Gericom/teak-llvm
1
Fork 0
mirror of https://github.com/Gericom/teak-llvm.git synced 2025-06-27 15:28:53 -04:00
Code Issues Actions Packages Projects Releases Wiki Activity
d9e416c0ea
teak-llvm/lldb/source/Core/DataExtractor.cpp
Greg Clayton d9e416c0ea The second part in thread hardening the internals of LLDB where we make 
the lldb_private::StackFrame objects hold onto a weak pointer to the thread
object. The lldb_private::StackFrame objects the the most volatile objects
we have as when we are doing single stepping, frames can often get lost or
thrown away, only to be re-created as another object that still refers to the
same frame. We have another bug tracking that. But we need to be able to 
have frames no longer be able to get the thread when they are not part of
a thread anymore, and this is the first step (this fix makes that possible
but doesn't implement it yet).

Also changed lldb_private::ExecutionContextScope to return shared pointers to
all objects in the execution context to further thread harden the internals.

llvm-svn: 150871
2012-02-18 05:35:26 +00:00

2038 lines
69 KiB
C++
Raw Blame History

//===-- 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 <assert.h>
#include <stddef.h>
#include <bitset>
#include <string>
#include "llvm/ADT/APFloat.h"
#include "llvm/ADT/APInt.h"
#include "llvm/ADT/ArrayRef.h"
#include "llvm/Support/MathExtras.h"
#include "lldb/Core/DataBufferHeap.h"
#include "lldb/Core/DataExtractor.h"
#include "lldb/Core/DataBuffer.h"
#include "lldb/Core/Disassembler.h"
#include "lldb/Core/Log.h"
#include "lldb/Core/Stream.h"
#include "lldb/Core/StreamString.h"
#include "lldb/Core/UUID.h"
#include "lldb/Core/dwarf.h"
#include "lldb/Host/Endian.h"
#include "lldb/Target/ExecutionContext.h"
#include "lldb/Target/ExecutionContextScope.h"
#include "lldb/Target/Target.h"
using namespace lldb;
using namespace lldb_private;
static inline uint16_t
ReadInt16(const unsigned char* ptr, unsigned offset)
{
return *(uint16_t *)(ptr + offset);
}
static inline uint32_t
ReadInt32 (const unsigned char* ptr, unsigned offset)
{
return *(uint32_t *)(ptr + offset);
}
static inline uint64_t
ReadInt64(const unsigned char* ptr, unsigned offset)
{
return *(uint64_t *)(ptr + offset);
}
static inline uint16_t
ReadSwapInt16(const unsigned char* ptr, unsigned offset)
{
return llvm::ByteSwap_16(*(uint16_t *)(ptr + offset));
}
static inline uint32_t
ReadSwapInt32 (const unsigned char* ptr, unsigned offset)
{
return llvm::ByteSwap_32(*(uint32_t *)(ptr + offset));
}
static inline uint64_t
ReadSwapInt64(const unsigned char* ptr, unsigned offset)
{
return llvm::ByteSwap_64(*(uint64_t *)(ptr + offset));
}
#define NON_PRINTABLE_CHAR '.'
//----------------------------------------------------------------------
// Default constructor.
//----------------------------------------------------------------------
DataExtractor::DataExtractor () :
m_start (NULL),
m_end (NULL),
m_byte_order(lldb::endian::InlHostByteOrder()),
m_addr_size (4),
m_data_sp ()
{
}
//----------------------------------------------------------------------
// 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, uint32_t length, ByteOrder endian, uint8_t addr_size) :
m_start ((uint8_t*)data),
m_end ((uint8_t*)data + length),
m_byte_order(endian),
m_addr_size (addr_size),
m_data_sp ()
{
}
//----------------------------------------------------------------------
// 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, uint8_t addr_size) :
m_start (NULL),
m_end (NULL),
m_byte_order(endian),
m_addr_size (addr_size),
m_data_sp ()
{
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, uint32_t offset, uint32_t length) :
m_start(NULL),
m_end(NULL),
m_byte_order(data.m_byte_order),
m_addr_size(data.m_addr_size),
m_data_sp()
{
if (data.ValidOffset(offset))
{
uint32_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)
{
}
//----------------------------------------------------------------------
// 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;
}
//----------------------------------------------------------------------
// Destructor
//----------------------------------------------------------------------
DataExtractor::~DataExtractor ()
{
}
//------------------------------------------------------------------
// 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 = NULL;
m_end = NULL;
m_byte_order = lldb::endian::InlHostByteOrder();
m_addr_size = 4;
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 != NULL)
{
const DataBuffer * data = m_data_sp.get();
if (data != NULL)
{
const uint8_t * data_bytes = data->GetBytes();
if (data_bytes != NULL)
{
assert(m_start >= data_bytes);
return m_start - data_bytes;
}
}
}
return 0;
}
//------------------------------------------------------------------
// Returns true if there are LENGTH bytes availabe starting OFFSET
// into the data that is in this object.
//------------------------------------------------------------------
bool
DataExtractor::ValidOffsetForDataOfSize (uint32_t offset, uint32_t length) const
{
size_t size = GetByteSize();
if (offset >= size)
return false; // offset isn't valid
if (length == 0)
return true; // No bytes requested at this offset, return true
// If we flip the bits in offset we can figure out how
// many bytes we have left before "offset + length"
// could overflow when doing unsigned arithmetic.
if (length > ~offset)
return false; // unsigned overflow
// Make sure "offset + length" is a valid offset as well.
// length must be greater than zero for this to be a
// valid expression, and we have already checked for this.
return ((offset + length) <= size);
}
//----------------------------------------------------------------------
// 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.
//----------------------------------------------------------------------
uint32_t
DataExtractor::SetData (const void *bytes, uint32_t length, ByteOrder endian)
{
m_byte_order = endian;
m_data_sp.reset();
if (bytes == NULL || length == 0)
{
m_start = NULL;
m_end = NULL;
}
else
{
m_start = (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".
//----------------------------------------------------------------------
uint32_t
DataExtractor::SetData (const DataExtractor& data, uint32_t data_offset, uint32_t data_length)
{
m_addr_size = data.m_addr_size;
// If "data" contains shared pointer to data, then we can use that
if (data.m_data_sp.get())
{
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.
//----------------------------------------------------------------------
uint32_t
DataExtractor::SetData (const DataBufferSP& data_sp, uint32_t data_offset, uint32_t data_length)
{
m_start = m_end = NULL;
if (data_length > 0)
{
m_data_sp = data_sp;
if (data_sp.get())
{
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
}
}
}
uint32_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 (uint32_t *offset_ptr) const
{
uint8_t val = 0;
if ( m_start < m_end )
{
val = m_start[*offset_ptr];
*offset_ptr += sizeof(val);
}
return val;
}
//----------------------------------------------------------------------
// 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-NULL buffer pointer upon successful extraction of
// all the requested bytes, or NULL when the data is not available in
// the buffer due to being out of bounds, or unsufficient data.
//----------------------------------------------------------------------
void *
DataExtractor::GetU8 (uint32_t *offset_ptr, void *dst, uint32_t count) const
{
register uint32_t offset = *offset_ptr;
if ((count > 0) && ValidOffsetForDataOfSize(offset, count) )
{
// Copy the data into the buffer
memcpy (dst, m_start + offset, count);
// Advance the offset
*offset_ptr += count;
// Return a non-NULL pointer to the converted data as an indicator of success
return dst;
}
return NULL;
}
//----------------------------------------------------------------------
// 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 (uint32_t *offset_ptr) const
{
uint16_t val = 0;
register uint32_t offset = *offset_ptr;
if ( ValidOffsetForDataOfSize(offset, sizeof(val)) )
{
if (m_byte_order != lldb::endian::InlHostByteOrder())
val = ReadSwapInt16(m_start, offset);
else
val = ReadInt16 (m_start, offset);
// Advance the offset
*offset_ptr += sizeof(val);
}
return val;
}
uint16_t
DataExtractor::GetU16_unchecked (uint32_t *offset_ptr) const
{
uint16_t val = (m_byte_order == lldb::endian::InlHostByteOrder()) ?
ReadInt16 (m_start, *offset_ptr) :
ReadSwapInt16(m_start, *offset_ptr);
*offset_ptr += sizeof(val);
return val;
}
uint32_t
DataExtractor::GetU32_unchecked (uint32_t *offset_ptr) const
{
uint32_t val = (m_byte_order == lldb::endian::InlHostByteOrder()) ?
ReadInt32 (m_start, *offset_ptr) :
ReadSwapInt32 (m_start, *offset_ptr);
*offset_ptr += sizeof(val);
return val;
}
uint64_t
DataExtractor::GetU64_unchecked (uint32_t *offset_ptr) const
{
uint64_t val = (m_byte_order == lldb::endian::InlHostByteOrder()) ?
ReadInt64 (m_start, *offset_ptr) :
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-NULL buffer pointer upon successful extraction of
// all the requested bytes, or NULL when the data is not available
// in the buffer due to being out of bounds, or unsufficient data.
//----------------------------------------------------------------------
void *
DataExtractor::GetU16 (uint32_t *offset_ptr, void *void_dst, uint32_t count) const
{
uint16_t *dst = (uint16_t *)void_dst;
const size_t value_size = sizeof(*dst);
register uint32_t offset = *offset_ptr;
if ((count > 0) && ValidOffsetForDataOfSize(offset, value_size * count) )
{
uint16_t *value_ptr;
uint16_t *end = dst + count;
if (m_byte_order != lldb::endian::InlHostByteOrder())
{
for (value_ptr = dst; value_ptr < end; ++value_ptr, offset += value_size)
*value_ptr = ReadSwapInt16 (m_start, offset);
}
else
{
for (value_ptr = dst; value_ptr < end; ++value_ptr, offset += value_size)
*value_ptr = ReadInt16 (m_start, offset);
}
// Advance the offset
*offset_ptr = offset;
// Return a non-NULL pointer to the converted data as an indicator of success
return dst;
}
return NULL;
}
//----------------------------------------------------------------------
// 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 (uint32_t *offset_ptr) const
{
uint32_t val = 0;
register uint32_t offset = *offset_ptr;
if ( ValidOffsetForDataOfSize(offset, sizeof(val)) )
{
if (m_byte_order != lldb::endian::InlHostByteOrder())
val = ReadSwapInt32 (m_start, offset);
else
val = ReadInt32 (m_start, offset);
// Advance the offset
*offset_ptr += sizeof(val);
}
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-NULL buffer pointer upon successful extraction of
// all the requested bytes, or NULL when the data is not available
// in the buffer due to being out of bounds, or unsufficient data.
//----------------------------------------------------------------------
void *
DataExtractor::GetU32 (uint32_t *offset_ptr, void *void_dst, uint32_t count) const
{
uint32_t *dst = (uint32_t *)void_dst;
const size_t value_size = sizeof(*dst);
register uint32_t offset = *offset_ptr;
if ((count > 0) && ValidOffsetForDataOfSize(offset, value_size * count))
{
uint32_t *value_ptr;
uint32_t *end = dst + count;
if (m_byte_order != lldb::endian::InlHostByteOrder())
{
for (value_ptr = dst; value_ptr < end; ++value_ptr, offset += value_size)
*value_ptr = ReadSwapInt32 (m_start, offset);
}
else
{
for (value_ptr = dst; value_ptr < end; ++value_ptr, offset += value_size)
*value_ptr = ReadInt32 (m_start, offset);
}
// Advance the offset
*offset_ptr = offset;
// Return a non-NULL pointer to the converted data as an indicator of success
return dst;
}
return NULL;
}
//----------------------------------------------------------------------
// 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 (uint32_t *offset_ptr) const
{
uint64_t val = 0;
register uint32_t offset = *offset_ptr;
if ( ValidOffsetForDataOfSize(offset, sizeof(val)) )
{
if (m_byte_order != lldb::endian::InlHostByteOrder())
val = ReadSwapInt64 (m_start, offset);
else
val = ReadInt64 (m_start, offset);
// Advance the offset
*offset_ptr += sizeof(val);
}
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 (uint32_t *offset_ptr, void *void_dst, uint32_t count) const
{
uint64_t *dst = (uint64_t *)void_dst;
const size_t value_size = sizeof(uint64_t);
register uint32_t offset = *offset_ptr;
if ((count > 0) && ValidOffsetForDataOfSize(offset, value_size * count))
{
uint64_t *value_ptr;
uint64_t *end = dst + count;
if (m_byte_order != lldb::endian::InlHostByteOrder())
{
for (value_ptr = dst; value_ptr < end; ++value_ptr, offset += value_size)
*value_ptr = ReadSwapInt64 (m_start, offset);
}
else
{
for (value_ptr = dst; value_ptr < end; ++value_ptr, offset += value_size)
*value_ptr = ReadInt64 (m_start, offset);
}
// Advance the offset
*offset_ptr = offset;
// Return a non-NULL pointer to the converted data as an indicator of success
return dst;
}
return NULL;
}
//----------------------------------------------------------------------
// 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 (uint32_t *offset_ptr, uint32_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(!"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 (uint32_t *offset_ptr, uint32_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(!"GetMax64 unhandled case!");
break;
}
return 0;
}
uint64_t
DataExtractor::GetMaxU64_unchecked (uint32_t *offset_ptr, uint32_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(!"GetMax64 unhandled case!");
break;
}
return 0;
}
int64_t
DataExtractor::GetMaxS64 (uint32_t *offset_ptr, uint32_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(!"GetMax64 unhandled case!");
break;
}
return 0;
}
uint64_t
DataExtractor::GetMaxU64Bitfield (uint32_t *offset_ptr, uint32_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)
{
if (bitfield_bit_offset > 0)
uval64 >>= bitfield_bit_offset;
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 (uint32_t *offset_ptr, uint32_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)
{
if (bitfield_bit_offset > 0)
sval64 >>= bitfield_bit_offset;
uint64_t bitfield_mask = ((1 << bitfield_bit_size) - 1);
sval64 &= bitfield_mask;
// sign extend if needed
if (sval64 & (1 << (bitfield_bit_size - 1)))
sval64 |= ~bitfield_mask;
}
return sval64;
}
float
DataExtractor::GetFloat (uint32_t *offset_ptr) const
{
typedef float float_type;
float_type val = 0.0;
const uint8_t *src_data = PeekData (*offset_ptr, sizeof(float_type));
if (src_data)
{
if (m_byte_order != lldb::endian::InlHostByteOrder())
{
uint8_t *dst_data = (uint8_t *)&val;
for (int i=0; i<sizeof(float_type); ++i)
dst_data[sizeof(float_type) - 1 - i] = src_data[i];
}
else
{
::memcpy (&val, src_data, sizeof (float_type));
}
// Advance the offset
*offset_ptr += sizeof(val);
}
return val;
}
double
DataExtractor::GetDouble (uint32_t *offset_ptr) const
{
typedef double float_type;
float_type val = 0.0;
const uint8_t *src_data = PeekData (*offset_ptr, sizeof(float_type));
if (src_data)
{
if (m_byte_order != lldb::endian::InlHostByteOrder())
{
uint8_t *dst_data = (uint8_t *)&val;
for (int i=0; i<sizeof(float_type); ++i)
dst_data[sizeof(float_type) - 1 - i] = src_data[i];
}
else
{
::memcpy (&val, src_data, sizeof (float_type));
}
// Advance the offset
*offset_ptr += sizeof(val);
}
return val;
}
long double
DataExtractor::GetLongDouble (uint32_t *offset_ptr) const
{
typedef long double float_type;
float_type val = 0.0;
const uint8_t *src_data = PeekData (*offset_ptr, sizeof(float_type));
if (src_data)
{
if (m_byte_order != lldb::endian::InlHostByteOrder())
{
uint8_t *dst_data = (uint8_t *)&val;
for (int i=0; i<sizeof(float_type); ++i)
dst_data[sizeof(float_type) - 1 - i] = src_data[i];
}
else
{
::memcpy (&val, src_data, sizeof (float_type));
}
// Advance the offset
*offset_ptr += sizeof(val);
}
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 (uint32_t *offset_ptr) const
{
return GetMaxU64 (offset_ptr, m_addr_size);
}
uint64_t
DataExtractor::GetAddress_unchecked (uint32_t *offset_ptr) const
{
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 (uint32_t *offset_ptr) const
{
return GetMaxU64 (offset_ptr, m_addr_size);
}
//----------------------------------------------------------------------
// GetDwarfEHPtr
//
// Used for calls when the value type is specified by a DWARF EH Frame
// pointer encoding.
//----------------------------------------------------------------------
uint64_t
DataExtractor::GetGNUEHPointer (uint32_t *offset_ptr, uint32_t eh_ptr_enc, lldb::addr_t pc_rel_addr, lldb::addr_t text_addr, lldb::addr_t data_addr)//, BSDRelocs *data_relocs) const
{
if (eh_ptr_enc == DW_EH_PE_omit)
return ULLONG_MAX; // Value isn't in the buffer...
uint64_t baseAddress = 0;
uint64_t addressValue = 0;
const uint32_t addr_size = GetAddressByteSize();
bool signExtendValue = false;
// Decode the base part or adjust our offset
switch (eh_ptr_enc & 0x70)
{
case DW_EH_PE_pcrel:
signExtendValue = true;
baseAddress = *offset_ptr;
if (pc_rel_addr != LLDB_INVALID_ADDRESS)
baseAddress += pc_rel_addr;
// else
// Log::GlobalWarning ("PC relative pointer encoding found with invalid pc relative address.");
break;
case DW_EH_PE_textrel:
signExtendValue = true;
if (text_addr != LLDB_INVALID_ADDRESS)
baseAddress = text_addr;
// else
// Log::GlobalWarning ("text relative pointer encoding being decoded with invalid text section address, setting base address to zero.");
break;
case DW_EH_PE_datarel:
signExtendValue = true;
if (data_addr != LLDB_INVALID_ADDRESS)
baseAddress = data_addr;
// else
// Log::GlobalWarning ("data relative pointer encoding being decoded with invalid data section address, setting base address to zero.");
break;
case DW_EH_PE_funcrel:
signExtendValue = true;
break;
case DW_EH_PE_aligned:
{
// SetPointerSize should be called prior to extracting these so the
// pointer size is cached
assert(addr_size != 0);
if (addr_size)
{
// Align to a address size boundary first
uint32_t alignOffset = *offset_ptr % addr_size;
if (alignOffset)
offset_ptr += addr_size - alignOffset;
}
}
break;
default:
break;
}
// Decode the value part
switch (eh_ptr_enc & DW_EH_PE_MASK_ENCODING)
{
case DW_EH_PE_absptr :
{
addressValue = GetAddress (offset_ptr);
// if (data_relocs)
// addressValue = data_relocs->Relocate(*offset_ptr - addr_size, *this, addressValue);
}
break;
case DW_EH_PE_uleb128 : addressValue = GetULEB128(offset_ptr); break;
case DW_EH_PE_udata2 : addressValue = GetU16(offset_ptr); break;
case DW_EH_PE_udata4 : addressValue = GetU32(offset_ptr); break;
case DW_EH_PE_udata8 : addressValue = GetU64(offset_ptr); break;
case DW_EH_PE_sleb128 : addressValue = GetSLEB128(offset_ptr); break;
case DW_EH_PE_sdata2 : addressValue = (int16_t)GetU16(offset_ptr); break;
case DW_EH_PE_sdata4 : addressValue = (int32_t)GetU32(offset_ptr); break;
case DW_EH_PE_sdata8 : addressValue = (int64_t)GetU64(offset_ptr); break;
default:
// Unhandled encoding type
assert(eh_ptr_enc);
break;
}
// Since we promote everything to 64 bit, we may need to sign extend
if (signExtendValue && addr_size < sizeof(baseAddress))
{
uint64_t sign_bit = 1ull << ((addr_size * 8ull) - 1ull);
if (sign_bit & addressValue)
{
uint64_t mask = ~sign_bit + 1;
addressValue |= mask;
}
}
return baseAddress + addressValue;
}
size_t
DataExtractor::ExtractBytes (uint32_t offset, uint32_t length, ByteOrder dst_byte_order, void *dst) const
{
const uint8_t *src = PeekData (offset, length);
if (src)
{
if (dst_byte_order != GetByteOrder())
{
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;
}
//----------------------------------------------------------------------
// Peeks at bytes in the contained data.
//
// Returns a valid pointer to bytes if "offset" is a valid offset in
// and there are "length" bytes available, else NULL is returned.
//----------------------------------------------------------------------
const uint8_t*
DataExtractor::PeekData (uint32_t offset, uint32_t length) const
{
if ( length > 0 && ValidOffsetForDataOfSize(offset, length) )
return m_start + offset;
return NULL;
}
//----------------------------------------------------------------------
// Returns a pointer to a bytes in this object's data at the offset
// pointed to by "offset_ptr". If "length" is zero or too large,
// then the offset pointed to by "offset_ptr" will not be updated
// and NULL will be returned.
//
// Returns a pointer to the data if the offset and length are valid,
// or NULL otherwise.
//----------------------------------------------------------------------
const void*
DataExtractor::GetData (uint32_t *offset_ptr, uint32_t length) const
{
const uint8_t* bytes = NULL;
register uint32_t offset = *offset_ptr;
if ( length > 0 && ValidOffsetForDataOfSize(offset, length) )
{
bytes = m_start + offset;
*offset_ptr = offset + length;
}
return bytes;
}
// Extract data and swap if needed when doing the copy
uint32_t
DataExtractor::CopyByteOrderedData (uint32_t src_offset,
uint32_t src_len,
void *dst_void_ptr,
uint32_t dst_len,
ByteOrder dst_byte_order) const
{
// Validate the source info
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 != NULL);
assert (dst_len > 0);
assert (dst_byte_order == eByteOrderBig || dst_byte_order == eByteOrderLittle);
// 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;
uint32_t i;
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 uint32_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 (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 (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 (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 (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 AsCString (fixed length, or variable length) from
// the data at the offset pointed to by "offset_ptr". If
// "length" is zero, then a variable length NULL terminated C
// string will be extracted from the data the "offset_ptr" will be
// updated with the offset of the byte that follows the NULL
// terminator byte. If "length" is greater than zero, then
// the function will make sure there are "length" bytes
// available in the current data and if so, return a valid pointer.
//
// If the offset pointed to by "offset_ptr" is out of bounds, or if
// "length" is non-zero and there aren't enough avaialable
// bytes, NULL will be returned and "offset_ptr" will not be
// updated.
//----------------------------------------------------------------------
const char*
DataExtractor::GetCStr (uint32_t *offset_ptr) const
{
const char *s = NULL;
if ( m_start < m_end )
{
s = (char*)m_start + *offset_ptr;
size_t length = strlen(s) + 1;
if (!ValidOffsetForDataOfSize(*offset_ptr, length))
return NULL;
// Advance the offset
*offset_ptr += length;
}
return s;
}
//------------------------------------------------------------------
// 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 NULL is returned.
//------------------------------------------------------------------
const char *
DataExtractor::PeekCStr (uint32_t offset) const
{
if (ValidOffset (offset))
return (const char*)m_start + offset;
return NULL;
}
//----------------------------------------------------------------------
// 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 (uint32_t *offset_ptr) const
{
const uint8_t *src = m_start + *offset_ptr;
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 |= (byte & 0x7f) << shift;
if ((byte & 0x80) == 0)
break;
shift += 7;
}
}
*offset_ptr = (uint32_t)(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 (uint32_t *offset_ptr) const
{
int64_t result = 0;
if ( m_start < m_end )
{
int shift = 0;
int size = sizeof (uint32_t) * 8;
const uint8_t *src = m_start + *offset_ptr;
uint8_t byte = 0;
int bytecount = 0;
while (src < m_end)
{
bytecount++;
byte = *src++;
result |= (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;
}
//----------------------------------------------------------------------
// 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 (uint32_t *offset_ptr) const
{
uint32_t bytes_consumed = 0;
if ( m_start < m_end )
{
const uint8_t *start = m_start + *offset_ptr;
const uint8_t *src = start;
while ((src < m_end) && (*src++ & 0x80))
++bytes_consumed;
*offset_ptr += src - start;
}
return bytes_consumed;
}
static uint32_t
DumpAPInt (Stream *s, const DataExtractor &data, uint32_t offset, uint32_t byte_size, bool is_signed, unsigned radix)
{
llvm::SmallVector<uint64_t, 2> uint64_array;
uint32_t bytes_left = byte_size;
uint64_t u64;
const lldb::ByteOrder byte_order = data.GetByteOrder();
if (byte_order == lldb::eByteOrderLittle)
{
while (bytes_left > 0)
{
if (bytes_left >= 8)
{
u64 = data.GetU64(&offset);
bytes_left -= 8;
}
else
{
u64 = data.GetMaxU64(&offset, bytes_left);
bytes_left = 0;
}
uint64_array.push_back(u64);
}
}
else if (byte_order == lldb::eByteOrderBig)
{
uint32_t be_offset = offset + byte_size;
uint32_t temp_offset;
while (bytes_left > 0)
{
if (bytes_left >= 8)
{
be_offset -= 8;
temp_offset = be_offset;
u64 = data.GetU64(&temp_offset);
bytes_left -= 8;
}
else
{
be_offset -= bytes_left;
temp_offset = be_offset;
u64 = data.GetMaxU64(&temp_offset, bytes_left);
bytes_left = 0;
}
uint64_array.push_back(u64);
}
}
else
return offset;
llvm::APInt apint (byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array));
std::string apint_str(apint.toString(radix, is_signed));
switch (radix)
{
case 2:
s->Write ("0b", 2);
break;
case 8:
s->Write ("0", 1);
break;
case 10:
break;
}
s->Write(apint_str.c_str(), apint_str.size());
return offset;
}
uint32_t
DataExtractor::Dump (Stream *s,
uint32_t start_offset,
lldb::Format item_format,
uint32_t item_byte_size,
uint32_t item_count,
uint32_t num_per_line,
uint64_t base_addr,
uint32_t item_bit_size, // If zero, this is not a bitfield value, if non-zero, the value is a bitfield
uint32_t item_bit_offset, // If "item_bit_size" is non-zero, this is the shift amount to apply to a bitfield
ExecutionContextScope *exe_scope) const
{
if (s == NULL)
return start_offset;
if (item_format == eFormatPointer)
{
if (item_byte_size != 4 && item_byte_size != 8)
item_byte_size = s->GetAddressByteSize();
}
uint32_t offset = start_offset;
if (item_format == eFormatInstruction)
{
TargetSP target_sp;
if (exe_scope)
target_sp = exe_scope->CalculateTarget();
if (target_sp)
{
DisassemblerSP disassembler_sp (Disassembler::FindPlugin(target_sp->GetArchitecture(), NULL));
if (disassembler_sp)
{
lldb::addr_t addr = base_addr + start_offset;
lldb_private::Address so_addr;
if (!target_sp->GetSectionLoadList().ResolveLoadAddress(addr, so_addr))
{
so_addr.SetOffset(addr);
so_addr.SetSection(NULL);
}
size_t bytes_consumed = disassembler_sp->DecodeInstructions (so_addr, *this, start_offset, item_count, false);
if (bytes_consumed)
{
offset += bytes_consumed;
const bool show_address = base_addr != LLDB_INVALID_ADDRESS;
const bool show_bytes = true;
ExecutionContext exe_ctx;
exe_scope->CalculateExecutionContext(exe_ctx);
disassembler_sp->GetInstructionList().Dump (s, show_address, show_bytes, &exe_ctx);
}
}
}
else
s->Printf ("invalid target");
return offset;
}
if ((item_format == eFormatOSType || item_format == eFormatAddressInfo) && item_byte_size > 8)
item_format = eFormatHex;
uint32_t line_start_offset = start_offset;
for (uint32_t count = 0; ValidOffset(offset) && count < item_count; ++count)
{
if ((count % num_per_line) == 0)
{
if (count > 0)
{
if (item_format == eFormatBytesWithASCII && offset > line_start_offset)
{
s->Printf("%*s", (num_per_line - (offset - line_start_offset)) * 3 + 2, "");
Dump(s, line_start_offset, eFormatCharPrintable, 1, offset - line_start_offset, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0);
}
s->EOL();
}
if (base_addr != LLDB_INVALID_ADDRESS)
s->Printf ("0x%8.8llx: ", (uint64_t)(base_addr + (offset - start_offset)));
line_start_offset = offset;
}
else
if (item_format != eFormatChar &&
item_format != eFormatCharPrintable &&
item_format != eFormatCharArray &&
count > 0)
{
s->PutChar(' ');
}
uint32_t i;
switch (item_format)
{
case eFormatBoolean:
s->Printf ("%s", GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset) ? "true" : "false");
break;
case eFormatBinary:
if (item_byte_size <= 8)
{
uint64_t uval64 = GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset);
// Avoid std::bitset<64>::to_string() since it is missing in
// earlier C++ libraries
std::string binary_value(64, '0');
std::bitset<64> bits(uval64);
for (i = 0; i < 64; ++i)
if (bits[i])
binary_value[64 - 1 - i] = '1';
if (item_bit_size > 0)
s->Printf("0b%s", binary_value.c_str() + 64 - item_bit_size);
else if (item_byte_size > 0 && item_byte_size <= 8)
s->Printf("0b%s", binary_value.c_str() + 64 - item_byte_size * 8);
}
else
{
const bool is_signed = false;
const unsigned radix = 2;
offset = DumpAPInt (s, *this, offset, item_byte_size, is_signed, radix);
}
break;
case eFormatBytes:
case eFormatBytesWithASCII:
for (i=0; i<item_byte_size; ++i)
{
s->Printf ("%2.2x", GetU8(&offset));
}
// Put an extra space between the groups of bytes if more than one
// is being dumped in a group (item_byte_size is more than 1).
if (item_byte_size > 1)
s->PutChar(' ');
break;
case eFormatChar:
case eFormatCharPrintable:
case eFormatCharArray:
{
// If we are only printing one character surround it with single
// quotes
if (item_count == 1 && item_format == eFormatChar)
s->PutChar('\'');
const uint64_t ch = GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset);
if (isprint(ch))
s->Printf ("%c", (char)ch);
else if (item_format != eFormatCharPrintable)
{
switch (ch)
{
case '\033': s->Printf ("\\e"); break;
case '\a': s->Printf ("\\a"); break;
case '\b': s->Printf ("\\b"); break;
case '\f': s->Printf ("\\f"); break;
case '\n': s->Printf ("\\n"); break;
case '\r': s->Printf ("\\r"); break;
case '\t': s->Printf ("\\t"); break;
case '\v': s->Printf ("\\v"); break;
case '\0': s->Printf ("\\0"); break;
default:
if (item_byte_size == 1)
s->Printf ("\\x%2.2x", (uint8_t)ch);
else
s->Printf ("%llu", ch);
break;
}
}
else
{
s->PutChar(NON_PRINTABLE_CHAR);
}
// If we are only printing one character surround it with single quotes
if (item_count == 1 && item_format == eFormatChar)
s->PutChar('\'');
}
break;
case eFormatDecimal:
if (item_byte_size <= 8)
s->Printf ("%lld", GetMaxS64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset));
else
{
const bool is_signed = true;
const unsigned radix = 10;
offset = DumpAPInt (s, *this, offset, item_byte_size, is_signed, radix);
}
break;
case eFormatUnsigned:
if (item_byte_size <= 8)
s->Printf ("%llu", GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset));
else
{
const bool is_signed = false;
const unsigned radix = 10;
offset = DumpAPInt (s, *this, offset, item_byte_size, is_signed, radix);
}
break;
case eFormatOctal:
if (item_byte_size <= 8)
s->Printf ("0%llo", GetMaxS64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset));
else
{
const bool is_signed = false;
const unsigned radix = 8;
offset = DumpAPInt (s, *this, offset, item_byte_size, is_signed, radix);
}
break;
case eFormatOSType:
{
uint64_t uval64 = GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset);
s->PutChar('\'');
for (i=0; i<item_byte_size; ++i)
{
uint8_t ch = (uint8_t)(uval64 >> ((item_byte_size - i - 1) * 8));
if (isprint(ch))
s->Printf ("%c", ch);
else
{
switch (ch)
{
case '\033': s->Printf ("\\e"); break;
case '\a': s->Printf ("\\a"); break;
case '\b': s->Printf ("\\b"); break;
case '\f': s->Printf ("\\f"); break;
case '\n': s->Printf ("\\n"); break;
case '\r': s->Printf ("\\r"); break;
case '\t': s->Printf ("\\t"); break;
case '\v': s->Printf ("\\v"); break;
case '\0': s->Printf ("\\0"); break;
default: s->Printf ("\\x%2.2x", ch); break;
}
}
}
s->PutChar('\'');
}
break;
case eFormatEnum:
// Print enum value as a signed integer when we don't get the enum type
s->Printf ("%lld", GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset));
break;
case eFormatCString:
{
const char *cstr = GetCStr(&offset);
if (!cstr)
{
s->Printf("NULL");
offset = UINT32_MAX;
}
else
{
s->PutChar('\"');
while (const char c = *cstr)
{
if (isprint(c))
{
s->PutChar(c);
}
else
{
switch (c)
{
case '\033': s->Printf ("\\e"); break;
case '\a': s->Printf ("\\a"); break;
case '\b': s->Printf ("\\b"); break;
case '\f': s->Printf ("\\f"); break;
case '\n': s->Printf ("\\n"); break;
case '\r': s->Printf ("\\r"); break;
case '\t': s->Printf ("\\t"); break;
case '\v': s->Printf ("\\v"); break;
default: s->Printf ("\\x%2.2x", c); break;
}
}
++cstr;
}
s->PutChar('\"');
}
}
break;
case eFormatPointer:
s->Address(GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset), sizeof (addr_t));
break;
case eFormatComplexInteger:
{
uint32_t complex_int_byte_size = item_byte_size / 2;
if (complex_int_byte_size <= 8)
{
s->Printf("%llu", GetMaxU64Bitfield(&offset, complex_int_byte_size, 0, 0));
s->Printf(" + %llui", GetMaxU64Bitfield(&offset, complex_int_byte_size, 0, 0));
}
}
break;
case eFormatComplex:
if (sizeof(float) * 2 == item_byte_size)
{
float f32_1 = GetFloat (&offset);
float f32_2 = GetFloat (&offset);
s->Printf ("%g + %gi", f32_1, f32_2);
break;
}
else if (sizeof(double) * 2 == item_byte_size)
{
double d64_1 = GetDouble (&offset);
double d64_2 = GetDouble (&offset);
s->Printf ("%lg + %lgi", d64_1, d64_2);
break;
}
else if (sizeof(long double) * 2 == item_byte_size)
{
long double ld64_1 = GetLongDouble (&offset);
long double ld64_2 = GetLongDouble (&offset);
s->Printf ("%Lg + %Lgi", ld64_1, ld64_2);
break;
}
else
{
s->Printf ("unsupported complex float byte size %u", item_byte_size);
return start_offset;
}
break;
default:
case eFormatDefault:
case eFormatHex:
if (item_byte_size <= 8)
{
s->Printf("0x%*.*llx", 2 * item_byte_size, 2 * item_byte_size, GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset));
}
else
{
assert (item_bit_size == 0 && item_bit_offset == 0);
s->PutCString("0x");
const uint8_t *bytes = (const uint8_t* )GetData(&offset, item_byte_size);
if (bytes)
{
uint32_t idx;
if (m_byte_order == eByteOrderBig)
{
for (idx = 0; idx < item_byte_size; ++idx)
s->Printf("%2.2x", bytes[idx]);
}
else
{
for (idx = 0; idx < item_byte_size; ++idx)
s->Printf("%2.2x", bytes[item_byte_size - 1 - idx]);
}
}
}
break;
case eFormatFloat:
if (sizeof(float) == item_byte_size)
{
s->Printf ("%g", GetFloat (&offset));
}
else if (sizeof(double) == item_byte_size)
{
s->Printf ("%lg", GetDouble(&offset));
}
else if (sizeof(long double) == item_byte_size)
{
s->Printf ("%Lg", GetLongDouble(&offset));
}
break;
case eFormatUnicode16:
s->Printf("0x%4.4x", GetU16 (&offset));
break;
case eFormatUnicode32:
s->Printf("0x%8.8x", GetU32 (&offset));
break;
case eFormatAddressInfo:
{
addr_t addr = GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset);
s->Printf("0x%*.*llx", 2 * item_byte_size, 2 * item_byte_size, addr);
if (exe_scope)
{
TargetSP target_sp (exe_scope->CalculateTarget());
lldb_private::Address so_addr;
if (target_sp && target_sp->GetSectionLoadList().ResolveLoadAddress(addr, so_addr))
{
s->PutChar(' ');
so_addr.Dump (s,
exe_scope,
Address::DumpStyleResolvedDescription,
Address::DumpStyleModuleWithFileAddress);
break;
}
}
}
break;
case eFormatHexFloat:
if (sizeof(float) == item_byte_size)
{
char float_cstr[256];
llvm::APFloat ap_float (GetFloat (&offset));
ap_float.convertToHexString (float_cstr, 0, false, llvm::APFloat::rmNearestTiesToEven);
s->Printf ("%s", float_cstr);
break;
}
else if (sizeof(double) == item_byte_size)
{
char float_cstr[256];
llvm::APFloat ap_float (GetDouble (&offset));
ap_float.convertToHexString (float_cstr, 0, false, llvm::APFloat::rmNearestTiesToEven);
s->Printf ("%s", float_cstr);
break;
}
else
{
s->Printf ("unsupported hex float byte size %u", item_byte_size);
return start_offset;
}
break;
// please keep the single-item formats below in sync with FormatManager::GetSingleItemFormat
// if you fail to do so, users will start getting different outputs depending on internal
// implementation details they should not care about ||
case eFormatVectorOfChar: // ||
s->PutChar('{'); // \/
offset = Dump (s, offset, eFormatCharArray, 1, item_byte_size, item_byte_size, LLDB_INVALID_ADDRESS, 0, 0);
s->PutChar('}');
break;
case eFormatVectorOfSInt8:
s->PutChar('{');
offset = Dump (s, offset, eFormatDecimal, 1, item_byte_size, item_byte_size, LLDB_INVALID_ADDRESS, 0, 0);
s->PutChar('}');
break;
case eFormatVectorOfUInt8:
s->PutChar('{');
offset = Dump (s, offset, eFormatHex, 1, item_byte_size, item_byte_size, LLDB_INVALID_ADDRESS, 0, 0);
s->PutChar('}');
break;
case eFormatVectorOfSInt16:
s->PutChar('{');
offset = Dump (s, offset, eFormatDecimal, sizeof(uint16_t), item_byte_size / sizeof(uint16_t), item_byte_size / sizeof(uint16_t), LLDB_INVALID_ADDRESS, 0, 0);
s->PutChar('}');
break;
case eFormatVectorOfUInt16:
s->PutChar('{');
offset = Dump (s, offset, eFormatHex, sizeof(uint16_t), item_byte_size / sizeof(uint16_t), item_byte_size / sizeof(uint16_t), LLDB_INVALID_ADDRESS, 0, 0);
s->PutChar('}');
break;
case eFormatVectorOfSInt32:
s->PutChar('{');
offset = Dump (s, offset, eFormatDecimal, sizeof(uint32_t), item_byte_size / sizeof(uint32_t), item_byte_size / sizeof(uint32_t), LLDB_INVALID_ADDRESS, 0, 0);
s->PutChar('}');
break;
case eFormatVectorOfUInt32:
s->PutChar('{');
offset = Dump (s, offset, eFormatHex, sizeof(uint32_t), item_byte_size / sizeof(uint32_t), item_byte_size / sizeof(uint32_t), LLDB_INVALID_ADDRESS, 0, 0);
s->PutChar('}');
break;
case eFormatVectorOfSInt64:
s->PutChar('{');
offset = Dump (s, offset, eFormatDecimal, sizeof(uint64_t), item_byte_size / sizeof(uint64_t), item_byte_size / sizeof(uint64_t), LLDB_INVALID_ADDRESS, 0, 0);
s->PutChar('}');
break;
case eFormatVectorOfUInt64:
s->PutChar('{');
offset = Dump (s, offset, eFormatHex, sizeof(uint32_t), item_byte_size / sizeof(uint32_t), item_byte_size / sizeof(uint32_t), LLDB_INVALID_ADDRESS, 0, 0);
s->PutChar('}');
break;
case eFormatVectorOfFloat32:
s->PutChar('{');
offset = Dump (s, offset, eFormatFloat, 4, item_byte_size / 4, item_byte_size / 4, LLDB_INVALID_ADDRESS, 0, 0);
s->PutChar('}');
break;
case eFormatVectorOfFloat64:
s->PutChar('{');
offset = Dump (s, offset, eFormatFloat, 8, item_byte_size / 8, item_byte_size / 8, LLDB_INVALID_ADDRESS, 0, 0);
s->PutChar('}');
break;
case eFormatVectorOfUInt128:
s->PutChar('{');
offset = Dump (s, offset, eFormatHex, 16, item_byte_size / 16, item_byte_size / 16, LLDB_INVALID_ADDRESS, 0, 0);
s->PutChar('}');
break;
}
}
if (item_format == eFormatBytesWithASCII && offset > line_start_offset)
{
s->Printf("%*s", (num_per_line - (offset - line_start_offset)) * 3 + 2, "");
Dump(s, line_start_offset, eFormatCharPrintable, 1, offset - line_start_offset, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0);
}
return offset; // Return the offset at which we ended up
}
//----------------------------------------------------------------------
// 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 NULL, then an appropriate format
// string will be used for the supplied "type". If the stream "s"
// is NULL, then the output will be send to Log().
//----------------------------------------------------------------------
uint32_t
DataExtractor::PutToLog
(
Log *log,
uint32_t start_offset,
uint32_t length,
uint64_t base_addr,
uint32_t num_per_line,
DataExtractor::Type type,
const char *format
) const
{
if (log == NULL)
return start_offset;
uint32_t offset;
uint32_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->Printf("%s", sstr.GetData());
sstr.Clear();
}
// Reset string offset and fill the current line string with address:
if (base_addr != LLDB_INVALID_ADDRESS)
sstr.Printf("0x%8.8llx:", (uint64_t)(base_addr + (offset - start_offset)));
}
switch (type)
{
default:
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.16llx", GetU64(&offset)); break;
case TypePointer: sstr.Printf (format ? format : " 0x%llx", GetAddress(&offset)); break;
case TypeULEB128: sstr.Printf (format ? format : " 0x%llx", GetULEB128(&offset)); break;
case TypeSLEB128: sstr.Printf (format ? format : " %lld", GetSLEB128(&offset)); break;
}
}
if (sstr.GetSize() > 0)
log->Printf("%s", sstr.GetData());
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, uint32_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.8x>", offset);
}
}
}
void
DataExtractor::DumpHexBytes (Stream *s,
const void *src,
size_t src_len,
uint32_t bytes_per_line,
addr_t base_addr)
{
DataExtractor data (src, src_len, eByteOrderLittle, 4);
data.Dump (s,
0, // Offset into "src"
eFormatBytes, // Dump as hex bytes
1, // Size of each item is 1 for single bytes
src_len, // Number of bytes
bytes_per_line, // Num bytes per line
base_addr, // Base address
0, 0); // Bitfield info
}
size_t
DataExtractor::Copy (DataExtractor &dest_data) const
{
if (m_data_sp.get())
{
// 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 = NULL;
DataBufferSP buffer_sp(buffer_heap_ptr = new DataBufferHeap(bytes, 0));
if (buffer_sp.get() == NULL || buffer_heap_ptr == NULL)
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, uint32_t length)
{
if (buf == NULL)
return false;
if (length == 0)
return true;
size_t bytes = GetByteSize() + length;
DataBufferHeap *buffer_heap_ptr = NULL;
DataBufferSP buffer_sp(buffer_heap_ptr = new DataBufferHeap(bytes, 0));
if (buffer_sp.get() == NULL || buffer_heap_ptr == NULL)
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;
}
Reference in New Issue View Git Blame Copy Permalink