forked from OSchip/llvm-project
1246 lines
43 KiB
C++
1246 lines
43 KiB
C++
//===-- DataExtractor.cpp ---------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include "lldb/Utility/DataExtractor.h"
|
|
|
|
#include "lldb/lldb-defines.h" // for LLDB_INVALID_ADDRESS
|
|
#include "lldb/lldb-enumerations.h" // for ByteOrder::eByteOrderBig
|
|
#include "lldb/lldb-forward.h" // for DataBufferSP
|
|
#include "lldb/lldb-types.h" // for offset_t
|
|
|
|
#include "lldb/Utility/DataBuffer.h"
|
|
#include "lldb/Utility/DataBufferHeap.h"
|
|
#include "lldb/Utility/Endian.h"
|
|
#include "lldb/Utility/Log.h"
|
|
#include "lldb/Utility/Stream.h"
|
|
#include "lldb/Utility/StreamString.h"
|
|
#include "lldb/Utility/UUID.h"
|
|
|
|
#include "llvm/ADT/ArrayRef.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/Support/MD5.h"
|
|
#include "llvm/Support/MathExtras.h"
|
|
|
|
#include <algorithm> // for min
|
|
#include <array> // for array
|
|
#include <cassert>
|
|
#include <cstdint> // for uint8_t, uint32_t, uint64_t
|
|
#include <string>
|
|
|
|
#include <ctype.h> // for isprint
|
|
#include <inttypes.h> // for PRIx64, PRId64
|
|
#include <string.h> // for memcpy, memset, memchr
|
|
|
|
using namespace lldb;
|
|
using namespace lldb_private;
|
|
|
|
static inline uint16_t ReadInt16(const unsigned char *ptr, offset_t offset) {
|
|
uint16_t value;
|
|
memcpy(&value, ptr + offset, 2);
|
|
return value;
|
|
}
|
|
|
|
static inline uint32_t ReadInt32(const unsigned char *ptr,
|
|
offset_t offset = 0) {
|
|
uint32_t value;
|
|
memcpy(&value, ptr + offset, 4);
|
|
return value;
|
|
}
|
|
|
|
static inline uint64_t ReadInt64(const unsigned char *ptr,
|
|
offset_t offset = 0) {
|
|
uint64_t value;
|
|
memcpy(&value, ptr + offset, 8);
|
|
return value;
|
|
}
|
|
|
|
static inline uint16_t ReadInt16(const void *ptr) {
|
|
uint16_t value;
|
|
memcpy(&value, ptr, 2);
|
|
return value;
|
|
}
|
|
|
|
static inline uint16_t ReadSwapInt16(const unsigned char *ptr,
|
|
offset_t offset) {
|
|
uint16_t value;
|
|
memcpy(&value, ptr + offset, 2);
|
|
return llvm::ByteSwap_16(value);
|
|
}
|
|
|
|
static inline uint32_t ReadSwapInt32(const unsigned char *ptr,
|
|
offset_t offset) {
|
|
uint32_t value;
|
|
memcpy(&value, ptr + offset, 4);
|
|
return llvm::ByteSwap_32(value);
|
|
}
|
|
|
|
static inline uint64_t ReadSwapInt64(const unsigned char *ptr,
|
|
offset_t offset) {
|
|
uint64_t value;
|
|
memcpy(&value, ptr + offset, 8);
|
|
return llvm::ByteSwap_64(value);
|
|
}
|
|
|
|
static inline uint16_t ReadSwapInt16(const void *ptr) {
|
|
uint16_t value;
|
|
memcpy(&value, ptr, 2);
|
|
return llvm::ByteSwap_16(value);
|
|
}
|
|
|
|
static inline uint32_t ReadSwapInt32(const void *ptr) {
|
|
uint32_t value;
|
|
memcpy(&value, ptr, 4);
|
|
return llvm::ByteSwap_32(value);
|
|
}
|
|
|
|
static inline uint64_t ReadSwapInt64(const void *ptr) {
|
|
uint64_t value;
|
|
memcpy(&value, ptr, 8);
|
|
return llvm::ByteSwap_64(value);
|
|
}
|
|
|
|
DataExtractor::DataExtractor()
|
|
: m_start(nullptr), m_end(nullptr),
|
|
m_byte_order(endian::InlHostByteOrder()), m_addr_size(sizeof(void *)),
|
|
m_data_sp(), m_target_byte_size(1) {}
|
|
|
|
//----------------------------------------------------------------------
|
|
// This constructor allows us to use data that is owned by someone else.
|
|
// The data must stay around as long as this object is valid.
|
|
//----------------------------------------------------------------------
|
|
DataExtractor::DataExtractor(const void *data, offset_t length,
|
|
ByteOrder endian, uint32_t addr_size,
|
|
uint32_t target_byte_size /*=1*/)
|
|
: m_start(const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(data))),
|
|
m_end(const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(data)) +
|
|
length),
|
|
m_byte_order(endian), m_addr_size(addr_size), m_data_sp(),
|
|
m_target_byte_size(target_byte_size) {
|
|
#ifdef LLDB_CONFIGURATION_DEBUG
|
|
assert(addr_size == 4 || addr_size == 8);
|
|
#endif
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Make a shared pointer reference to the shared data in "data_sp" and
|
|
// set the endian swapping setting to "swap", and the address size to
|
|
// "addr_size". The shared data reference will ensure the data lives
|
|
// as long as any DataExtractor objects exist that have a reference to
|
|
// this data.
|
|
//----------------------------------------------------------------------
|
|
DataExtractor::DataExtractor(const DataBufferSP &data_sp, ByteOrder endian,
|
|
uint32_t addr_size,
|
|
uint32_t target_byte_size /*=1*/)
|
|
: m_start(nullptr), m_end(nullptr), m_byte_order(endian),
|
|
m_addr_size(addr_size), m_data_sp(),
|
|
m_target_byte_size(target_byte_size) {
|
|
#ifdef LLDB_CONFIGURATION_DEBUG
|
|
assert(addr_size == 4 || addr_size == 8);
|
|
#endif
|
|
SetData(data_sp);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Initialize this object with a subset of the data bytes in "data".
|
|
// If "data" contains shared data, then a reference to this shared
|
|
// data will added and the shared data will stay around as long
|
|
// as any object contains a reference to that data. The endian
|
|
// swap and address size settings are copied from "data".
|
|
//----------------------------------------------------------------------
|
|
DataExtractor::DataExtractor(const DataExtractor &data, offset_t offset,
|
|
offset_t length, uint32_t target_byte_size /*=1*/)
|
|
: m_start(nullptr), m_end(nullptr), m_byte_order(data.m_byte_order),
|
|
m_addr_size(data.m_addr_size), m_data_sp(),
|
|
m_target_byte_size(target_byte_size) {
|
|
#ifdef LLDB_CONFIGURATION_DEBUG
|
|
assert(m_addr_size == 4 || m_addr_size == 8);
|
|
#endif
|
|
if (data.ValidOffset(offset)) {
|
|
offset_t bytes_available = data.GetByteSize() - offset;
|
|
if (length > bytes_available)
|
|
length = bytes_available;
|
|
SetData(data, offset, length);
|
|
}
|
|
}
|
|
|
|
DataExtractor::DataExtractor(const DataExtractor &rhs)
|
|
: m_start(rhs.m_start), m_end(rhs.m_end), m_byte_order(rhs.m_byte_order),
|
|
m_addr_size(rhs.m_addr_size), m_data_sp(rhs.m_data_sp),
|
|
m_target_byte_size(rhs.m_target_byte_size) {
|
|
#ifdef LLDB_CONFIGURATION_DEBUG
|
|
assert(m_addr_size == 4 || m_addr_size == 8);
|
|
#endif
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Assignment operator
|
|
//----------------------------------------------------------------------
|
|
const DataExtractor &DataExtractor::operator=(const DataExtractor &rhs) {
|
|
if (this != &rhs) {
|
|
m_start = rhs.m_start;
|
|
m_end = rhs.m_end;
|
|
m_byte_order = rhs.m_byte_order;
|
|
m_addr_size = rhs.m_addr_size;
|
|
m_data_sp = rhs.m_data_sp;
|
|
}
|
|
return *this;
|
|
}
|
|
|
|
DataExtractor::~DataExtractor() = default;
|
|
|
|
//------------------------------------------------------------------
|
|
// Clears the object contents back to a default invalid state, and
|
|
// release any references to shared data that this object may
|
|
// contain.
|
|
//------------------------------------------------------------------
|
|
void DataExtractor::Clear() {
|
|
m_start = nullptr;
|
|
m_end = nullptr;
|
|
m_byte_order = endian::InlHostByteOrder();
|
|
m_addr_size = sizeof(void *);
|
|
m_data_sp.reset();
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// If this object contains shared data, this function returns the
|
|
// offset into that shared data. Else zero is returned.
|
|
//------------------------------------------------------------------
|
|
size_t DataExtractor::GetSharedDataOffset() const {
|
|
if (m_start != nullptr) {
|
|
const DataBuffer *data = m_data_sp.get();
|
|
if (data != nullptr) {
|
|
const uint8_t *data_bytes = data->GetBytes();
|
|
if (data_bytes != nullptr) {
|
|
assert(m_start >= data_bytes);
|
|
return m_start - data_bytes;
|
|
}
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Set the data with which this object will extract from to data
|
|
// starting at BYTES and set the length of the data to LENGTH bytes
|
|
// long. The data is externally owned must be around at least as
|
|
// long as this object points to the data. No copy of the data is
|
|
// made, this object just refers to this data and can extract from
|
|
// it. If this object refers to any shared data upon entry, the
|
|
// reference to that data will be released. Is SWAP is set to true,
|
|
// any data extracted will be endian swapped.
|
|
//----------------------------------------------------------------------
|
|
lldb::offset_t DataExtractor::SetData(const void *bytes, offset_t length,
|
|
ByteOrder endian) {
|
|
m_byte_order = endian;
|
|
m_data_sp.reset();
|
|
if (bytes == nullptr || length == 0) {
|
|
m_start = nullptr;
|
|
m_end = nullptr;
|
|
} else {
|
|
m_start = const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(bytes));
|
|
m_end = m_start + length;
|
|
}
|
|
return GetByteSize();
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Assign the data for this object to be a subrange in "data"
|
|
// starting "data_offset" bytes into "data" and ending "data_length"
|
|
// bytes later. If "data_offset" is not a valid offset into "data",
|
|
// then this object will contain no bytes. If "data_offset" is
|
|
// within "data" yet "data_length" is too large, the length will be
|
|
// capped at the number of bytes remaining in "data". If "data"
|
|
// contains a shared pointer to other data, then a ref counted
|
|
// pointer to that data will be made in this object. If "data"
|
|
// doesn't contain a shared pointer to data, then the bytes referred
|
|
// to in "data" will need to exist at least as long as this object
|
|
// refers to those bytes. The address size and endian swap settings
|
|
// are copied from the current values in "data".
|
|
//----------------------------------------------------------------------
|
|
lldb::offset_t DataExtractor::SetData(const DataExtractor &data,
|
|
offset_t data_offset,
|
|
offset_t data_length) {
|
|
m_addr_size = data.m_addr_size;
|
|
#ifdef LLDB_CONFIGURATION_DEBUG
|
|
assert(m_addr_size == 4 || m_addr_size == 8);
|
|
#endif
|
|
// If "data" contains shared pointer to data, then we can use that
|
|
if (data.m_data_sp) {
|
|
m_byte_order = data.m_byte_order;
|
|
return SetData(data.m_data_sp, data.GetSharedDataOffset() + data_offset,
|
|
data_length);
|
|
}
|
|
|
|
// We have a DataExtractor object that just has a pointer to bytes
|
|
if (data.ValidOffset(data_offset)) {
|
|
if (data_length > data.GetByteSize() - data_offset)
|
|
data_length = data.GetByteSize() - data_offset;
|
|
return SetData(data.GetDataStart() + data_offset, data_length,
|
|
data.GetByteOrder());
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Assign the data for this object to be a subrange of the shared
|
|
// data in "data_sp" starting "data_offset" bytes into "data_sp"
|
|
// and ending "data_length" bytes later. If "data_offset" is not
|
|
// a valid offset into "data_sp", then this object will contain no
|
|
// bytes. If "data_offset" is within "data_sp" yet "data_length" is
|
|
// too large, the length will be capped at the number of bytes
|
|
// remaining in "data_sp". A ref counted pointer to the data in
|
|
// "data_sp" will be made in this object IF the number of bytes this
|
|
// object refers to in greater than zero (if at least one byte was
|
|
// available starting at "data_offset") to ensure the data stays
|
|
// around as long as it is needed. The address size and endian swap
|
|
// settings will remain unchanged from their current settings.
|
|
//----------------------------------------------------------------------
|
|
lldb::offset_t DataExtractor::SetData(const DataBufferSP &data_sp,
|
|
offset_t data_offset,
|
|
offset_t data_length) {
|
|
m_start = m_end = nullptr;
|
|
|
|
if (data_length > 0) {
|
|
m_data_sp = data_sp;
|
|
if (data_sp) {
|
|
const size_t data_size = data_sp->GetByteSize();
|
|
if (data_offset < data_size) {
|
|
m_start = data_sp->GetBytes() + data_offset;
|
|
const size_t bytes_left = data_size - data_offset;
|
|
// Cap the length of we asked for too many
|
|
if (data_length <= bytes_left)
|
|
m_end = m_start + data_length; // We got all the bytes we wanted
|
|
else
|
|
m_end = m_start + bytes_left; // Not all the bytes requested were
|
|
// available in the shared data
|
|
}
|
|
}
|
|
}
|
|
|
|
size_t new_size = GetByteSize();
|
|
|
|
// Don't hold a shared pointer to the data buffer if we don't share
|
|
// any valid bytes in the shared buffer.
|
|
if (new_size == 0)
|
|
m_data_sp.reset();
|
|
|
|
return new_size;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Extract a single unsigned char from the binary data and update
|
|
// the offset pointed to by "offset_ptr".
|
|
//
|
|
// RETURNS the byte that was extracted, or zero on failure.
|
|
//----------------------------------------------------------------------
|
|
uint8_t DataExtractor::GetU8(offset_t *offset_ptr) const {
|
|
const uint8_t *data = (const uint8_t *)GetData(offset_ptr, 1);
|
|
if (data)
|
|
return *data;
|
|
return 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Extract "count" unsigned chars from the binary data and update the
|
|
// offset pointed to by "offset_ptr". The extracted data is copied into
|
|
// "dst".
|
|
//
|
|
// RETURNS the non-nullptr buffer pointer upon successful extraction of
|
|
// all the requested bytes, or nullptr when the data is not available in
|
|
// the buffer due to being out of bounds, or insufficient data.
|
|
//----------------------------------------------------------------------
|
|
void *DataExtractor::GetU8(offset_t *offset_ptr, void *dst,
|
|
uint32_t count) const {
|
|
const uint8_t *data = (const uint8_t *)GetData(offset_ptr, count);
|
|
if (data) {
|
|
// Copy the data into the buffer
|
|
memcpy(dst, data, count);
|
|
// Return a non-nullptr pointer to the converted data as an indicator of
|
|
// success
|
|
return dst;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Extract a single uint16_t from the data and update the offset
|
|
// pointed to by "offset_ptr".
|
|
//
|
|
// RETURNS the uint16_t that was extracted, or zero on failure.
|
|
//----------------------------------------------------------------------
|
|
uint16_t DataExtractor::GetU16(offset_t *offset_ptr) const {
|
|
uint16_t val = 0;
|
|
const uint8_t *data = (const uint8_t *)GetData(offset_ptr, sizeof(val));
|
|
if (data) {
|
|
if (m_byte_order != endian::InlHostByteOrder())
|
|
val = ReadSwapInt16(data);
|
|
else
|
|
val = ReadInt16(data);
|
|
}
|
|
return val;
|
|
}
|
|
|
|
uint16_t DataExtractor::GetU16_unchecked(offset_t *offset_ptr) const {
|
|
uint16_t val;
|
|
if (m_byte_order == endian::InlHostByteOrder())
|
|
val = ReadInt16(m_start, *offset_ptr);
|
|
else
|
|
val = ReadSwapInt16(m_start, *offset_ptr);
|
|
*offset_ptr += sizeof(val);
|
|
return val;
|
|
}
|
|
|
|
uint32_t DataExtractor::GetU32_unchecked(offset_t *offset_ptr) const {
|
|
uint32_t val;
|
|
if (m_byte_order == endian::InlHostByteOrder())
|
|
val = ReadInt32(m_start, *offset_ptr);
|
|
else
|
|
val = ReadSwapInt32(m_start, *offset_ptr);
|
|
*offset_ptr += sizeof(val);
|
|
return val;
|
|
}
|
|
|
|
uint64_t DataExtractor::GetU64_unchecked(offset_t *offset_ptr) const {
|
|
uint64_t val;
|
|
if (m_byte_order == endian::InlHostByteOrder())
|
|
val = ReadInt64(m_start, *offset_ptr);
|
|
else
|
|
val = ReadSwapInt64(m_start, *offset_ptr);
|
|
*offset_ptr += sizeof(val);
|
|
return val;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Extract "count" uint16_t values from the binary data and update
|
|
// the offset pointed to by "offset_ptr". The extracted data is
|
|
// copied into "dst".
|
|
//
|
|
// RETURNS the non-nullptr buffer pointer upon successful extraction of
|
|
// all the requested bytes, or nullptr when the data is not available
|
|
// in the buffer due to being out of bounds, or insufficient data.
|
|
//----------------------------------------------------------------------
|
|
void *DataExtractor::GetU16(offset_t *offset_ptr, void *void_dst,
|
|
uint32_t count) const {
|
|
const size_t src_size = sizeof(uint16_t) * count;
|
|
const uint16_t *src = (const uint16_t *)GetData(offset_ptr, src_size);
|
|
if (src) {
|
|
if (m_byte_order != endian::InlHostByteOrder()) {
|
|
uint16_t *dst_pos = (uint16_t *)void_dst;
|
|
uint16_t *dst_end = dst_pos + count;
|
|
const uint16_t *src_pos = src;
|
|
while (dst_pos < dst_end) {
|
|
*dst_pos = ReadSwapInt16(src_pos);
|
|
++dst_pos;
|
|
++src_pos;
|
|
}
|
|
} else {
|
|
memcpy(void_dst, src, src_size);
|
|
}
|
|
// Return a non-nullptr pointer to the converted data as an indicator of
|
|
// success
|
|
return void_dst;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Extract a single uint32_t from the data and update the offset
|
|
// pointed to by "offset_ptr".
|
|
//
|
|
// RETURNS the uint32_t that was extracted, or zero on failure.
|
|
//----------------------------------------------------------------------
|
|
uint32_t DataExtractor::GetU32(offset_t *offset_ptr) const {
|
|
uint32_t val = 0;
|
|
const uint8_t *data = (const uint8_t *)GetData(offset_ptr, sizeof(val));
|
|
if (data) {
|
|
if (m_byte_order != endian::InlHostByteOrder()) {
|
|
val = ReadSwapInt32(data);
|
|
} else {
|
|
memcpy(&val, data, 4);
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Extract "count" uint32_t values from the binary data and update
|
|
// the offset pointed to by "offset_ptr". The extracted data is
|
|
// copied into "dst".
|
|
//
|
|
// RETURNS the non-nullptr buffer pointer upon successful extraction of
|
|
// all the requested bytes, or nullptr when the data is not available
|
|
// in the buffer due to being out of bounds, or insufficient data.
|
|
//----------------------------------------------------------------------
|
|
void *DataExtractor::GetU32(offset_t *offset_ptr, void *void_dst,
|
|
uint32_t count) const {
|
|
const size_t src_size = sizeof(uint32_t) * count;
|
|
const uint32_t *src = (const uint32_t *)GetData(offset_ptr, src_size);
|
|
if (src) {
|
|
if (m_byte_order != endian::InlHostByteOrder()) {
|
|
uint32_t *dst_pos = (uint32_t *)void_dst;
|
|
uint32_t *dst_end = dst_pos + count;
|
|
const uint32_t *src_pos = src;
|
|
while (dst_pos < dst_end) {
|
|
*dst_pos = ReadSwapInt32(src_pos);
|
|
++dst_pos;
|
|
++src_pos;
|
|
}
|
|
} else {
|
|
memcpy(void_dst, src, src_size);
|
|
}
|
|
// Return a non-nullptr pointer to the converted data as an indicator of
|
|
// success
|
|
return void_dst;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Extract a single uint64_t from the data and update the offset
|
|
// pointed to by "offset_ptr".
|
|
//
|
|
// RETURNS the uint64_t that was extracted, or zero on failure.
|
|
//----------------------------------------------------------------------
|
|
uint64_t DataExtractor::GetU64(offset_t *offset_ptr) const {
|
|
uint64_t val = 0;
|
|
const uint8_t *data = (const uint8_t *)GetData(offset_ptr, sizeof(val));
|
|
if (data) {
|
|
if (m_byte_order != endian::InlHostByteOrder()) {
|
|
val = ReadSwapInt64(data);
|
|
} else {
|
|
memcpy(&val, data, 8);
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// GetU64
|
|
//
|
|
// Get multiple consecutive 64 bit values. Return true if the entire
|
|
// read succeeds and increment the offset pointed to by offset_ptr, else
|
|
// return false and leave the offset pointed to by offset_ptr unchanged.
|
|
//----------------------------------------------------------------------
|
|
void *DataExtractor::GetU64(offset_t *offset_ptr, void *void_dst,
|
|
uint32_t count) const {
|
|
const size_t src_size = sizeof(uint64_t) * count;
|
|
const uint64_t *src = (const uint64_t *)GetData(offset_ptr, src_size);
|
|
if (src) {
|
|
if (m_byte_order != endian::InlHostByteOrder()) {
|
|
uint64_t *dst_pos = (uint64_t *)void_dst;
|
|
uint64_t *dst_end = dst_pos + count;
|
|
const uint64_t *src_pos = src;
|
|
while (dst_pos < dst_end) {
|
|
*dst_pos = ReadSwapInt64(src_pos);
|
|
++dst_pos;
|
|
++src_pos;
|
|
}
|
|
} else {
|
|
memcpy(void_dst, src, src_size);
|
|
}
|
|
// Return a non-nullptr pointer to the converted data as an indicator of
|
|
// success
|
|
return void_dst;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Extract a single integer value from the data and update the offset
|
|
// pointed to by "offset_ptr". The size of the extracted integer
|
|
// is specified by the "byte_size" argument. "byte_size" should have
|
|
// a value between 1 and 4 since the return value is only 32 bits
|
|
// wide. Any "byte_size" values less than 1 or greater than 4 will
|
|
// result in nothing being extracted, and zero being returned.
|
|
//
|
|
// RETURNS the integer value that was extracted, or zero on failure.
|
|
//----------------------------------------------------------------------
|
|
uint32_t DataExtractor::GetMaxU32(offset_t *offset_ptr,
|
|
size_t byte_size) const {
|
|
switch (byte_size) {
|
|
case 1:
|
|
return GetU8(offset_ptr);
|
|
break;
|
|
case 2:
|
|
return GetU16(offset_ptr);
|
|
break;
|
|
case 4:
|
|
return GetU32(offset_ptr);
|
|
break;
|
|
default:
|
|
assert(false && "GetMaxU32 unhandled case!");
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Extract a single integer value from the data and update the offset
|
|
// pointed to by "offset_ptr". The size of the extracted integer
|
|
// is specified by the "byte_size" argument. "byte_size" should have
|
|
// a value >= 1 and <= 8 since the return value is only 64 bits
|
|
// wide. Any "byte_size" values less than 1 or greater than 8 will
|
|
// result in nothing being extracted, and zero being returned.
|
|
//
|
|
// RETURNS the integer value that was extracted, or zero on failure.
|
|
//----------------------------------------------------------------------
|
|
uint64_t DataExtractor::GetMaxU64(offset_t *offset_ptr, size_t size) const {
|
|
switch (size) {
|
|
case 1:
|
|
return GetU8(offset_ptr);
|
|
break;
|
|
case 2:
|
|
return GetU16(offset_ptr);
|
|
break;
|
|
case 4:
|
|
return GetU32(offset_ptr);
|
|
break;
|
|
case 8:
|
|
return GetU64(offset_ptr);
|
|
break;
|
|
default:
|
|
assert(false && "GetMax64 unhandled case!");
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint64_t DataExtractor::GetMaxU64_unchecked(offset_t *offset_ptr,
|
|
size_t size) const {
|
|
switch (size) {
|
|
case 1:
|
|
return GetU8_unchecked(offset_ptr);
|
|
break;
|
|
case 2:
|
|
return GetU16_unchecked(offset_ptr);
|
|
break;
|
|
case 4:
|
|
return GetU32_unchecked(offset_ptr);
|
|
break;
|
|
case 8:
|
|
return GetU64_unchecked(offset_ptr);
|
|
break;
|
|
default:
|
|
assert(false && "GetMax64 unhandled case!");
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
int64_t DataExtractor::GetMaxS64(offset_t *offset_ptr, size_t size) const {
|
|
switch (size) {
|
|
case 1:
|
|
return (int8_t)GetU8(offset_ptr);
|
|
break;
|
|
case 2:
|
|
return (int16_t)GetU16(offset_ptr);
|
|
break;
|
|
case 4:
|
|
return (int32_t)GetU32(offset_ptr);
|
|
break;
|
|
case 8:
|
|
return (int64_t)GetU64(offset_ptr);
|
|
break;
|
|
default:
|
|
assert(false && "GetMax64 unhandled case!");
|
|
break;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
uint64_t DataExtractor::GetMaxU64Bitfield(offset_t *offset_ptr, size_t size,
|
|
uint32_t bitfield_bit_size,
|
|
uint32_t bitfield_bit_offset) const {
|
|
uint64_t uval64 = GetMaxU64(offset_ptr, size);
|
|
if (bitfield_bit_size > 0) {
|
|
int32_t lsbcount = bitfield_bit_offset;
|
|
if (m_byte_order == eByteOrderBig)
|
|
lsbcount = size * 8 - bitfield_bit_offset - bitfield_bit_size;
|
|
if (lsbcount > 0)
|
|
uval64 >>= lsbcount;
|
|
uint64_t bitfield_mask = ((1ul << bitfield_bit_size) - 1);
|
|
if (!bitfield_mask && bitfield_bit_offset == 0 && bitfield_bit_size == 64)
|
|
return uval64;
|
|
uval64 &= bitfield_mask;
|
|
}
|
|
return uval64;
|
|
}
|
|
|
|
int64_t DataExtractor::GetMaxS64Bitfield(offset_t *offset_ptr, size_t size,
|
|
uint32_t bitfield_bit_size,
|
|
uint32_t bitfield_bit_offset) const {
|
|
int64_t sval64 = GetMaxS64(offset_ptr, size);
|
|
if (bitfield_bit_size > 0) {
|
|
int32_t lsbcount = bitfield_bit_offset;
|
|
if (m_byte_order == eByteOrderBig)
|
|
lsbcount = size * 8 - bitfield_bit_offset - bitfield_bit_size;
|
|
if (lsbcount > 0)
|
|
sval64 >>= lsbcount;
|
|
uint64_t bitfield_mask = (((uint64_t)1) << bitfield_bit_size) - 1;
|
|
sval64 &= bitfield_mask;
|
|
// sign extend if needed
|
|
if (sval64 & (((uint64_t)1) << (bitfield_bit_size - 1)))
|
|
sval64 |= ~bitfield_mask;
|
|
}
|
|
return sval64;
|
|
}
|
|
|
|
float DataExtractor::GetFloat(offset_t *offset_ptr) const {
|
|
typedef float float_type;
|
|
float_type val = 0.0;
|
|
const size_t src_size = sizeof(float_type);
|
|
const float_type *src = (const float_type *)GetData(offset_ptr, src_size);
|
|
if (src) {
|
|
if (m_byte_order != endian::InlHostByteOrder()) {
|
|
const uint8_t *src_data = (const uint8_t *)src;
|
|
uint8_t *dst_data = (uint8_t *)&val;
|
|
for (size_t i = 0; i < sizeof(float_type); ++i)
|
|
dst_data[sizeof(float_type) - 1 - i] = src_data[i];
|
|
} else {
|
|
val = *src;
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
|
|
double DataExtractor::GetDouble(offset_t *offset_ptr) const {
|
|
typedef double float_type;
|
|
float_type val = 0.0;
|
|
const size_t src_size = sizeof(float_type);
|
|
const float_type *src = (const float_type *)GetData(offset_ptr, src_size);
|
|
if (src) {
|
|
if (m_byte_order != endian::InlHostByteOrder()) {
|
|
const uint8_t *src_data = (const uint8_t *)src;
|
|
uint8_t *dst_data = (uint8_t *)&val;
|
|
for (size_t i = 0; i < sizeof(float_type); ++i)
|
|
dst_data[sizeof(float_type) - 1 - i] = src_data[i];
|
|
} else {
|
|
val = *src;
|
|
}
|
|
}
|
|
return val;
|
|
}
|
|
|
|
long double DataExtractor::GetLongDouble(offset_t *offset_ptr) const {
|
|
long double val = 0.0;
|
|
#if defined(__i386__) || defined(__amd64__) || defined(__x86_64__) || \
|
|
defined(_M_IX86) || defined(_M_IA64) || defined(_M_X64)
|
|
*offset_ptr += CopyByteOrderedData(*offset_ptr, 10, &val, sizeof(val),
|
|
endian::InlHostByteOrder());
|
|
#else
|
|
*offset_ptr += CopyByteOrderedData(*offset_ptr, sizeof(val), &val,
|
|
sizeof(val), endian::InlHostByteOrder());
|
|
#endif
|
|
return val;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Extract a single address from the data and update the offset
|
|
// pointed to by "offset_ptr". The size of the extracted address
|
|
// comes from the "this->m_addr_size" member variable and should be
|
|
// set correctly prior to extracting any address values.
|
|
//
|
|
// RETURNS the address that was extracted, or zero on failure.
|
|
//------------------------------------------------------------------
|
|
uint64_t DataExtractor::GetAddress(offset_t *offset_ptr) const {
|
|
#ifdef LLDB_CONFIGURATION_DEBUG
|
|
assert(m_addr_size == 4 || m_addr_size == 8);
|
|
#endif
|
|
return GetMaxU64(offset_ptr, m_addr_size);
|
|
}
|
|
|
|
uint64_t DataExtractor::GetAddress_unchecked(offset_t *offset_ptr) const {
|
|
#ifdef LLDB_CONFIGURATION_DEBUG
|
|
assert(m_addr_size == 4 || m_addr_size == 8);
|
|
#endif
|
|
return GetMaxU64_unchecked(offset_ptr, m_addr_size);
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Extract a single pointer from the data and update the offset
|
|
// pointed to by "offset_ptr". The size of the extracted pointer
|
|
// comes from the "this->m_addr_size" member variable and should be
|
|
// set correctly prior to extracting any pointer values.
|
|
//
|
|
// RETURNS the pointer that was extracted, or zero on failure.
|
|
//------------------------------------------------------------------
|
|
uint64_t DataExtractor::GetPointer(offset_t *offset_ptr) const {
|
|
#ifdef LLDB_CONFIGURATION_DEBUG
|
|
assert(m_addr_size == 4 || m_addr_size == 8);
|
|
#endif
|
|
return GetMaxU64(offset_ptr, m_addr_size);
|
|
}
|
|
|
|
size_t DataExtractor::ExtractBytes(offset_t offset, offset_t length,
|
|
ByteOrder dst_byte_order, void *dst) const {
|
|
const uint8_t *src = PeekData(offset, length);
|
|
if (src) {
|
|
if (dst_byte_order != GetByteOrder()) {
|
|
// Validate that only a word- or register-sized dst is byte swapped
|
|
assert(length == 1 || length == 2 || length == 4 || length == 8 ||
|
|
length == 10 || length == 16 || length == 32);
|
|
|
|
for (uint32_t i = 0; i < length; ++i)
|
|
((uint8_t *)dst)[i] = src[length - i - 1];
|
|
} else
|
|
::memcpy(dst, src, length);
|
|
return length;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Extract data as it exists in target memory
|
|
lldb::offset_t DataExtractor::CopyData(offset_t offset, offset_t length,
|
|
void *dst) const {
|
|
const uint8_t *src = PeekData(offset, length);
|
|
if (src) {
|
|
::memcpy(dst, src, length);
|
|
return length;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// Extract data and swap if needed when doing the copy
|
|
lldb::offset_t
|
|
DataExtractor::CopyByteOrderedData(offset_t src_offset, offset_t src_len,
|
|
void *dst_void_ptr, offset_t dst_len,
|
|
ByteOrder dst_byte_order) const {
|
|
// Validate the source info
|
|
if (!ValidOffsetForDataOfSize(src_offset, src_len))
|
|
assert(ValidOffsetForDataOfSize(src_offset, src_len));
|
|
assert(src_len > 0);
|
|
assert(m_byte_order == eByteOrderBig || m_byte_order == eByteOrderLittle);
|
|
|
|
// Validate the destination info
|
|
assert(dst_void_ptr != nullptr);
|
|
assert(dst_len > 0);
|
|
assert(dst_byte_order == eByteOrderBig || dst_byte_order == eByteOrderLittle);
|
|
|
|
// Validate that only a word- or register-sized dst is byte swapped
|
|
assert(dst_byte_order == m_byte_order || dst_len == 1 || dst_len == 2 ||
|
|
dst_len == 4 || dst_len == 8 || dst_len == 10 || dst_len == 16 ||
|
|
dst_len == 32);
|
|
|
|
// Must have valid byte orders set in this object and for destination
|
|
if (!(dst_byte_order == eByteOrderBig ||
|
|
dst_byte_order == eByteOrderLittle) ||
|
|
!(m_byte_order == eByteOrderBig || m_byte_order == eByteOrderLittle))
|
|
return 0;
|
|
|
|
uint8_t *dst = (uint8_t *)dst_void_ptr;
|
|
const uint8_t *src = (const uint8_t *)PeekData(src_offset, src_len);
|
|
if (src) {
|
|
if (dst_len >= src_len) {
|
|
// We are copying the entire value from src into dst.
|
|
// Calculate how many, if any, zeroes we need for the most
|
|
// significant bytes if "dst_len" is greater than "src_len"...
|
|
const size_t num_zeroes = dst_len - src_len;
|
|
if (dst_byte_order == eByteOrderBig) {
|
|
// Big endian, so we lead with zeroes...
|
|
if (num_zeroes > 0)
|
|
::memset(dst, 0, num_zeroes);
|
|
// Then either copy or swap the rest
|
|
if (m_byte_order == eByteOrderBig) {
|
|
::memcpy(dst + num_zeroes, src, src_len);
|
|
} else {
|
|
for (uint32_t i = 0; i < src_len; ++i)
|
|
dst[i + num_zeroes] = src[src_len - 1 - i];
|
|
}
|
|
} else {
|
|
// Little endian destination, so we lead the value bytes
|
|
if (m_byte_order == eByteOrderBig) {
|
|
for (uint32_t i = 0; i < src_len; ++i)
|
|
dst[i] = src[src_len - 1 - i];
|
|
} else {
|
|
::memcpy(dst, src, src_len);
|
|
}
|
|
// And zero the rest...
|
|
if (num_zeroes > 0)
|
|
::memset(dst + src_len, 0, num_zeroes);
|
|
}
|
|
return src_len;
|
|
} else {
|
|
// We are only copying some of the value from src into dst..
|
|
|
|
if (dst_byte_order == eByteOrderBig) {
|
|
// Big endian dst
|
|
if (m_byte_order == eByteOrderBig) {
|
|
// Big endian dst, with big endian src
|
|
::memcpy(dst, src + (src_len - dst_len), dst_len);
|
|
} else {
|
|
// Big endian dst, with little endian src
|
|
for (uint32_t i = 0; i < dst_len; ++i)
|
|
dst[i] = src[dst_len - 1 - i];
|
|
}
|
|
} else {
|
|
// Little endian dst
|
|
if (m_byte_order == eByteOrderBig) {
|
|
// Little endian dst, with big endian src
|
|
for (uint32_t i = 0; i < dst_len; ++i)
|
|
dst[i] = src[src_len - 1 - i];
|
|
} else {
|
|
// Little endian dst, with big endian src
|
|
::memcpy(dst, src, dst_len);
|
|
}
|
|
}
|
|
return dst_len;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Extracts a variable length NULL terminated C string from
|
|
// the data at the offset pointed to by "offset_ptr". The
|
|
// "offset_ptr" will be updated with the offset of the byte that
|
|
// follows the NULL terminator byte.
|
|
//
|
|
// If the offset pointed to by "offset_ptr" is out of bounds, or if
|
|
// "length" is non-zero and there aren't enough available
|
|
// bytes, nullptr will be returned and "offset_ptr" will not be
|
|
// updated.
|
|
//----------------------------------------------------------------------
|
|
const char *DataExtractor::GetCStr(offset_t *offset_ptr) const {
|
|
const char *cstr = (const char *)PeekData(*offset_ptr, 1);
|
|
if (cstr) {
|
|
const char *cstr_end = cstr;
|
|
const char *end = (const char *)m_end;
|
|
while (cstr_end < end && *cstr_end)
|
|
++cstr_end;
|
|
|
|
// Now we are either at the end of the data or we point to the
|
|
// NULL C string terminator with cstr_end...
|
|
if (*cstr_end == '\0') {
|
|
// Advance the offset with one extra byte for the NULL terminator
|
|
*offset_ptr += (cstr_end - cstr + 1);
|
|
return cstr;
|
|
}
|
|
|
|
// We reached the end of the data without finding a NULL C string
|
|
// terminator. Fall through and return nullptr otherwise anyone that
|
|
// would have used the result as a C string can wander into
|
|
// unknown memory...
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Extracts a NULL terminated C string from the fixed length field of
|
|
// length "len" at the offset pointed to by "offset_ptr".
|
|
// The "offset_ptr" will be updated with the offset of the byte that
|
|
// follows the fixed length field.
|
|
//
|
|
// If the offset pointed to by "offset_ptr" is out of bounds, or if
|
|
// the offset plus the length of the field is out of bounds, or if the
|
|
// field does not contain a NULL terminator byte, nullptr will be returned
|
|
// and "offset_ptr" will not be updated.
|
|
//----------------------------------------------------------------------
|
|
const char *DataExtractor::GetCStr(offset_t *offset_ptr, offset_t len) const {
|
|
const char *cstr = (const char *)PeekData(*offset_ptr, len);
|
|
if (cstr != nullptr) {
|
|
if (memchr(cstr, '\0', len) == nullptr) {
|
|
return nullptr;
|
|
}
|
|
*offset_ptr += len;
|
|
return cstr;
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
//------------------------------------------------------------------
|
|
// Peeks at a string in the contained data. No verification is done
|
|
// to make sure the entire string lies within the bounds of this
|
|
// object's data, only "offset" is verified to be a valid offset.
|
|
//
|
|
// Returns a valid C string pointer if "offset" is a valid offset in
|
|
// this object's data, else nullptr is returned.
|
|
//------------------------------------------------------------------
|
|
const char *DataExtractor::PeekCStr(offset_t offset) const {
|
|
return (const char *)PeekData(offset, 1);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Extracts an unsigned LEB128 number from this object's data
|
|
// starting at the offset pointed to by "offset_ptr". The offset
|
|
// pointed to by "offset_ptr" will be updated with the offset of the
|
|
// byte following the last extracted byte.
|
|
//
|
|
// Returned the extracted integer value.
|
|
//----------------------------------------------------------------------
|
|
uint64_t DataExtractor::GetULEB128(offset_t *offset_ptr) const {
|
|
const uint8_t *src = (const uint8_t *)PeekData(*offset_ptr, 1);
|
|
if (src == nullptr)
|
|
return 0;
|
|
|
|
const uint8_t *end = m_end;
|
|
|
|
if (src < end) {
|
|
uint64_t result = *src++;
|
|
if (result >= 0x80) {
|
|
result &= 0x7f;
|
|
int shift = 7;
|
|
while (src < end) {
|
|
uint8_t byte = *src++;
|
|
result |= (uint64_t)(byte & 0x7f) << shift;
|
|
if ((byte & 0x80) == 0)
|
|
break;
|
|
shift += 7;
|
|
}
|
|
}
|
|
*offset_ptr = src - m_start;
|
|
return result;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Extracts an signed LEB128 number from this object's data
|
|
// starting at the offset pointed to by "offset_ptr". The offset
|
|
// pointed to by "offset_ptr" will be updated with the offset of the
|
|
// byte following the last extracted byte.
|
|
//
|
|
// Returned the extracted integer value.
|
|
//----------------------------------------------------------------------
|
|
int64_t DataExtractor::GetSLEB128(offset_t *offset_ptr) const {
|
|
const uint8_t *src = (const uint8_t *)PeekData(*offset_ptr, 1);
|
|
if (src == nullptr)
|
|
return 0;
|
|
|
|
const uint8_t *end = m_end;
|
|
|
|
if (src < end) {
|
|
int64_t result = 0;
|
|
int shift = 0;
|
|
int size = sizeof(int64_t) * 8;
|
|
|
|
uint8_t byte = 0;
|
|
int bytecount = 0;
|
|
|
|
while (src < end) {
|
|
bytecount++;
|
|
byte = *src++;
|
|
result |= (int64_t)(byte & 0x7f) << shift;
|
|
shift += 7;
|
|
if ((byte & 0x80) == 0)
|
|
break;
|
|
}
|
|
|
|
// Sign bit of byte is 2nd high order bit (0x40)
|
|
if (shift < size && (byte & 0x40))
|
|
result |= -(1 << shift);
|
|
|
|
*offset_ptr += bytecount;
|
|
return result;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Skips a ULEB128 number (signed or unsigned) from this object's
|
|
// data starting at the offset pointed to by "offset_ptr". The
|
|
// offset pointed to by "offset_ptr" will be updated with the offset
|
|
// of the byte following the last extracted byte.
|
|
//
|
|
// Returns the number of bytes consumed during the extraction.
|
|
//----------------------------------------------------------------------
|
|
uint32_t DataExtractor::Skip_LEB128(offset_t *offset_ptr) const {
|
|
uint32_t bytes_consumed = 0;
|
|
const uint8_t *src = (const uint8_t *)PeekData(*offset_ptr, 1);
|
|
if (src == nullptr)
|
|
return 0;
|
|
|
|
const uint8_t *end = m_end;
|
|
|
|
if (src < end) {
|
|
const uint8_t *src_pos = src;
|
|
while ((src_pos < end) && (*src_pos++ & 0x80))
|
|
++bytes_consumed;
|
|
*offset_ptr += src_pos - src;
|
|
}
|
|
return bytes_consumed;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Dumps bytes from this object's data to the stream "s" starting
|
|
// "start_offset" bytes into this data, and ending with the byte
|
|
// before "end_offset". "base_addr" will be added to the offset
|
|
// into the dumped data when showing the offset into the data in the
|
|
// output information. "num_per_line" objects of type "type" will
|
|
// be dumped with the option to override the format for each object
|
|
// with "type_format". "type_format" is a printf style formatting
|
|
// string. If "type_format" is nullptr, then an appropriate format
|
|
// string will be used for the supplied "type". If the stream "s"
|
|
// is nullptr, then the output will be send to Log().
|
|
//----------------------------------------------------------------------
|
|
lldb::offset_t DataExtractor::PutToLog(Log *log, offset_t start_offset,
|
|
offset_t length, uint64_t base_addr,
|
|
uint32_t num_per_line,
|
|
DataExtractor::Type type,
|
|
const char *format) const {
|
|
if (log == nullptr)
|
|
return start_offset;
|
|
|
|
offset_t offset;
|
|
offset_t end_offset;
|
|
uint32_t count;
|
|
StreamString sstr;
|
|
for (offset = start_offset, end_offset = offset + length, count = 0;
|
|
ValidOffset(offset) && offset < end_offset; ++count) {
|
|
if ((count % num_per_line) == 0) {
|
|
// Print out any previous string
|
|
if (sstr.GetSize() > 0) {
|
|
log->PutString(sstr.GetString());
|
|
sstr.Clear();
|
|
}
|
|
// Reset string offset and fill the current line string with address:
|
|
if (base_addr != LLDB_INVALID_ADDRESS)
|
|
sstr.Printf("0x%8.8" PRIx64 ":",
|
|
(uint64_t)(base_addr + (offset - start_offset)));
|
|
}
|
|
|
|
switch (type) {
|
|
case TypeUInt8:
|
|
sstr.Printf(format ? format : " %2.2x", GetU8(&offset));
|
|
break;
|
|
case TypeChar: {
|
|
char ch = GetU8(&offset);
|
|
sstr.Printf(format ? format : " %c", isprint(ch) ? ch : ' ');
|
|
} break;
|
|
case TypeUInt16:
|
|
sstr.Printf(format ? format : " %4.4x", GetU16(&offset));
|
|
break;
|
|
case TypeUInt32:
|
|
sstr.Printf(format ? format : " %8.8x", GetU32(&offset));
|
|
break;
|
|
case TypeUInt64:
|
|
sstr.Printf(format ? format : " %16.16" PRIx64, GetU64(&offset));
|
|
break;
|
|
case TypePointer:
|
|
sstr.Printf(format ? format : " 0x%" PRIx64, GetAddress(&offset));
|
|
break;
|
|
case TypeULEB128:
|
|
sstr.Printf(format ? format : " 0x%" PRIx64, GetULEB128(&offset));
|
|
break;
|
|
case TypeSLEB128:
|
|
sstr.Printf(format ? format : " %" PRId64, GetSLEB128(&offset));
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!sstr.Empty())
|
|
log->PutString(sstr.GetString());
|
|
|
|
return offset; // Return the offset at which we ended up
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// DumpUUID
|
|
//
|
|
// Dump out a UUID starting at 'offset' bytes into the buffer
|
|
//----------------------------------------------------------------------
|
|
void DataExtractor::DumpUUID(Stream *s, offset_t offset) const {
|
|
if (s) {
|
|
const uint8_t *uuid_data = PeekData(offset, 16);
|
|
if (uuid_data) {
|
|
lldb_private::UUID uuid(uuid_data, 16);
|
|
uuid.Dump(s);
|
|
} else {
|
|
s->Printf("<not enough data for UUID at offset 0x%8.8" PRIx64 ">",
|
|
offset);
|
|
}
|
|
}
|
|
}
|
|
|
|
size_t DataExtractor::Copy(DataExtractor &dest_data) const {
|
|
if (m_data_sp) {
|
|
// we can pass along the SP to the data
|
|
dest_data.SetData(m_data_sp);
|
|
} else {
|
|
const uint8_t *base_ptr = m_start;
|
|
size_t data_size = GetByteSize();
|
|
dest_data.SetData(DataBufferSP(new DataBufferHeap(base_ptr, data_size)));
|
|
}
|
|
return GetByteSize();
|
|
}
|
|
|
|
bool DataExtractor::Append(DataExtractor &rhs) {
|
|
if (rhs.GetByteOrder() != GetByteOrder())
|
|
return false;
|
|
|
|
if (rhs.GetByteSize() == 0)
|
|
return true;
|
|
|
|
if (GetByteSize() == 0)
|
|
return (rhs.Copy(*this) > 0);
|
|
|
|
size_t bytes = GetByteSize() + rhs.GetByteSize();
|
|
|
|
DataBufferHeap *buffer_heap_ptr = nullptr;
|
|
DataBufferSP buffer_sp(buffer_heap_ptr = new DataBufferHeap(bytes, 0));
|
|
|
|
if (!buffer_sp || buffer_heap_ptr == nullptr)
|
|
return false;
|
|
|
|
uint8_t *bytes_ptr = buffer_heap_ptr->GetBytes();
|
|
|
|
memcpy(bytes_ptr, GetDataStart(), GetByteSize());
|
|
memcpy(bytes_ptr + GetByteSize(), rhs.GetDataStart(), rhs.GetByteSize());
|
|
|
|
SetData(buffer_sp);
|
|
|
|
return true;
|
|
}
|
|
|
|
bool DataExtractor::Append(void *buf, offset_t length) {
|
|
if (buf == nullptr)
|
|
return false;
|
|
|
|
if (length == 0)
|
|
return true;
|
|
|
|
size_t bytes = GetByteSize() + length;
|
|
|
|
DataBufferHeap *buffer_heap_ptr = nullptr;
|
|
DataBufferSP buffer_sp(buffer_heap_ptr = new DataBufferHeap(bytes, 0));
|
|
|
|
if (!buffer_sp || buffer_heap_ptr == nullptr)
|
|
return false;
|
|
|
|
uint8_t *bytes_ptr = buffer_heap_ptr->GetBytes();
|
|
|
|
if (GetByteSize() > 0)
|
|
memcpy(bytes_ptr, GetDataStart(), GetByteSize());
|
|
|
|
memcpy(bytes_ptr + GetByteSize(), buf, length);
|
|
|
|
SetData(buffer_sp);
|
|
|
|
return true;
|
|
}
|
|
|
|
void DataExtractor::Checksum(llvm::SmallVectorImpl<uint8_t> &dest,
|
|
uint64_t max_data) {
|
|
if (max_data == 0)
|
|
max_data = GetByteSize();
|
|
else
|
|
max_data = std::min(max_data, GetByteSize());
|
|
|
|
llvm::MD5 md5;
|
|
|
|
const llvm::ArrayRef<uint8_t> data(GetDataStart(), max_data);
|
|
md5.update(data);
|
|
|
|
llvm::MD5::MD5Result result;
|
|
md5.final(result);
|
|
|
|
dest.clear();
|
|
dest.append(result.Bytes.begin(), result.Bytes.end());
|
|
}
|