b9c1b51e45
*** 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
352 lines
11 KiB
C++
352 lines
11 KiB
C++
//===-- 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);
|
|
}
|
|
//----------------------------------------------------------------------
|
|
// 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 |= (uint64_t)(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 |= (int64_t)(byte & 0x7f) << shift;
|
|
shift += 7;
|
|
if ((byte & 0x80) == 0)
|
|
break;
|
|
}
|
|
|
|
// Sign bit of byte is 2nd high order bit (0x40)
|
|
if (shift < size && (byte & 0x40))
|
|
result |= -(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';
|
|
size_t 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) {
|
|
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
|
|
}
|