maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lldb/tools/debugserver/source/DNBDataRef.cpp

486 lines
15 KiB
C++
Raw Blame History

//===-- 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
}
Reference in New Issue View Git Blame Copy Permalink