lldb/source/Utility/DataEncoder.cpp

   1 //===-- DataEncoder.cpp ---------------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Utility/DataEncoder.h"
  10
  11 #include "lldb/Utility/DataBufferHeap.h"
  12 #include "lldb/Utility/Endian.h"
  13
  14 #include "llvm/Support/Endian.h"
  15 #include "llvm/Support/ErrorHandling.h"
  16
  17 #include <cstddef>
  18
  19 #include <cstring>
  20
  21 using namespace lldb;
  22 using namespace lldb_private;
  23 using namespace llvm::support::endian;
  24
  25 DataEncoder::DataEncoder()
  26     : m_data_sp(new DataBufferHeap()), m_byte_order(endian::InlHostByteOrder()),
  27       m_addr_size(sizeof(void *)) {}
  28
  29 DataEncoder::DataEncoder(const void *data, uint32_t length, ByteOrder endian,
  30                          uint8_t addr_size)
  31     : m_data_sp(new DataBufferHeap(data, length)), m_byte_order(endian),
  32       m_addr_size(addr_size) {}
  33
  34 DataEncoder::DataEncoder(ByteOrder endian, uint8_t addr_size)
  35     : m_data_sp(new DataBufferHeap()), m_byte_order(endian),
  36       m_addr_size(addr_size) {}
  37
  38 DataEncoder::~DataEncoder() = default;
  39
  40 llvm::ArrayRef<uint8_t> DataEncoder::GetData() const {
  41   return llvm::ArrayRef<uint8_t>(m_data_sp->GetBytes(), GetByteSize());
  42 }
  43
  44 size_t DataEncoder::GetByteSize() const { return m_data_sp->GetByteSize(); }
  45
  46 // Extract a single unsigned char from the binary data and update the offset
  47 // pointed to by "offset_ptr".
  48 //
  49 // RETURNS the byte that was extracted, or zero on failure.
  50 uint32_t DataEncoder::PutU8(uint32_t offset, uint8_t value) {
  51   if (ValidOffset(offset)) {
  52     m_data_sp->GetBytes()[offset] = value;
  53     return offset + 1;
  54   }
  55   return UINT32_MAX;
  56 }
  57
  58 uint32_t DataEncoder::PutU16(uint32_t offset, uint16_t value) {
  59   if (ValidOffsetForDataOfSize(offset, sizeof(value))) {
  60     if (m_byte_order != endian::InlHostByteOrder())
  61       write16be(m_data_sp->GetBytes() + offset, value);
  62     else
  63       write16le(m_data_sp->GetBytes() + offset, value);
  64
  65     return offset + sizeof(value);
  66   }
  67   return UINT32_MAX;
  68 }
  69
  70 uint32_t DataEncoder::PutU32(uint32_t offset, uint32_t value) {
  71   if (ValidOffsetForDataOfSize(offset, sizeof(value))) {
  72     if (m_byte_order != endian::InlHostByteOrder())
  73       write32be(m_data_sp->GetBytes() + offset, value);
  74     else
  75       write32le(m_data_sp->GetBytes() + offset, value);
  76
  77     return offset + sizeof(value);
  78   }
  79   return UINT32_MAX;
  80 }
  81
  82 uint32_t DataEncoder::PutU64(uint32_t offset, uint64_t value) {
  83   if (ValidOffsetForDataOfSize(offset, sizeof(value))) {
  84     if (m_byte_order != endian::InlHostByteOrder())
  85       write64be(m_data_sp->GetBytes() + offset, value);
  86     else
  87       write64le(m_data_sp->GetBytes() + offset, value);
  88
  89     return offset + sizeof(value);
  90   }
  91   return UINT32_MAX;
  92 }
  93
  94 uint32_t DataEncoder::PutUnsigned(uint32_t offset, uint32_t byte_size,
  95                                   uint64_t value) {
  96   switch (byte_size) {
  97   case 1:
  98     return PutU8(offset, value);
  99   case 2:
 100     return PutU16(offset, value);
 101   case 4:
 102     return PutU32(offset, value);
 103   case 8:
 104     return PutU64(offset, value);
 105   default:
 106     llvm_unreachable("GetMax64 unhandled case!");
 107   }
 108   return UINT32_MAX;
 109 }
 110
 111 uint32_t DataEncoder::PutData(uint32_t offset, const void *src,
 112                               uint32_t src_len) {
 113   if (src == nullptr || src_len == 0)
 114     return offset;
 115
 116   if (ValidOffsetForDataOfSize(offset, src_len)) {
 117     memcpy(m_data_sp->GetBytes() + offset, src, src_len);
 118     return offset + src_len;
 119   }
 120   return UINT32_MAX;
 121 }
 122
 123 uint32_t DataEncoder::PutAddress(uint32_t offset, lldb::addr_t addr) {
 124   return PutUnsigned(offset, m_addr_size, addr);
 125 }
 126
 127 uint32_t DataEncoder::PutCString(uint32_t offset, const char *cstr) {
 128   if (cstr != nullptr)
 129     return PutData(offset, cstr, strlen(cstr) + 1);
 130   return UINT32_MAX;
 131 }
 132
 133 void DataEncoder::AppendU8(uint8_t value) {
 134   m_data_sp->AppendData(&value, sizeof(value));
 135 }
 136
 137 void DataEncoder::AppendU16(uint16_t value) {
 138   uint32_t offset = m_data_sp->GetByteSize();
 139   m_data_sp->SetByteSize(m_data_sp->GetByteSize() + sizeof(value));
 140   PutU16(offset, value);
 141 }
 142
 143 void DataEncoder::AppendU32(uint32_t value) {
 144   uint32_t offset = m_data_sp->GetByteSize();
 145   m_data_sp->SetByteSize(m_data_sp->GetByteSize() + sizeof(value));
 146   PutU32(offset, value);
 147 }
 148
 149 void DataEncoder::AppendU64(uint64_t value) {
 150   uint32_t offset = m_data_sp->GetByteSize();
 151   m_data_sp->SetByteSize(m_data_sp->GetByteSize() + sizeof(value));
 152   PutU64(offset, value);
 153 }
 154
 155 void DataEncoder::AppendAddress(lldb::addr_t addr) {
 156   switch (m_addr_size) {
 157   case 4:
 158     AppendU32(addr);
 159     break;
 160   case 8:
 161     AppendU64(addr);
 162     break;
 163   default:
 164     llvm_unreachable("AppendAddress unhandled case!");
 165   }
 166 }
 167
 168 void DataEncoder::AppendData(llvm::StringRef data) {
 169   const char *bytes = data.data();
 170   const size_t length = data.size();
 171   if (bytes && length > 0)
 172     m_data_sp->AppendData(bytes, length);
 173 }
 174
 175 void DataEncoder::AppendData(llvm::ArrayRef<uint8_t> data) {
 176   const uint8_t *bytes = data.data();
 177   const size_t length = data.size();
 178   if (bytes && length > 0)
 179     m_data_sp->AppendData(bytes, length);
 180 }
 181
 182 void DataEncoder::AppendCString(llvm::StringRef data) {
 183   const char *bytes = data.data();
 184   const size_t length = data.size();
 185   if (bytes) {
 186     if (length > 0)
 187       m_data_sp->AppendData(bytes, length);
 188     if (length == 0 || bytes[length - 1] != '\0')
 189       AppendU8(0);
 190   }
 191 }