diff options
Diffstat (limited to 'source/Core/DataEncoder.cpp')
| -rw-r--r-- | source/Core/DataEncoder.cpp | 335 |
1 files changed, 335 insertions, 0 deletions
diff --git a/source/Core/DataEncoder.cpp b/source/Core/DataEncoder.cpp new file mode 100644 index 000000000000..92a9104acc3a --- /dev/null +++ b/source/Core/DataEncoder.cpp @@ -0,0 +1,335 @@ +//===-- DataEncoder.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/Core/DataEncoder.h" + +#include <assert.h> +#include <stddef.h> + +#include "llvm/Support/MathExtras.h" + +#include "lldb/Core/DataBuffer.h" +#include "lldb/Host/Endian.h" + +using namespace lldb; +using namespace lldb_private; + +static inline void +WriteInt16(const unsigned char* ptr, unsigned offset, uint16_t value) +{ + *(uint16_t *)(ptr + offset) = value; +} +static inline void +WriteInt32 (const unsigned char* ptr, unsigned offset, uint32_t value) +{ + *(uint32_t *)(ptr + offset) = value; +} + +static inline void +WriteInt64(const unsigned char* ptr, unsigned offset, uint64_t value) +{ + *(uint64_t *)(ptr + offset) = value; +} + +static inline void +WriteSwappedInt16(const unsigned char* ptr, unsigned offset, uint16_t value) +{ + *(uint16_t *)(ptr + offset) = llvm::ByteSwap_16(value); +} + +static inline void +WriteSwappedInt32 (const unsigned char* ptr, unsigned offset, uint32_t value) +{ + *(uint32_t *)(ptr + offset) = llvm::ByteSwap_32(value); +} + +static inline void +WriteSwappedInt64(const unsigned char* ptr, unsigned offset, uint64_t value) +{ + *(uint64_t *)(ptr + offset) = llvm::ByteSwap_64(value); +} + +//---------------------------------------------------------------------- +// Default constructor. +//---------------------------------------------------------------------- +DataEncoder::DataEncoder () : + m_start (NULL), + m_end (NULL), + m_byte_order(lldb::endian::InlHostByteOrder()), + m_addr_size (sizeof(void*)), + 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. +//---------------------------------------------------------------------- +DataEncoder::DataEncoder (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 DataEncoder objects exist that have a reference to +// this data. +//---------------------------------------------------------------------- +DataEncoder::DataEncoder (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); +} + +//---------------------------------------------------------------------- +// Destructor +//---------------------------------------------------------------------- +DataEncoder::~DataEncoder () +{ +} + +//------------------------------------------------------------------ +// Clears the object contents back to a default invalid state, and +// release any references to shared data that this object may +// contain. +//------------------------------------------------------------------ +void +DataEncoder::Clear () +{ + m_start = NULL; + m_end = NULL; + m_byte_order = lldb::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 +DataEncoder::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; +} + +//---------------------------------------------------------------------- +// 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 +DataEncoder::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 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 +DataEncoder::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. +//---------------------------------------------------------------------- +uint32_t +DataEncoder::PutU8 (uint32_t offset, uint8_t value) +{ + if (ValidOffset(offset)) + { + m_start[offset] = value; + return offset + 1; + } + return UINT32_MAX; +} + +uint32_t +DataEncoder::PutU16 (uint32_t offset, uint16_t value) +{ + if (ValidOffsetForDataOfSize(offset, sizeof(value))) + { + if (m_byte_order != lldb::endian::InlHostByteOrder()) + WriteSwappedInt16 (m_start, offset, value); + else + WriteInt16 (m_start, offset, value); + + return offset + sizeof (value); + } + return UINT32_MAX; +} + +uint32_t +DataEncoder::PutU32 (uint32_t offset, uint32_t value) +{ + if (ValidOffsetForDataOfSize(offset, sizeof(value))) + { + if (m_byte_order != lldb::endian::InlHostByteOrder()) + WriteSwappedInt32 (m_start, offset, value); + else + WriteInt32 (m_start, offset, value); + + return offset + sizeof (value); + } + return UINT32_MAX; +} + +uint32_t +DataEncoder::PutU64 (uint32_t offset, uint64_t value) +{ + if (ValidOffsetForDataOfSize(offset, sizeof(value))) + { + if (m_byte_order != lldb::endian::InlHostByteOrder()) + WriteSwappedInt64 (m_start, offset, value); + else + WriteInt64 (m_start, offset, value); + + return offset + sizeof (value); + } + return UINT32_MAX; +} + +//---------------------------------------------------------------------- +// 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. +//---------------------------------------------------------------------- +uint32_t +DataEncoder::PutMaxU64 (uint32_t offset, uint32_t byte_size, uint64_t value) +{ + switch (byte_size) + { + case 1: return PutU8 (offset, value); + case 2: return PutU16(offset, value); + case 4: return PutU32(offset, value); + case 8: return PutU64(offset, value); + default: + assert(!"GetMax64 unhandled case!"); + break; + } + return UINT32_MAX; +} + +uint32_t +DataEncoder::PutData (uint32_t offset, const void *src, uint32_t src_len) +{ + if (src == NULL || src_len == 0) + return offset; + + if (ValidOffsetForDataOfSize(offset, src_len)) + { + memcpy (m_start + offset, src, src_len); + return offset + src_len; + } + return UINT32_MAX; +} + +uint32_t +DataEncoder::PutAddress (uint32_t offset, lldb::addr_t addr) +{ + return PutMaxU64 (offset, GetAddressByteSize(), addr); +} + +uint32_t +DataEncoder::PutCString (uint32_t offset, const char *cstr) +{ + if (cstr) + return PutData (offset, cstr, strlen(cstr) + 1); + return UINT32_MAX; +} |