diff options
| author | Kate Stone <katherine.stone@apple.com> | 2016-09-06 20:57:50 +0000 |
|---|---|---|
| committer | Kate Stone <katherine.stone@apple.com> | 2016-09-06 20:57:50 +0000 |
| commit | b9c1b51e45b845debb76d8658edabca70ca56079 (patch) | |
| tree | dfcb5a13ef2b014202340f47036da383eaee74aa /lldb/source/Core/DataExtractor.cpp | |
| parent | d5aa73376966339caad04013510626ec2e42c760 (diff) | |
| download | bcm5719-llvm-b9c1b51e45b845debb76d8658edabca70ca56079.tar.gz bcm5719-llvm-b9c1b51e45b845debb76d8658edabca70ca56079.zip | |
*** This commit represents a complete reformatting of the LLDB source code
*** to conform to clang-format’s LLVM style. This kind of mass change has
*** two obvious implications:
Firstly, merging this particular commit into a downstream fork may be a huge
effort. Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit. The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):
find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;
The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.
Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit. There are alternatives available that will attempt
to look through this change and find the appropriate prior commit. YMMV.
llvm-svn: 280751
Diffstat (limited to 'lldb/source/Core/DataExtractor.cpp')
| -rw-r--r-- | lldb/source/Core/DataExtractor.cpp | 3448 |
1 files changed, 1661 insertions, 1787 deletions
diff --git a/lldb/source/Core/DataExtractor.cpp b/lldb/source/Core/DataExtractor.cpp index 84446147a36..466f111b3b1 100644 --- a/lldb/source/Core/DataExtractor.cpp +++ b/lldb/source/Core/DataExtractor.cpp @@ -11,8 +11,8 @@ // C++ Includes #include <bitset> #include <cassert> -#include <cstddef> #include <cmath> +#include <cstddef> #include <sstream> #include <string> @@ -21,15 +21,15 @@ #include "llvm/ADT/APInt.h" #include "llvm/ADT/ArrayRef.h" #include "llvm/ADT/SmallVector.h" -#include "llvm/Support/MathExtras.h" #include "llvm/Support/MD5.h" +#include "llvm/Support/MathExtras.h" #include "clang/AST/ASTContext.h" // Project includes +#include "lldb/Core/DataBuffer.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" @@ -46,112 +46,92 @@ 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 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 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 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 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 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 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 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 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 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); +static inline uint64_t ReadSwapInt64(const void *ptr) { + uint64_t value; + memcpy(&value, ptr, 8); + return llvm::ByteSwap_64(value); } #define NON_PRINTABLE_CHAR '.' -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) -{ -} +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) -{ +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); + assert(addr_size == 4 || addr_size == 8); #endif } @@ -162,18 +142,16 @@ DataExtractor::DataExtractor (const void* data, offset_t length, ByteOrder endia // 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) -{ +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); + assert(addr_size == 4 || addr_size == 8); #endif - SetData (data_sp); + SetData(data_sp); } //---------------------------------------------------------------------- @@ -183,54 +161,43 @@ DataExtractor::DataExtractor (const DataBufferSP& data_sp, ByteOrder endian, uin // 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) -{ +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); + 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) -{ + 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); + 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; +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; @@ -240,37 +207,30 @@ DataExtractor::~DataExtractor() = default; // 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(); +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; - } - } +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; + } + return 0; } //---------------------------------------------------------------------- @@ -283,22 +243,18 @@ DataExtractor::GetSharedDataOffset () const // 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(); +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(); } //---------------------------------------------------------------------- @@ -315,28 +271,28 @@ DataExtractor::SetData (const void *bytes, offset_t length, ByteOrder endian) // 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; +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); + 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; + // 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; } //---------------------------------------------------------------------- @@ -353,38 +309,36 @@ DataExtractor::SetData (const DataExtractor& data, offset_t data_offset, offset_ // 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 - } - } +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(); + 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(); + // 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; + return new_size; } //---------------------------------------------------------------------- @@ -393,13 +347,11 @@ DataExtractor::SetData (const DataBufferSP& data_sp, offset_t data_offset, offse // // 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; +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; } //---------------------------------------------------------------------- @@ -411,18 +363,17 @@ DataExtractor::GetU8 (offset_t *offset_ptr) const // 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; +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; } //---------------------------------------------------------------------- @@ -431,55 +382,46 @@ DataExtractor::GetU8 (offset_t *offset_ptr, void *dst, uint32_t count) const // // 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(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; +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; +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; +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; } //---------------------------------------------------------------------- @@ -491,33 +433,28 @@ DataExtractor::GetU64_unchecked (offset_t *offset_ptr) const // 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; +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 nullptr; + // Return a non-nullptr pointer to the converted data as an indicator of + // success + return void_dst; + } + return nullptr; } //---------------------------------------------------------------------- @@ -526,23 +463,17 @@ DataExtractor::GetU16 (offset_t *offset_ptr, void *void_dst, uint32_t count) con // // 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); - } +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; + } + return val; } //---------------------------------------------------------------------- @@ -554,33 +485,28 @@ DataExtractor::GetU32 (offset_t *offset_ptr) const // 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; +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 nullptr; + // Return a non-nullptr pointer to the converted data as an indicator of + // success + return void_dst; + } + return nullptr; } //---------------------------------------------------------------------- @@ -589,23 +515,17 @@ DataExtractor::GetU32 (offset_t *offset_ptr, void *void_dst, uint32_t count) con // // 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); - } +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; + } + return val; } //---------------------------------------------------------------------- @@ -615,33 +535,28 @@ DataExtractor::GetU64 (offset_t *offset_ptr) const // 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; +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 nullptr; + // Return a non-nullptr pointer to the converted data as an indicator of + // success + return void_dst; + } + return nullptr; } //---------------------------------------------------------------------- @@ -654,19 +569,23 @@ DataExtractor::GetU64 (offset_t *offset_ptr, void *void_dst, uint32_t count) con // // 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; +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; } //---------------------------------------------------------------------- @@ -679,153 +598,154 @@ DataExtractor::GetMaxU32 (offset_t *offset_ptr, size_t byte_size) const // // 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; - } +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; +} + +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; + } + 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()); +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()); + *offset_ptr += CopyByteOrderedData(*offset_ptr, sizeof(val), &val, + sizeof(val), endian::InlHostByteOrder()); #endif - return val; + return val; } //------------------------------------------------------------------ @@ -836,22 +756,18 @@ DataExtractor::GetLongDouble (offset_t *offset_ptr) const // // RETURNS the address that was extracted, or zero on failure. //------------------------------------------------------------------ -uint64_t -DataExtractor::GetAddress (offset_t *offset_ptr) const -{ +uint64_t DataExtractor::GetAddress(offset_t *offset_ptr) const { #ifdef LLDB_CONFIGURATION_DEBUG - assert (m_addr_size == 4 || m_addr_size == 8); + assert(m_addr_size == 4 || m_addr_size == 8); #endif - return GetMaxU64 (offset_ptr, m_addr_size); + return GetMaxU64(offset_ptr, m_addr_size); } -uint64_t -DataExtractor::GetAddress_unchecked (offset_t *offset_ptr) const -{ +uint64_t DataExtractor::GetAddress_unchecked(offset_t *offset_ptr) const { #ifdef LLDB_CONFIGURATION_DEBUG - assert (m_addr_size == 4 || m_addr_size == 8); + assert(m_addr_size == 4 || m_addr_size == 8); #endif - return GetMaxU64_unchecked (offset_ptr, m_addr_size); + return GetMaxU64_unchecked(offset_ptr, m_addr_size); } //------------------------------------------------------------------ @@ -862,13 +778,11 @@ DataExtractor::GetAddress_unchecked (offset_t *offset_ptr) const // // RETURNS the pointer that was extracted, or zero on failure. //------------------------------------------------------------------ -uint64_t -DataExtractor::GetPointer (offset_t *offset_ptr) const -{ +uint64_t DataExtractor::GetPointer(offset_t *offset_ptr) const { #ifdef LLDB_CONFIGURATION_DEBUG - assert (m_addr_size == 4 || m_addr_size == 8); + assert(m_addr_size == 4 || m_addr_size == 8); #endif - return GetMaxU64 (offset_ptr, m_addr_size); + return GetMaxU64(offset_ptr, m_addr_size); } //---------------------------------------------------------------------- @@ -878,256 +792,239 @@ DataExtractor::GetPointer (offset_t *offset_ptr) const // pointer encoding. //---------------------------------------------------------------------- -uint64_t -DataExtractor::GetGNUEHPointer (offset_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 +uint64_t DataExtractor::GetGNUEHPointer( + offset_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... + 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(); + uint64_t baseAddress = 0; + uint64_t addressValue = 0; + const uint32_t addr_size = GetAddressByteSize(); #ifdef LLDB_CONFIGURATION_DEBUG - assert (addr_size == 4 || addr_size == 8); + assert(addr_size == 4 || addr_size == 8); #endif - 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; + 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; } - - // 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; - } + } 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; + } + return baseAddress + addressValue; } -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; +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; +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; +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 - { - // 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; - } + } 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; + } + return 0; } //---------------------------------------------------------------------- @@ -1141,32 +1038,28 @@ DataExtractor::CopyByteOrderedData (offset_t src_offset, // 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... +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; } - return nullptr; + + // 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; } //---------------------------------------------------------------------- @@ -1180,20 +1073,16 @@ DataExtractor::GetCStr (offset_t *offset_ptr) const // 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; +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; } - return nullptr; + *offset_ptr += len; + return cstr; + } + return nullptr; } //------------------------------------------------------------------ @@ -1204,10 +1093,8 @@ DataExtractor::GetCStr (offset_t *offset_ptr, offset_t len) const // 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); +const char *DataExtractor::PeekCStr(offset_t offset) const { + return (const char *)PeekData(offset, 1); } //---------------------------------------------------------------------- @@ -1218,36 +1105,31 @@ DataExtractor::PeekCStr (offset_t offset) const // // 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; - } - +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; } //---------------------------------------------------------------------- @@ -1258,42 +1140,38 @@ DataExtractor::GetULEB128 (offset_t *offset_ptr) const // // 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; - } +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; - // Sign bit of byte is 2nd high order bit (0x40) - if (shift < size && (byte & 0x40)) - result |= - (1 << shift); + if (src < end) { + int64_t result = 0; + int shift = 0; + int size = sizeof(int64_t) * 8; - *offset_ptr += bytecount; - return result; + 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; } - return 0; + + // 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; } //---------------------------------------------------------------------- @@ -1304,761 +1182,774 @@ DataExtractor::GetSLEB128 (offset_t *offset_ptr) const // // 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; -} +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; -static bool -GetAPInt (const DataExtractor &data, lldb::offset_t *offset_ptr, lldb::offset_t byte_size, llvm::APInt &result) -{ - llvm::SmallVector<uint64_t, 2> uint64_array; - lldb::offset_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_ptr); - bytes_left -= 8; - } - else - { - u64 = data.GetMaxU64(offset_ptr, (uint32_t)bytes_left); - bytes_left = 0; - } - uint64_array.push_back(u64); - } - result = llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array)); - return true; - } - else if (byte_order == lldb::eByteOrderBig) - { - lldb::offset_t be_offset = *offset_ptr + byte_size; - lldb::offset_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, (uint32_t)bytes_left); - bytes_left = 0; - } - uint64_array.push_back(u64); - } - *offset_ptr += byte_size; - result = llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array)); - return true; + 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; +} + +static bool GetAPInt(const DataExtractor &data, lldb::offset_t *offset_ptr, + lldb::offset_t byte_size, llvm::APInt &result) { + llvm::SmallVector<uint64_t, 2> uint64_array; + lldb::offset_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_ptr); + bytes_left -= 8; + } else { + u64 = data.GetMaxU64(offset_ptr, (uint32_t)bytes_left); + bytes_left = 0; + } + uint64_array.push_back(u64); } - return false; -} - -static lldb::offset_t -DumpAPInt (Stream *s, const DataExtractor &data, lldb::offset_t offset, lldb::offset_t byte_size, bool is_signed, unsigned radix) -{ - llvm::APInt apint; - if (GetAPInt (data, &offset, byte_size, apint)) - { - 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()); + result = llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array)); + return true; + } else if (byte_order == lldb::eByteOrderBig) { + lldb::offset_t be_offset = *offset_ptr + byte_size; + lldb::offset_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, (uint32_t)bytes_left); + bytes_left = 0; + } + uint64_array.push_back(u64); } - return offset; -} - -static float -half2float (uint16_t half) -{ - union { float f; uint32_t u; } u; - int32_t v = (int16_t) half; - - if (0 == (v & 0x7c00)) - { - u.u = v & 0x80007FFFU; - return u.f * ldexpf(1, 125); + *offset_ptr += byte_size; + result = llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array)); + return true; + } + return false; +} + +static lldb::offset_t DumpAPInt(Stream *s, const DataExtractor &data, + lldb::offset_t offset, lldb::offset_t byte_size, + bool is_signed, unsigned radix) { + llvm::APInt apint; + if (GetAPInt(data, &offset, byte_size, apint)) { + 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; +} + +static float half2float(uint16_t half) { + union { + float f; + uint32_t u; + } u; + int32_t v = (int16_t)half; + + if (0 == (v & 0x7c00)) { + u.u = v & 0x80007FFFU; + return u.f * ldexpf(1, 125); + } + + v <<= 13; + u.u = v | 0x70000000U; + return u.f * ldexpf(1, -112); +} + +lldb::offset_t DataExtractor::Dump( + Stream *s, offset_t start_offset, lldb::Format item_format, + size_t item_byte_size, size_t item_count, size_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 == nullptr) + return start_offset; + + if (item_format == eFormatPointer) { + if (item_byte_size != 4 && item_byte_size != 8) + item_byte_size = s->GetAddressByteSize(); + } + + offset_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(), nullptr, nullptr)); + if (disassembler_sp) { + lldb::addr_t addr = base_addr + start_offset; + lldb_private::Address so_addr; + bool data_from_file = true; + if (target_sp->GetSectionLoadList().ResolveLoadAddress(addr, so_addr)) { + data_from_file = false; + } else { + if (target_sp->GetSectionLoadList().IsEmpty() || + !target_sp->GetImages().ResolveFileAddress(addr, so_addr)) + so_addr.SetRawAddress(addr); + } - v <<= 13; - u.u = v | 0x70000000U; - return u.f * ldexpf(1, -112); -} - -lldb::offset_t -DataExtractor::Dump (Stream *s, - offset_t start_offset, - lldb::Format item_format, - size_t item_byte_size, - size_t item_count, - size_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 == nullptr) - return start_offset; - - if (item_format == eFormatPointer) - { - if (item_byte_size != 4 && item_byte_size != 8) - item_byte_size = s->GetAddressByteSize(); - } - - offset_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(), nullptr, nullptr)); - if (disassembler_sp) - { - lldb::addr_t addr = base_addr + start_offset; - lldb_private::Address so_addr; - bool data_from_file = true; - if (target_sp->GetSectionLoadList().ResolveLoadAddress(addr, so_addr)) - { - data_from_file = false; - } - else - { - if (target_sp->GetSectionLoadList().IsEmpty() || !target_sp->GetImages().ResolveFileAddress(addr, so_addr)) - so_addr.SetRawAddress(addr); - } - - size_t bytes_consumed = disassembler_sp->DecodeInstructions (so_addr, *this, start_offset, item_count, false, data_from_file); - - 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); - } - } + size_t bytes_consumed = disassembler_sp->DecodeInstructions( + so_addr, *this, start_offset, item_count, false, data_from_file); + + 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"); + } + } else + s->Printf("invalid target"); - return offset; + return offset; + } + + if ((item_format == eFormatOSType || item_format == eFormatAddressInfo) && + item_byte_size > 8) + item_format = eFormatHex; + + lldb::offset_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", + static_cast<int>( + (num_per_line - (offset - line_start_offset)) * 3 + 2), + ""); + Dump(s, line_start_offset, eFormatCharPrintable, 1, + offset - line_start_offset, SIZE_MAX, LLDB_INVALID_ADDRESS, 0, + 0); + } + s->EOL(); + } + if (base_addr != LLDB_INVALID_ADDRESS) + s->Printf("0x%8.8" PRIx64 ": ", + (uint64_t)(base_addr + + (offset - start_offset) / m_target_byte_size)); + + line_start_offset = offset; + } else if (item_format != eFormatChar && + item_format != eFormatCharPrintable && + item_format != eFormatCharArray && count > 0) { + s->PutChar(' '); } - if ((item_format == eFormatOSType || item_format == eFormatAddressInfo) && item_byte_size > 8) - item_format = eFormatHex; - - lldb::offset_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", static_cast<int>((num_per_line - (offset - line_start_offset)) * 3 + 2), ""); - Dump(s, line_start_offset, eFormatCharPrintable, 1, offset - line_start_offset, SIZE_MAX, LLDB_INVALID_ADDRESS, 0, 0); - } - s->EOL(); - } - if (base_addr != LLDB_INVALID_ADDRESS) - s->Printf ("0x%8.8" PRIx64 ": ", - (uint64_t)(base_addr + (offset - start_offset)/m_target_byte_size )); - - line_start_offset = offset; - } - else if (item_format != eFormatChar && - item_format != eFormatCharPrintable && - item_format != eFormatCharArray && - count > 0) - { - s->PutChar(' '); + switch (item_format) { + case eFormatBoolean: + if (item_byte_size <= 8) + s->Printf("%s", GetMaxU64Bitfield(&offset, item_byte_size, + item_bit_size, item_bit_offset) + ? "true" + : "false"); + else { + s->Printf("error: unsupported byte size (%" PRIu64 + ") for boolean format", + (uint64_t)item_byte_size); + return offset; + } + 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 (uint32_t 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 (uint32_t 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("%" PRIu64, ch); + break; } - - switch (item_format) - { - case eFormatBoolean: - if (item_byte_size <= 8) - s->Printf ("%s", GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset) ? "true" : "false"); - else - { - s->Printf("error: unsupported byte size (%" PRIu64 ") for boolean format", (uint64_t)item_byte_size); - return offset; - } + } 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 eFormatEnum: // Print enum value as a signed integer when we don't get + // the enum type + case eFormatDecimal: + if (item_byte_size <= 8) + s->Printf("%" PRId64, + 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("%" PRIu64, + 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%" PRIo64, + 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 (uint32_t 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 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 (uint32_t 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); - } + case '\a': + s->Printf("\\a"); break; - - case eFormatBytes: - case eFormatBytesWithASCII: - for (uint32_t 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(' '); + case '\b': + s->Printf("\\b"); 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 ("%" PRIu64, 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('\''); - } + case '\f': + s->Printf("\\f"); break; - - case eFormatEnum: // Print enum value as a signed integer when we don't get the enum type - case eFormatDecimal: - if (item_byte_size <= 8) - s->Printf ("%" PRId64, 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); - } + case '\n': + s->Printf("\\n"); break; - - case eFormatUnsigned: - if (item_byte_size <= 8) - s->Printf ("%" PRIu64, 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); - } + case '\r': + s->Printf("\\r"); break; - - case eFormatOctal: - if (item_byte_size <= 8) - s->Printf ("0%" PRIo64, 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); - } + case '\t': + s->Printf("\\t"); break; - - case eFormatOSType: - { - uint64_t uval64 = GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset); - s->PutChar('\''); - for (uint32_t 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('\''); - } + case '\v': + s->Printf("\\v"); break; - - case eFormatCString: - { - const char *cstr = GetCStr(&offset); - - if (!cstr) - { - s->Printf("NULL"); - offset = LLDB_INVALID_OFFSET; - } - 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('\"'); - } - } + case '\0': + s->Printf("\\0"); break; - - - case eFormatPointer: - s->Address(GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset), sizeof (addr_t)); + default: + s->Printf("\\x%2.2x", ch); break; - - - case eFormatComplexInteger: - { - size_t complex_int_byte_size = item_byte_size / 2; - - if (complex_int_byte_size > 0 && complex_int_byte_size <= 8) - { - s->Printf("%" PRIu64, GetMaxU64Bitfield(&offset, complex_int_byte_size, 0, 0)); - s->Printf(" + %" PRIu64 "i", GetMaxU64Bitfield(&offset, complex_int_byte_size, 0, 0)); - } - else - { - s->Printf("error: unsupported byte size (%" PRIu64 ") for complex integer format", (uint64_t)item_byte_size); - return offset; - } + } + } + } + s->PutChar('\''); + } break; + + case eFormatCString: { + const char *cstr = GetCStr(&offset); + + if (!cstr) { + s->Printf("NULL"); + offset = LLDB_INVALID_OFFSET; + } 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; } - 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); + ++cstr; + } - 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("error: unsupported byte size (%" PRIu64 ") for complex float format", (uint64_t)item_byte_size); - return offset; - } - break; + s->PutChar('\"'); + } + } break; + + case eFormatPointer: + s->Address(GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, + item_bit_offset), + sizeof(addr_t)); + break; + + case eFormatComplexInteger: { + size_t complex_int_byte_size = item_byte_size / 2; + + if (complex_int_byte_size > 0 && complex_int_byte_size <= 8) { + s->Printf("%" PRIu64, + GetMaxU64Bitfield(&offset, complex_int_byte_size, 0, 0)); + s->Printf(" + %" PRIu64 "i", + GetMaxU64Bitfield(&offset, complex_int_byte_size, 0, 0)); + } else { + s->Printf("error: unsupported byte size (%" PRIu64 + ") for complex integer format", + (uint64_t)item_byte_size); + return offset; + } + } break; - default: - case eFormatDefault: - case eFormatHex: - case eFormatHexUppercase: - { - bool wantsuppercase = (item_format == eFormatHexUppercase); - switch (item_byte_size) - { - case 1: - case 2: - case 4: - case 8: - s->Printf(wantsuppercase ? "0x%*.*" PRIX64 : "0x%*.*" PRIx64, (int)(2 * item_byte_size), (int)(2 * item_byte_size), GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset)); - break; - default: - { - assert (item_bit_size == 0 && item_bit_offset == 0); - const uint8_t *bytes = (const uint8_t* )GetData(&offset, item_byte_size); - if (bytes) - { - s->PutCString("0x"); - uint32_t idx; - if (m_byte_order == eByteOrderBig) - { - for (idx = 0; idx < item_byte_size; ++idx) - s->Printf(wantsuppercase ? "%2.2X" : "%2.2x", bytes[idx]); - } - else - { - for (idx = 0; idx < item_byte_size; ++idx) - s->Printf(wantsuppercase ? "%2.2X" : "%2.2x", bytes[item_byte_size - 1 - idx]); - } - } - } - break; - } - } - break; + case eFormatComplex: + if (sizeof(float) * 2 == item_byte_size) { + float f32_1 = GetFloat(&offset); + float f32_2 = GetFloat(&offset); - case eFormatFloat: - { - TargetSP target_sp; - bool used_apfloat = false; - if (exe_scope) - target_sp = exe_scope->CalculateTarget(); - if (target_sp) - { - ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); - if (clang_ast) - { - clang::ASTContext *ast = clang_ast->getASTContext(); - if (ast) - { - llvm::SmallVector<char, 256> sv; - // Show full precision when printing float values - const unsigned format_precision = 0; - const unsigned format_max_padding = 100; - size_t item_bit_size = item_byte_size * 8; - - if (item_bit_size == ast->getTypeSize(ast->FloatTy)) - { - llvm::APInt apint(item_bit_size, this->GetMaxU64(&offset, item_byte_size)); - llvm::APFloat apfloat (ast->getFloatTypeSemantics(ast->FloatTy), apint); - apfloat.toString(sv, format_precision, format_max_padding); - } - else if (item_bit_size == ast->getTypeSize(ast->DoubleTy)) - { - llvm::APInt apint; - if (GetAPInt (*this, &offset, item_byte_size, apint)) - { - llvm::APFloat apfloat (ast->getFloatTypeSemantics(ast->DoubleTy), apint); - apfloat.toString(sv, format_precision, format_max_padding); - } - } - else if (item_bit_size == ast->getTypeSize(ast->LongDoubleTy)) - { - const auto &semantics = ast->getFloatTypeSemantics(ast->LongDoubleTy); - const auto byte_size = (llvm::APFloat::getSizeInBits(semantics) + 7) / 8; - - llvm::APInt apint; - if (GetAPInt(*this, &offset, byte_size, apint)) - { - llvm::APFloat apfloat(semantics, apint); - apfloat.toString(sv, format_precision, format_max_padding); - } - } - else if (item_bit_size == ast->getTypeSize(ast->HalfTy)) - { - llvm::APInt apint(item_bit_size, this->GetU16(&offset)); - llvm::APFloat apfloat (ast->getFloatTypeSemantics(ast->HalfTy), apint); - apfloat.toString(sv, format_precision, format_max_padding); - } - - if (!sv.empty()) - { - s->Printf("%*.*s", (int)sv.size(), (int)sv.size(), sv.data()); - used_apfloat = true; - } - } - } - } - - if (!used_apfloat) - { - std::ostringstream ss; - if (item_byte_size == sizeof(float) || item_byte_size == 2) - { - float f; - if (item_byte_size == 2) - { - uint16_t half = this->GetU16(&offset); - f = half2float(half); - } - else - { - f = GetFloat (&offset); - } - ss.precision(std::numeric_limits<float>::digits10); - ss << f; - } - else if (item_byte_size == sizeof(double)) - { - ss.precision(std::numeric_limits<double>::digits10); - ss << GetDouble(&offset); - } - else if (item_byte_size == sizeof(long double) || item_byte_size == 10) - { - ss.precision(std::numeric_limits<long double>::digits10); - ss << GetLongDouble(&offset); - } - else - { - s->Printf("error: unsupported byte size (%" PRIu64 ") for float format", (uint64_t)item_byte_size); - return offset; - } - ss.flush(); - s->Printf("%s", ss.str().c_str()); - } - } - break; - - case eFormatUnicode16: - s->Printf("U+%4.4x", GetU16 (&offset)); - break; + 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); - case eFormatUnicode32: - s->Printf("U+0x%8.8x", GetU32 (&offset)); - break; + 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("error: unsupported byte size (%" PRIu64 + ") for complex float format", + (uint64_t)item_byte_size); + return offset; + } + break; - case eFormatAddressInfo: - { - addr_t addr = GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, item_bit_offset); - s->Printf("0x%*.*" PRIx64, (int)(2 * item_byte_size), (int)(2 * item_byte_size), addr); - if (exe_scope) - { - TargetSP target_sp (exe_scope->CalculateTarget()); - lldb_private::Address so_addr; - if (target_sp) - { - if (target_sp->GetSectionLoadList().ResolveLoadAddress(addr, so_addr)) - { - s->PutChar(' '); - so_addr.Dump (s, - exe_scope, - Address::DumpStyleResolvedDescription, - Address::DumpStyleModuleWithFileAddress); - } - else - { - so_addr.SetOffset(addr); - so_addr.Dump (s, exe_scope, Address::DumpStyleResolvedPointerDescription); - } - } - } + default: + case eFormatDefault: + case eFormatHex: + case eFormatHexUppercase: { + bool wantsuppercase = (item_format == eFormatHexUppercase); + switch (item_byte_size) { + case 1: + case 2: + case 4: + case 8: + s->Printf(wantsuppercase ? "0x%*.*" PRIX64 : "0x%*.*" PRIx64, + (int)(2 * item_byte_size), (int)(2 * item_byte_size), + GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size, + item_bit_offset)); + break; + default: { + assert(item_bit_size == 0 && item_bit_offset == 0); + const uint8_t *bytes = + (const uint8_t *)GetData(&offset, item_byte_size); + if (bytes) { + s->PutCString("0x"); + uint32_t idx; + if (m_byte_order == eByteOrderBig) { + for (idx = 0; idx < item_byte_size; ++idx) + s->Printf(wantsuppercase ? "%2.2X" : "%2.2x", bytes[idx]); + } else { + for (idx = 0; idx < item_byte_size; ++idx) + s->Printf(wantsuppercase ? "%2.2X" : "%2.2x", + bytes[item_byte_size - 1 - idx]); + } + } + } break; + } + } break; + + case eFormatFloat: { + TargetSP target_sp; + bool used_apfloat = false; + if (exe_scope) + target_sp = exe_scope->CalculateTarget(); + if (target_sp) { + ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext(); + if (clang_ast) { + clang::ASTContext *ast = clang_ast->getASTContext(); + if (ast) { + llvm::SmallVector<char, 256> sv; + // Show full precision when printing float values + const unsigned format_precision = 0; + const unsigned format_max_padding = 100; + size_t item_bit_size = item_byte_size * 8; + + if (item_bit_size == ast->getTypeSize(ast->FloatTy)) { + llvm::APInt apint(item_bit_size, + this->GetMaxU64(&offset, item_byte_size)); + llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->FloatTy), + apint); + apfloat.toString(sv, format_precision, format_max_padding); + } else if (item_bit_size == ast->getTypeSize(ast->DoubleTy)) { + llvm::APInt apint; + if (GetAPInt(*this, &offset, item_byte_size, apint)) { + llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->DoubleTy), + apint); + apfloat.toString(sv, format_precision, format_max_padding); + } + } else if (item_bit_size == ast->getTypeSize(ast->LongDoubleTy)) { + const auto &semantics = + ast->getFloatTypeSemantics(ast->LongDoubleTy); + const auto byte_size = + (llvm::APFloat::getSizeInBits(semantics) + 7) / 8; + + llvm::APInt apint; + if (GetAPInt(*this, &offset, byte_size, apint)) { + llvm::APFloat apfloat(semantics, apint); + apfloat.toString(sv, format_precision, format_max_padding); + } + } else if (item_bit_size == ast->getTypeSize(ast->HalfTy)) { + llvm::APInt apint(item_bit_size, this->GetU16(&offset)); + llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->HalfTy), + apint); + apfloat.toString(sv, format_precision, format_max_padding); } - 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; + if (!sv.empty()) { + s->Printf("%*.*s", (int)sv.size(), (int)sv.size(), sv.data()); + used_apfloat = true; } - 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("error: unsupported byte size (%" PRIu64 ") for hex float format", (uint64_t)item_byte_size); - return 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(uint64_t), item_byte_size / sizeof(uint64_t), item_byte_size / sizeof(uint64_t), LLDB_INVALID_ADDRESS, 0, 0); - s->PutChar('}'); - break; - - case eFormatVectorOfFloat16: - s->PutChar('{'); - offset = Dump (s, offset, eFormatFloat, 2, item_byte_size / 2, item_byte_size / 2, 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 (!used_apfloat) { + std::ostringstream ss; + if (item_byte_size == sizeof(float) || item_byte_size == 2) { + float f; + if (item_byte_size == 2) { + uint16_t half = this->GetU16(&offset); + f = half2float(half); + } else { + f = GetFloat(&offset); + } + ss.precision(std::numeric_limits<float>::digits10); + ss << f; + } else if (item_byte_size == sizeof(double)) { + ss.precision(std::numeric_limits<double>::digits10); + ss << GetDouble(&offset); + } else if (item_byte_size == sizeof(long double) || + item_byte_size == 10) { + ss.precision(std::numeric_limits<long double>::digits10); + ss << GetLongDouble(&offset); + } else { + s->Printf("error: unsupported byte size (%" PRIu64 + ") for float format", + (uint64_t)item_byte_size); + return offset; } + ss.flush(); + s->Printf("%s", ss.str().c_str()); + } + } break; + + case eFormatUnicode16: + s->Printf("U+%4.4x", GetU16(&offset)); + break; + + case eFormatUnicode32: + s->Printf("U+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%*.*" PRIx64, (int)(2 * item_byte_size), + (int)(2 * item_byte_size), addr); + if (exe_scope) { + TargetSP target_sp(exe_scope->CalculateTarget()); + lldb_private::Address so_addr; + if (target_sp) { + if (target_sp->GetSectionLoadList().ResolveLoadAddress(addr, + so_addr)) { + s->PutChar(' '); + so_addr.Dump(s, exe_scope, Address::DumpStyleResolvedDescription, + Address::DumpStyleModuleWithFileAddress); + } else { + so_addr.SetOffset(addr); + so_addr.Dump(s, exe_scope, + Address::DumpStyleResolvedPointerDescription); + } + } + } + } 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("error: unsupported byte size (%" PRIu64 + ") for hex float format", + (uint64_t)item_byte_size); + return 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(uint64_t), + item_byte_size / sizeof(uint64_t), + item_byte_size / sizeof(uint64_t), LLDB_INVALID_ADDRESS, 0, 0); + s->PutChar('}'); + break; + + case eFormatVectorOfFloat16: + s->PutChar('{'); + offset = Dump(s, offset, eFormatFloat, 2, item_byte_size / 2, + item_byte_size / 2, 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", static_cast<int>((num_per_line - (offset - line_start_offset)) * 3 + 2), ""); - Dump(s, line_start_offset, eFormatCharPrintable, 1, offset - line_start_offset, SIZE_MAX, LLDB_INVALID_ADDRESS, 0, 0); - } - return offset; // Return the offset at which we ended up + if (item_format == eFormatBytesWithASCII && offset > line_start_offset) { + s->Printf("%*s", static_cast<int>( + (num_per_line - (offset - line_start_offset)) * 3 + 2), + ""); + Dump(s, line_start_offset, eFormatCharPrintable, 1, + offset - line_start_offset, SIZE_MAX, LLDB_INVALID_ADDRESS, 0, 0); + } + return offset; // Return the offset at which we ended up } //---------------------------------------------------------------------- @@ -2073,59 +1964,65 @@ DataExtractor::Dump (Stream *s, // 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->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.8" PRIx64 ":", (uint64_t)(base_addr + (offset - start_offset))); - } +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->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.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; - } + 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.GetSize() > 0) - log->Printf("%s", sstr.GetData()); + if (sstr.GetSize() > 0) + log->Printf("%s", sstr.GetData()); - return offset; // Return the offset at which we ended up + return offset; // Return the offset at which we ended up } //---------------------------------------------------------------------- @@ -2133,137 +2030,114 @@ DataExtractor::PutToLog(Log *log, // // 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); - } +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); } -} - -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) - { - // 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(); -} + } +} + +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) { + // 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; -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); - + 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); - +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()); +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; + llvm::MD5 md5; - const llvm::ArrayRef<uint8_t> data(GetDataStart(),max_data); - md5.update(data); + const llvm::ArrayRef<uint8_t> data(GetDataStart(), max_data); + md5.update(data); - llvm::MD5::MD5Result result; - md5.final(result); + llvm::MD5::MD5Result result; + md5.final(result); - dest.resize(16); - std::copy(result, - result+16, - dest.begin()); + dest.resize(16); + std::copy(result, result + 16, dest.begin()); } |
