| //===-- DNBDataRef.cpp ------------------------------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| // |
| // Created by Greg Clayton on 1/11/06. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "DNBDataRef.h" |
| #include "DNBLog.h" |
| #include <assert.h> |
| #include <ctype.h> |
| #include <libkern/OSByteOrder.h> |
| |
| //---------------------------------------------------------------------- |
| // Constructor |
| //---------------------------------------------------------------------- |
| |
| DNBDataRef::DNBDataRef() : |
| m_start(NULL), |
| m_end(NULL), |
| m_swap(false), |
| m_ptrSize(0), |
| m_addrPCRelative(INVALID_NUB_ADDRESS), |
| m_addrTEXT(INVALID_NUB_ADDRESS), |
| m_addrDATA(INVALID_NUB_ADDRESS) |
| { |
| } |
| |
| |
| //---------------------------------------------------------------------- |
| // Constructor |
| //---------------------------------------------------------------------- |
| |
| DNBDataRef::DNBDataRef(const uint8_t *start, size_t size, bool swap) : |
| m_start(start), |
| m_end(start+size), |
| m_swap(swap), |
| m_ptrSize(0), |
| m_addrPCRelative(INVALID_NUB_ADDRESS), |
| m_addrTEXT(INVALID_NUB_ADDRESS), |
| m_addrDATA(INVALID_NUB_ADDRESS) |
| { |
| } |
| |
| |
| //---------------------------------------------------------------------- |
| // Destructor |
| //---------------------------------------------------------------------- |
| |
| DNBDataRef::~DNBDataRef() |
| { |
| } |
| |
| |
| //---------------------------------------------------------------------- |
| // Get8 |
| //---------------------------------------------------------------------- |
| uint8_t |
| DNBDataRef::Get8(offset_t *offset_ptr) const |
| { |
| uint8_t val = 0; |
| if ( ValidOffsetForDataOfSize(*offset_ptr, sizeof(val)) ) |
| { |
| val = *(m_start + *offset_ptr); |
| *offset_ptr += sizeof(val); |
| } |
| return val; |
| } |
| |
| |
| //---------------------------------------------------------------------- |
| // Get16 |
| //---------------------------------------------------------------------- |
| uint16_t |
| DNBDataRef::Get16(offset_t *offset_ptr) const |
| { |
| uint16_t val = 0; |
| if ( ValidOffsetForDataOfSize(*offset_ptr, sizeof(val)) ) |
| { |
| const uint8_t *p = m_start + *offset_ptr; |
| val = *(uint16_t*)p; |
| |
| if (m_swap) |
| val = OSSwapInt16(val); |
| |
| // Advance the offset |
| *offset_ptr += sizeof(val); |
| } |
| return val; |
| } |
| |
| |
| //---------------------------------------------------------------------- |
| // Get32 |
| //---------------------------------------------------------------------- |
| uint32_t |
| DNBDataRef::Get32(offset_t *offset_ptr) const |
| { |
| uint32_t val = 0; |
| if ( ValidOffsetForDataOfSize(*offset_ptr, sizeof(val)) ) |
| { |
| const uint8_t *p = m_start + *offset_ptr; |
| val = *(uint32_t*)p; |
| if (m_swap) |
| val = OSSwapInt32(val); |
| |
| // Advance the offset |
| *offset_ptr += sizeof(val); |
| } |
| return val; |
| } |
| |
| |
| //---------------------------------------------------------------------- |
| // Get64 |
| //---------------------------------------------------------------------- |
| uint64_t |
| DNBDataRef::Get64(offset_t *offset_ptr) const |
| { |
| uint64_t val = 0; |
| if ( ValidOffsetForDataOfSize(*offset_ptr, sizeof(val)) ) |
| { |
| const uint8_t *p = m_start + *offset_ptr; |
| val = *(uint64_t*)p; |
| if (m_swap) |
| val = OSSwapInt64(val); |
| |
| // Advance the offset |
| *offset_ptr += sizeof(val); |
| } |
| return val; |
| } |
| |
| |
| //---------------------------------------------------------------------- |
| // GetMax32 |
| // |
| // Used for calls when the size can vary. Fill in extra cases if they |
| // are ever needed. |
| //---------------------------------------------------------------------- |
| uint32_t |
| DNBDataRef::GetMax32(offset_t *offset_ptr, uint32_t byte_size) const |
| { |
| switch (byte_size) |
| { |
| case 1: return Get8 (offset_ptr); break; |
| case 2: return Get16(offset_ptr); break; |
| case 4: return Get32(offset_ptr); break; |
| default: |
| assert(!"GetMax32 unhandled case!"); |
| break; |
| } |
| return 0; |
| } |
| |
| |
| //---------------------------------------------------------------------- |
| // GetMax64 |
| // |
| // Used for calls when the size can vary. Fill in extra cases if they |
| // are ever needed. |
| //---------------------------------------------------------------------- |
| uint64_t |
| DNBDataRef::GetMax64(offset_t *offset_ptr, uint32_t size) const |
| { |
| switch (size) |
| { |
| case 1: return Get8 (offset_ptr); break; |
| case 2: return Get16(offset_ptr); break; |
| case 4: return Get32(offset_ptr); break; |
| case 8: return Get64(offset_ptr); break; |
| default: |
| assert(!"GetMax64 unhandled case!"); |
| break; |
| } |
| return 0; |
| } |
| |
| //---------------------------------------------------------------------- |
| // GetPointer |
| // |
| // Extract a pointer value from the buffer. The pointer size must be |
| // set prior to using this using one of the SetPointerSize functions. |
| //---------------------------------------------------------------------- |
| uint64_t |
| DNBDataRef::GetPointer(offset_t *offset_ptr) const |
| { |
| // Must set pointer size prior to using this call |
| assert(m_ptrSize != 0); |
| return GetMax64(offset_ptr, m_ptrSize); |
| } |
| |
| //---------------------------------------------------------------------- |
| // GetDwarfEHPtr |
| // |
| // Used for calls when the value type is specified by a DWARF EH Frame |
| // pointer encoding. |
| //---------------------------------------------------------------------- |
| /* |
| uint64_t |
| DNBDataRef::GetDwarfEHPtr(offset_t *offset_ptr, uint32_t encoding) const |
| { |
| if (encoding == DW_EH_PE_omit) |
| return ULLONG_MAX; // Value isn't in the buffer... |
| |
| uint64_t baseAddress = 0; |
| uint64_t addressValue = 0; |
| |
| BOOL signExtendValue = NO; |
| // Decode the base part or adjust our offset |
| switch (encoding & 0x70) |
| { |
| case DW_EH_PE_pcrel: |
| // SetEHPtrBaseAddresses should be called prior to extracting these |
| // so the base addresses are cached. |
| assert(m_addrPCRelative != INVALID_NUB_ADDRESS); |
| signExtendValue = YES; |
| baseAddress = *offset_ptr + m_addrPCRelative; |
| break; |
| |
| case DW_EH_PE_textrel: |
| // SetEHPtrBaseAddresses should be called prior to extracting these |
| // so the base addresses are cached. |
| assert(m_addrTEXT != INVALID_NUB_ADDRESS); |
| signExtendValue = YES; |
| baseAddress = m_addrTEXT; |
| break; |
| |
| case DW_EH_PE_datarel: |
| // SetEHPtrBaseAddresses should be called prior to extracting these |
| // so the base addresses are cached. |
| assert(m_addrDATA != INVALID_NUB_ADDRESS); |
| signExtendValue = YES; |
| baseAddress = m_addrDATA; |
| break; |
| |
| case DW_EH_PE_funcrel: |
| signExtendValue = YES; |
| break; |
| |
| case DW_EH_PE_aligned: |
| // SetPointerSize should be called prior to extracting these so the |
| // pointer size is cached |
| assert(m_ptrSize != 0); |
| if (m_ptrSize) |
| { |
| // Align to a address size boundary first |
| uint32_t alignOffset = *offset_ptr % m_ptrSize; |
| if (alignOffset) |
| offset_ptr += m_ptrSize - alignOffset; |
| } |
| break; |
| |
| default: |
| break; |
| } |
| |
| // Decode the value part |
| switch (encoding & DW_EH_PE_MASK_ENCODING) |
| { |
| case DW_EH_PE_absptr : addressValue = GetPointer(offset_ptr); break; |
| case DW_EH_PE_uleb128 : addressValue = Get_ULEB128(offset_ptr); break; |
| case DW_EH_PE_udata2 : addressValue = Get16(offset_ptr); break; |
| case DW_EH_PE_udata4 : addressValue = Get32(offset_ptr); break; |
| case DW_EH_PE_udata8 : addressValue = Get64(offset_ptr); break; |
| case DW_EH_PE_sleb128 : addressValue = Get_SLEB128(offset_ptr); break; |
| case DW_EH_PE_sdata2 : addressValue = (int16_t)Get16(offset_ptr); break; |
| case DW_EH_PE_sdata4 : addressValue = (int32_t)Get32(offset_ptr); break; |
| case DW_EH_PE_sdata8 : addressValue = (int64_t)Get64(offset_ptr); break; |
| default: |
| // Unhandled encoding type |
| assert(encoding); |
| break; |
| } |
| |
| // Since we promote everything to 64 bit, we may need to sign extend |
| if (signExtendValue && m_ptrSize < sizeof(baseAddress)) |
| { |
| uint64_t sign_bit = 1ull << ((m_ptrSize * 8ull) - 1ull); |
| if (sign_bit & addressValue) |
| { |
| uint64_t mask = ~sign_bit + 1; |
| addressValue |= mask; |
| } |
| } |
| return baseAddress + addressValue; |
| } |
| */ |
| |
| |
| //---------------------------------------------------------------------- |
| // GetCStr |
| //---------------------------------------------------------------------- |
| const char * |
| DNBDataRef::GetCStr(offset_t *offset_ptr, uint32_t fixed_length) const |
| { |
| const char *s = NULL; |
| if ( m_start < m_end ) |
| { |
| s = (char*)m_start + *offset_ptr; |
| |
| // Advance the offset |
| if (fixed_length) |
| *offset_ptr += fixed_length; |
| else |
| *offset_ptr += strlen(s) + 1; |
| } |
| return s; |
| } |
| |
| |
| //---------------------------------------------------------------------- |
| // GetData |
| //---------------------------------------------------------------------- |
| const uint8_t * |
| DNBDataRef::GetData(offset_t *offset_ptr, uint32_t length) const |
| { |
| const uint8_t *data = NULL; |
| if ( length > 0 && ValidOffsetForDataOfSize(*offset_ptr, length) ) |
| { |
| data = m_start + *offset_ptr; |
| *offset_ptr += length; |
| } |
| return data; |
| } |
| |
| |
| //---------------------------------------------------------------------- |
| // Get_ULEB128 |
| //---------------------------------------------------------------------- |
| uint64_t |
| DNBDataRef::Get_ULEB128 (offset_t *offset_ptr) const |
| { |
| uint64_t result = 0; |
| if ( m_start < m_end ) |
| { |
| int shift = 0; |
| const uint8_t *src = m_start + *offset_ptr; |
| uint8_t byte; |
| int bytecount = 0; |
| |
| while (src < m_end) |
| { |
| bytecount++; |
| byte = *src++; |
| result |= (byte & 0x7f) << shift; |
| shift += 7; |
| if ((byte & 0x80) == 0) |
| break; |
| } |
| |
| *offset_ptr += bytecount; |
| } |
| return result; |
| } |
| |
| |
| //---------------------------------------------------------------------- |
| // Get_SLEB128 |
| //---------------------------------------------------------------------- |
| int64_t |
| DNBDataRef::Get_SLEB128 (offset_t *offset_ptr) const |
| { |
| int64_t result = 0; |
| |
| if ( m_start < m_end ) |
| { |
| int shift = 0; |
| int size = sizeof (uint32_t) * 8; |
| const uint8_t *src = m_start + *offset_ptr; |
| |
| uint8_t byte = 0; |
| int bytecount = 0; |
| |
| while (src < m_end) |
| { |
| bytecount++; |
| byte = *src++; |
| result |= (byte & 0x7f) << shift; |
| shift += 7; |
| if ((byte & 0x80) == 0) |
| break; |
| } |
| |
| // Sign bit of byte is 2nd high order bit (0x40) |
| if (shift < size && (byte & 0x40)) |
| result |= - (1ll << shift); |
| |
| *offset_ptr += bytecount; |
| } |
| return result; |
| } |
| |
| |
| //---------------------------------------------------------------------- |
| // Skip_LEB128 |
| // |
| // Skips past ULEB128 and SLEB128 numbers (just updates the offset) |
| //---------------------------------------------------------------------- |
| void |
| DNBDataRef::Skip_LEB128 (offset_t *offset_ptr) const |
| { |
| if ( m_start < m_end ) |
| { |
| const uint8_t *start = m_start + *offset_ptr; |
| const uint8_t *src = start; |
| |
| while ((src < m_end) && (*src++ & 0x80)) |
| /* Do nothing */; |
| |
| *offset_ptr += src - start; |
| } |
| } |
| |
| uint32_t |
| DNBDataRef::Dump |
| ( |
| uint32_t startOffset, |
| uint32_t endOffset, |
| uint64_t offsetBase, |
| DNBDataRef::Type type, |
| uint32_t numPerLine, |
| const char *format |
| ) |
| { |
| uint32_t offset; |
| uint32_t count; |
| char str[1024]; |
| str[0] = '\0'; |
| int str_offset = 0; |
| |
| for (offset = startOffset, count = 0; ValidOffset(offset) && offset < endOffset; ++count) |
| { |
| if ((count % numPerLine) == 0) |
| { |
| // Print out any previous string |
| if (str[0] != '\0') |
| DNBLog("%s", str); |
| // Reset string offset and fill the current line string with address: |
| str_offset = 0; |
| str_offset += snprintf(str, sizeof(str), "0x%8.8llx:", (uint64_t)(offsetBase + (offset - startOffset))); |
| } |
| |
| // Make sure we don't pass the bounds of our current string buffer on each iteration through this loop |
| if (str_offset >= sizeof(str)) |
| { |
| // The last snprintf consumed our string buffer, we will need to dump this out |
| // and reset the string with no address |
| DNBLog("%s", str); |
| str_offset = 0; |
| str[0] = '\0'; |
| } |
| |
| // We already checked that there is at least some room in the string str above, so it is safe to make |
| // the snprintf call each time through this loop |
| switch (type) |
| { |
| default: |
| case TypeUInt8: str_offset += snprintf(str + str_offset, sizeof(str) - str_offset, format ? format : " %2.2x", Get8(&offset)); break; |
| case TypeChar: |
| { |
| char ch = Get8(&offset); |
| str_offset += snprintf(str + str_offset, sizeof(str) - str_offset, format ? format : " %c", isprint(ch) ? ch : ' '); |
| } |
| break; |
| case TypeUInt16: str_offset += snprintf(str + str_offset, sizeof(str) - str_offset, format ? format : " %4.4x", Get16(&offset)); break; |
| case TypeUInt32: str_offset += snprintf(str + str_offset, sizeof(str) - str_offset, format ? format : " %8.8x", Get32(&offset)); break; |
| case TypeUInt64: str_offset += snprintf(str + str_offset, sizeof(str) - str_offset, format ? format : " %16.16llx", Get64(&offset)); break; |
| case TypePointer: str_offset += snprintf(str + str_offset, sizeof(str) - str_offset, format ? format : " 0x%llx", GetPointer(&offset)); break; |
| case TypeULEB128: str_offset += snprintf(str + str_offset, sizeof(str) - str_offset, format ? format : " 0x%llx", Get_ULEB128(&offset)); break; |
| case TypeSLEB128: str_offset += snprintf(str + str_offset, sizeof(str) - str_offset, format ? format : " %lld", Get_SLEB128(&offset)); break; |
| } |
| } |
| |
| if (str[0] != '\0') |
| DNBLog("%s", str); |
| |
| return offset; // Return the offset at which we ended up |
| } |
