4479ac15c9
This patch makes adjustments to header file includes in lldbUtility based on recommendations by the iwyu tool (include-what-you-use). The goal here is to make sure that all files include the exact set of headers which are needed for that file only, to eliminate cases of dead includes (e.g. someone deleted some code but forgot to delete the header includes that that code necessitated), and to eliminate the case where header includes are picked up transitively. llvm-svn: 299676
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());
|
|
}
|