d1767f05b5
take a SymbolFile reference and a lldb::user_id_t and be used in objects which represent things in debug symbols that have types where we don't need to know the true type yet, such as in lldb_private::Variable objects. This allows us to defer resolving the type until something is used. More specifically this allows us to get 1000 local variables from the current function, and if the user types "frame variable argc", we end up _only_ resolving the type for "argc" and not for the 999 other local variables. We can expand the use of this as needed in the future. Modified the DWARFMappedHash class to be able to read the HashData that has more than just the DIE offset. It currently will read the atoms in the header definition and read the data correctly. Currently only the DIE offset and type flags are supported. This is needed for adding type flags to the .apple_types hash accelerator tables. Fixed a assertion crash that would happen if we have a variable that had a DW_AT_const_value instead of a location where "location.LocationContains_DW_OP_addr()" would end up asserting when it tried to parse the variable location as a DWARF opcode list. Decreased the amount of memory that LLDB would use when evaluating an expression by 3x - 4x for clang. There was a place in the namespace lookup code that was parsing all namespaces with a certain name in a DWARF file instead of stopping when it found the first match. This was causing all of the compile units with a matching namespace to get parsed into memory and causing unnecessary memory bloat. Improved "Target::EvaluateExpression(...)" to not try and find a variable when the expression contains characters that would certainly cause an expression to need to be evaluated by the debugger. llvm-svn: 146130
660 lines
22 KiB
C++
660 lines
22 KiB
C++
//===-- DWARFFormValue.cpp --------------------------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#include <assert.h>
|
|
|
|
#include "lldb/Core/dwarf.h"
|
|
#include "lldb/Core/Stream.h"
|
|
|
|
#include "DWARFFormValue.h"
|
|
#include "DWARFCompileUnit.h"
|
|
|
|
class DWARFCompileUnit;
|
|
|
|
using namespace lldb_private;
|
|
|
|
|
|
static uint8_t g_form_sizes_addr4[] =
|
|
{
|
|
0, // 0x00 unused
|
|
4, // 0x01 DW_FORM_addr
|
|
0, // 0x02 unused
|
|
0, // 0x03 DW_FORM_block2
|
|
0, // 0x04 DW_FORM_block4
|
|
2, // 0x05 DW_FORM_data2
|
|
4, // 0x06 DW_FORM_data4
|
|
8, // 0x07 DW_FORM_data8
|
|
0, // 0x08 DW_FORM_string
|
|
0, // 0x09 DW_FORM_block
|
|
0, // 0x0a DW_FORM_block1
|
|
1, // 0x0b DW_FORM_data1
|
|
1, // 0x0c DW_FORM_flag
|
|
0, // 0x0d DW_FORM_sdata
|
|
4, // 0x0e DW_FORM_strp
|
|
0, // 0x0f DW_FORM_udata
|
|
4, // 0x10 DW_FORM_ref_addr
|
|
1, // 0x11 DW_FORM_ref1
|
|
2, // 0x12 DW_FORM_ref2
|
|
4, // 0x13 DW_FORM_ref4
|
|
8, // 0x14 DW_FORM_ref8
|
|
0, // 0x15 DW_FORM_ref_udata
|
|
0, // 0x16 DW_FORM_indirect
|
|
};
|
|
|
|
static uint8_t
|
|
g_form_sizes_addr8[] =
|
|
{
|
|
0, // 0x00 unused
|
|
8, // 0x01 DW_FORM_addr
|
|
0, // 0x02 unused
|
|
0, // 0x03 DW_FORM_block2
|
|
0, // 0x04 DW_FORM_block4
|
|
2, // 0x05 DW_FORM_data2
|
|
4, // 0x06 DW_FORM_data4
|
|
8, // 0x07 DW_FORM_data8
|
|
0, // 0x08 DW_FORM_string
|
|
0, // 0x09 DW_FORM_block
|
|
0, // 0x0a DW_FORM_block1
|
|
1, // 0x0b DW_FORM_data1
|
|
1, // 0x0c DW_FORM_flag
|
|
0, // 0x0d DW_FORM_sdata
|
|
4, // 0x0e DW_FORM_strp
|
|
0, // 0x0f DW_FORM_udata
|
|
8, // 0x10 DW_FORM_ref_addr
|
|
1, // 0x11 DW_FORM_ref1
|
|
2, // 0x12 DW_FORM_ref2
|
|
4, // 0x13 DW_FORM_ref4
|
|
8, // 0x14 DW_FORM_ref8
|
|
0, // 0x15 DW_FORM_ref_udata
|
|
0, // 0x16 DW_FORM_indirect
|
|
};
|
|
|
|
const uint8_t *
|
|
DWARFFormValue::GetFixedFormSizesForAddressSize (uint8_t addr_size)
|
|
{
|
|
switch (addr_size)
|
|
{
|
|
case 4: return g_form_sizes_addr4;
|
|
case 8: return g_form_sizes_addr8;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
DWARFFormValue::DWARFFormValue(dw_form_t form) :
|
|
m_form(form),
|
|
m_value()
|
|
{
|
|
}
|
|
|
|
bool
|
|
DWARFFormValue::ExtractValue(const DataExtractor& data, uint32_t* offset_ptr, const DWARFCompileUnit* cu)
|
|
{
|
|
bool indirect = false;
|
|
bool is_block = false;
|
|
m_value.data = NULL;
|
|
// Read the value for the form into value and follow and DW_FORM_indirect instances we run into
|
|
do
|
|
{
|
|
indirect = false;
|
|
switch (m_form)
|
|
{
|
|
case DW_FORM_addr: m_value.value.uval = data.GetMaxU64(offset_ptr, DWARFCompileUnit::GetAddressByteSize(cu)); break;
|
|
case DW_FORM_block2: m_value.value.uval = data.GetU16(offset_ptr); is_block = true; break;
|
|
case DW_FORM_block4: m_value.value.uval = data.GetU32(offset_ptr); is_block = true; break;
|
|
case DW_FORM_data2: m_value.value.uval = data.GetU16(offset_ptr); break;
|
|
case DW_FORM_data4: m_value.value.uval = data.GetU32(offset_ptr); break;
|
|
case DW_FORM_data8: m_value.value.uval = data.GetU64(offset_ptr); break;
|
|
case DW_FORM_string: m_value.value.cstr = data.GetCStr(offset_ptr);
|
|
// Set the string value to also be the data for inlined cstr form values only
|
|
// so we can tell the differnence between DW_FORM_string and DW_FORM_strp form
|
|
// values;
|
|
m_value.data = (uint8_t*)m_value.value.cstr; break;
|
|
case DW_FORM_block: m_value.value.uval = data.GetULEB128(offset_ptr); is_block = true; break;
|
|
case DW_FORM_block1: m_value.value.uval = data.GetU8(offset_ptr); is_block = true; break;
|
|
case DW_FORM_data1: m_value.value.uval = data.GetU8(offset_ptr); break;
|
|
case DW_FORM_flag: m_value.value.uval = data.GetU8(offset_ptr); break;
|
|
case DW_FORM_sdata: m_value.value.sval = data.GetSLEB128(offset_ptr); break;
|
|
case DW_FORM_strp: m_value.value.uval = data.GetU32(offset_ptr); break;
|
|
// case DW_FORM_APPLE_db_str:
|
|
case DW_FORM_udata: m_value.value.uval = data.GetULEB128(offset_ptr); break;
|
|
case DW_FORM_ref_addr: m_value.value.uval = data.GetMaxU64(offset_ptr, DWARFCompileUnit::GetAddressByteSize(cu)); break;
|
|
case DW_FORM_ref1: m_value.value.uval = data.GetU8(offset_ptr); break;
|
|
case DW_FORM_ref2: m_value.value.uval = data.GetU16(offset_ptr); break;
|
|
case DW_FORM_ref4: m_value.value.uval = data.GetU32(offset_ptr); break;
|
|
case DW_FORM_ref8: m_value.value.uval = data.GetU64(offset_ptr); break;
|
|
case DW_FORM_ref_udata: m_value.value.uval = data.GetULEB128(offset_ptr); break;
|
|
case DW_FORM_indirect:
|
|
m_form = data.GetULEB128(offset_ptr);
|
|
indirect = true;
|
|
break;
|
|
|
|
default:
|
|
return false;
|
|
break;
|
|
}
|
|
} while (indirect);
|
|
|
|
if (is_block)
|
|
{
|
|
m_value.data = data.PeekData(*offset_ptr, m_value.value.uval);
|
|
if (m_value.data != NULL)
|
|
{
|
|
*offset_ptr += m_value.value.uval;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool
|
|
DWARFFormValue::SkipValue(const DataExtractor& debug_info_data, uint32_t* offset_ptr, const DWARFCompileUnit* cu) const
|
|
{
|
|
return DWARFFormValue::SkipValue(m_form, debug_info_data, offset_ptr, cu);
|
|
}
|
|
|
|
bool
|
|
DWARFFormValue::SkipValue(dw_form_t form, const DataExtractor& debug_info_data, uint32_t* offset_ptr, const DWARFCompileUnit* cu)
|
|
{
|
|
bool indirect = false;
|
|
do
|
|
{
|
|
indirect = false;
|
|
switch (form)
|
|
{
|
|
// Blocks if inlined data that have a length field and the data bytes
|
|
// inlined in the .debug_info
|
|
case DW_FORM_block : { dw_uleb128_t size = debug_info_data.GetULEB128(offset_ptr); *offset_ptr += size; } return true;
|
|
case DW_FORM_block1 : { dw_uleb128_t size = debug_info_data.GetU8(offset_ptr); *offset_ptr += size; } return true;
|
|
case DW_FORM_block2 : { dw_uleb128_t size = debug_info_data.GetU16(offset_ptr); *offset_ptr += size; } return true;
|
|
case DW_FORM_block4 : { dw_uleb128_t size = debug_info_data.GetU32(offset_ptr); *offset_ptr += size; } return true;
|
|
|
|
// Inlined NULL terminated C-strings
|
|
case DW_FORM_string :
|
|
debug_info_data.GetCStr(offset_ptr);
|
|
return true;
|
|
|
|
// Compile unit address sized values
|
|
case DW_FORM_addr :
|
|
case DW_FORM_ref_addr :
|
|
*offset_ptr += DWARFCompileUnit::GetAddressByteSize(cu);
|
|
return true;
|
|
|
|
// 1 byte values
|
|
case DW_FORM_data1 :
|
|
case DW_FORM_flag :
|
|
case DW_FORM_ref1 :
|
|
*offset_ptr += 1;
|
|
return true;
|
|
|
|
// 2 byte values
|
|
case DW_FORM_data2 :
|
|
case DW_FORM_ref2 :
|
|
*offset_ptr += 2;
|
|
return true;
|
|
|
|
// 4 byte values
|
|
case DW_FORM_strp :
|
|
case DW_FORM_data4 :
|
|
case DW_FORM_ref4 :
|
|
*offset_ptr += 4;
|
|
return true;
|
|
|
|
// 8 byte values
|
|
case DW_FORM_data8 :
|
|
case DW_FORM_ref8 :
|
|
*offset_ptr += 8;
|
|
return true;
|
|
|
|
// signed or unsigned LEB 128 values
|
|
// case DW_FORM_APPLE_db_str:
|
|
case DW_FORM_sdata :
|
|
case DW_FORM_udata :
|
|
case DW_FORM_ref_udata :
|
|
debug_info_data.Skip_LEB128(offset_ptr);
|
|
return true;
|
|
|
|
case DW_FORM_indirect :
|
|
indirect = true;
|
|
form = debug_info_data.GetULEB128(offset_ptr);
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
} while (indirect);
|
|
return true;
|
|
}
|
|
|
|
//bool
|
|
//DWARFFormValue::PutUnsigned(dw_form_t form, dw_offset_t offset, uint64_t value, BinaryStreamBuf& out_buff, const DWARFCompileUnit* cu, bool fixup_cu_relative_refs)
|
|
//{
|
|
// assert(offset != DW_INVALID_OFFSET);
|
|
//// printf("PutUnsigned(%s, 0x%8.8x, 0x%16.16llx, %d)\n", DW_FORM_value_to_name(form), offset, value, fixup_cu_relative_refs);
|
|
// // Read the value for the form into value and follow and DW_FORM_indirect instances we run into
|
|
// switch (form)
|
|
// {
|
|
// case DW_FORM_addr: offset = out_buff.PutMax64(offset, value, DWARFCompileUnit::GetAddressByteSize(cu)); break;
|
|
//
|
|
// case DW_FORM_flag:
|
|
// case DW_FORM_data1: offset = out_buff.Put8(offset, value); break;
|
|
// case DW_FORM_data2: offset = out_buff.Put16(offset, value); break;
|
|
// case DW_FORM_data4: offset = out_buff.Put32(offset, value); break;
|
|
// case DW_FORM_data8: offset = out_buff.Put64(offset, value); break;
|
|
//// case DW_FORM_udata: offset = out_buff.Put32_as_ULEB128(offset, value); break;
|
|
//// case DW_FORM_sdata: offset = out_buff.Put32_as_SLEB128(offset, value); break;
|
|
// case DW_FORM_strp: offset = out_buff.Put32(offset, value); break;
|
|
//// case DW_FORM_APPLE_db_str:
|
|
//// offset = out_buff.Put32_as_ULEB128(offset, value); break;
|
|
//
|
|
// case DW_FORM_ref1:
|
|
// if (fixup_cu_relative_refs) value -= cu->GetOffset();
|
|
// offset = out_buff.Put8(offset, value);
|
|
// break;
|
|
// case DW_FORM_ref2:
|
|
// if (fixup_cu_relative_refs) value -= cu->GetOffset();
|
|
// offset = out_buff.Put16(offset, value);
|
|
// break;
|
|
// case DW_FORM_ref4:
|
|
// if (fixup_cu_relative_refs) value -= cu->GetOffset();
|
|
// offset = out_buff.Put32(offset, value);
|
|
// break;
|
|
// case DW_FORM_ref8:
|
|
// if (fixup_cu_relative_refs) value -= cu->GetOffset();
|
|
// offset = out_buff.Put64(offset, value);
|
|
// break;
|
|
//// case DW_FORM_ref_udata:
|
|
//// if (fixup_cu_relative_refs) value -= cu->GetOffset();
|
|
//// offset = out_buff.Put32_as_ULEB128(offset, value);
|
|
//// break;
|
|
// case DW_FORM_ref_addr:
|
|
// // TODO: Add support for DWARF3 if we ever start emitting DWARF3. The DW_FORM_ref_addr
|
|
// // is always the same size as an address prior to DWARF3, and with DWARF3 or later it
|
|
// // is 4 hard coded to bytes.
|
|
// offset = out_buff.PutMax64(offset, value, DWARFCompileUnit::GetAddressByteSize(cu));
|
|
// break;
|
|
//
|
|
// default:
|
|
// return false;
|
|
// }
|
|
//
|
|
// return true;
|
|
//}
|
|
|
|
//bool
|
|
//DWARFFormValue::TransferValue(dw_form_t form, const DataExtractor& data, uint32_t* offset_ptr, const DWARFCompileUnit* cu, BinaryStreamBuf& out_buff)
|
|
//{
|
|
// DWARFFormValue formValue(form);
|
|
// if (formValue.ExtractValue(data, offset_ptr,cu))
|
|
// return TransferValue(formValue, cu, out_buff);
|
|
// return false;
|
|
//}
|
|
|
|
//bool
|
|
//DWARFFormValue::TransferValue(const DWARFFormValue& formValue, const DWARFCompileUnit* cu, BinaryStreamBuf& out_buff)
|
|
//{
|
|
// // Read the value for the form into value and follow and DW_FORM_indirect instances we run into
|
|
// dw_form_t form = formValue.Form();
|
|
// switch (form)
|
|
// {
|
|
// case DW_FORM_addr:
|
|
// case DW_FORM_ref_addr:
|
|
// {
|
|
// uint8_t addr_size = DWARFCompileUnit::GetAddressByteSize(cu);
|
|
// out_buff.AppendMax64(formValue.Unsigned(), addr_size);
|
|
// }
|
|
// break;
|
|
//
|
|
// case DW_FORM_block: out_buff.Append32_as_ULEB128(formValue.Unsigned()); break;
|
|
// case DW_FORM_block1: out_buff.Append8(formValue.Unsigned()); break;
|
|
// case DW_FORM_block2: out_buff.Append16(formValue.Unsigned()); break;
|
|
// case DW_FORM_block4: out_buff.Append32(formValue.Unsigned()); break;
|
|
//
|
|
// case DW_FORM_flag:
|
|
// case DW_FORM_data1: out_buff.Append8(formValue.Unsigned()); break;
|
|
// case DW_FORM_data2: out_buff.Append16(formValue.Unsigned()); break;
|
|
// case DW_FORM_data4: out_buff.Append32(formValue.Unsigned()); break;
|
|
// case DW_FORM_data8: out_buff.Append64(formValue.Unsigned()); break;
|
|
// case DW_FORM_udata: out_buff.Append32_as_ULEB128(formValue.Unsigned()); break;
|
|
// case DW_FORM_sdata: out_buff.Append32_as_SLEB128(formValue.Signed()); break;
|
|
//
|
|
// case DW_FORM_string: out_buff.AppendCStr(formValue.m_value.value.cstr); break;
|
|
// case DW_FORM_strp: out_buff.Append32(formValue.Unsigned()); break;
|
|
//// case DW_FORM_APPLE_db_str:
|
|
//// out_buff.Append32_as_ULEB128(formValue.Unsigned()); break;
|
|
//
|
|
// case DW_FORM_ref1: out_buff.Append8(formValue.Unsigned()); break;
|
|
// case DW_FORM_ref2: out_buff.Append16(formValue.Unsigned()); break;
|
|
// case DW_FORM_ref4: out_buff.Append32(formValue.Unsigned()); break;
|
|
// case DW_FORM_ref8: out_buff.Append64(formValue.Unsigned()); break;
|
|
// case DW_FORM_ref_udata: out_buff.Append32_as_ULEB128(formValue.Unsigned()); break;
|
|
//
|
|
// case DW_FORM_indirect:
|
|
// assert(!"DW_FORM_indirect found in DWARFFormValue::TransferValue() for an extracted form...");
|
|
// break;
|
|
//
|
|
// default:
|
|
// Log::Error("DWARFFormValue::TransferValue() Unrecognized form: 0x%4.4x", form);
|
|
// return false;
|
|
// break;
|
|
// }
|
|
//
|
|
// const uint8_t* block_data = formValue.BlockData();
|
|
// if (block_data)
|
|
// out_buff.AppendData(block_data, formValue.Unsigned());
|
|
// return true;
|
|
//}
|
|
|
|
void
|
|
DWARFFormValue::Dump(Stream &s, const DataExtractor* debug_str_data, const DWARFCompileUnit* cu) const
|
|
{
|
|
uint64_t uvalue = Unsigned();
|
|
bool cu_relative_offset = false;
|
|
|
|
bool verbose = s.GetVerbose();
|
|
|
|
switch (m_form)
|
|
{
|
|
case DW_FORM_addr: s.Address(uvalue, sizeof (uint64_t)); break;
|
|
case DW_FORM_flag:
|
|
case DW_FORM_data1: s.PutHex8(uvalue); break;
|
|
case DW_FORM_data2: s.PutHex16(uvalue); break;
|
|
case DW_FORM_data4: s.PutHex32(uvalue); break;
|
|
case DW_FORM_data8: s.PutHex64(uvalue); break;
|
|
case DW_FORM_string: s.QuotedCString(AsCString(NULL)); break;
|
|
case DW_FORM_block:
|
|
case DW_FORM_block1:
|
|
case DW_FORM_block2:
|
|
case DW_FORM_block4:
|
|
if (uvalue > 0)
|
|
{
|
|
switch (m_form)
|
|
{
|
|
case DW_FORM_block: s.Printf("<0x%llx> ", uvalue); break;
|
|
case DW_FORM_block1: s.Printf("<0x%2.2x> ", (uint8_t)uvalue); break;
|
|
case DW_FORM_block2: s.Printf("<0x%4.4x> ", (uint16_t)uvalue); break;
|
|
case DW_FORM_block4: s.Printf("<0x%8.8x> ", (uint32_t)uvalue); break;
|
|
default: break;
|
|
}
|
|
|
|
const uint8_t* data_ptr = m_value.data;
|
|
if (data_ptr)
|
|
{
|
|
const uint8_t* end_data_ptr = data_ptr + uvalue; // uvalue contains size of block
|
|
while (data_ptr < end_data_ptr)
|
|
{
|
|
s.Printf("%2.2x ", *data_ptr);
|
|
++data_ptr;
|
|
}
|
|
}
|
|
else
|
|
s.PutCString("NULL");
|
|
}
|
|
break;
|
|
|
|
case DW_FORM_sdata: s.PutSLEB128(uvalue); break;
|
|
case DW_FORM_udata: s.PutULEB128(uvalue); break;
|
|
case DW_FORM_strp:
|
|
if (debug_str_data)
|
|
{
|
|
if (verbose)
|
|
s.Printf(" .debug_str[0x%8.8x] = ", (uint32_t)uvalue);
|
|
|
|
const char* dbg_str = AsCString(debug_str_data);
|
|
if (dbg_str)
|
|
s.QuotedCString(dbg_str);
|
|
}
|
|
else
|
|
{
|
|
s.PutHex32(uvalue);
|
|
}
|
|
break;
|
|
|
|
case DW_FORM_ref_addr:
|
|
{
|
|
s.Address(uvalue, sizeof (uint64_t) * 2);
|
|
break;
|
|
}
|
|
case DW_FORM_ref1: cu_relative_offset = true; if (verbose) s.Printf("cu + 0x%2.2x", (uint8_t)uvalue); break;
|
|
case DW_FORM_ref2: cu_relative_offset = true; if (verbose) s.Printf("cu + 0x%4.4x", (uint16_t)uvalue); break;
|
|
case DW_FORM_ref4: cu_relative_offset = true; if (verbose) s.Printf("cu + 0x%4.4x", (uint32_t)uvalue); break;
|
|
case DW_FORM_ref8: cu_relative_offset = true; if (verbose) s.Printf("cu + 0x%8.8llx", uvalue); break;
|
|
case DW_FORM_ref_udata: cu_relative_offset = true; if (verbose) s.Printf("cu + 0x%llx", uvalue); break;
|
|
|
|
// All DW_FORM_indirect attributes should be resolved prior to calling this function
|
|
case DW_FORM_indirect: s.PutCString("DW_FORM_indirect"); break;
|
|
default:
|
|
s.Printf("DW_FORM(0x%4.4x)", m_form);
|
|
break;
|
|
}
|
|
|
|
if (cu_relative_offset)
|
|
{
|
|
if (verbose)
|
|
s.PutCString(" => ");
|
|
|
|
s.Printf("{0x%8.8llx}", (uvalue + (cu ? cu->GetOffset() : 0)));
|
|
}
|
|
}
|
|
|
|
const char*
|
|
DWARFFormValue::AsCString(const DataExtractor* debug_str_data_ptr) const
|
|
{
|
|
if (IsInlinedCStr())
|
|
return m_value.value.cstr;
|
|
else if (debug_str_data_ptr)
|
|
return debug_str_data_ptr->PeekCStr(m_value.value.uval);
|
|
return NULL;
|
|
}
|
|
|
|
uint64_t
|
|
DWARFFormValue::Reference(const DWARFCompileUnit* cu) const
|
|
{
|
|
uint64_t die_offset = m_value.value.uval;
|
|
switch (m_form)
|
|
{
|
|
case DW_FORM_ref1:
|
|
case DW_FORM_ref2:
|
|
case DW_FORM_ref4:
|
|
case DW_FORM_ref8:
|
|
case DW_FORM_ref_udata:
|
|
die_offset += (cu ? cu->GetOffset() : 0);
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return die_offset;
|
|
}
|
|
|
|
uint64_t
|
|
DWARFFormValue::Reference (dw_offset_t base_offset) const
|
|
{
|
|
uint64_t die_offset = m_value.value.uval;
|
|
switch (m_form)
|
|
{
|
|
case DW_FORM_ref1:
|
|
case DW_FORM_ref2:
|
|
case DW_FORM_ref4:
|
|
case DW_FORM_ref8:
|
|
case DW_FORM_ref_udata:
|
|
die_offset += base_offset;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return die_offset;
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
// Resolve any compile unit specific references so that we don't need
|
|
// the compile unit at a later time in order to work with the form
|
|
// value.
|
|
//----------------------------------------------------------------------
|
|
bool
|
|
DWARFFormValue::ResolveCompileUnitReferences(const DWARFCompileUnit* cu)
|
|
{
|
|
switch (m_form)
|
|
{
|
|
case DW_FORM_ref1:
|
|
case DW_FORM_ref2:
|
|
case DW_FORM_ref4:
|
|
case DW_FORM_ref8:
|
|
case DW_FORM_ref_udata:
|
|
m_value.value.uval += cu->GetOffset();
|
|
m_form = DW_FORM_ref_addr;
|
|
return true;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
const uint8_t*
|
|
DWARFFormValue::BlockData() const
|
|
{
|
|
if (!IsInlinedCStr())
|
|
return m_value.data;
|
|
return NULL;
|
|
}
|
|
|
|
|
|
bool
|
|
DWARFFormValue::IsBlockForm(const dw_form_t form)
|
|
{
|
|
switch (form)
|
|
{
|
|
case DW_FORM_block:
|
|
case DW_FORM_block1:
|
|
case DW_FORM_block2:
|
|
case DW_FORM_block4:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool
|
|
DWARFFormValue::IsDataForm(const dw_form_t form)
|
|
{
|
|
switch (form)
|
|
{
|
|
case DW_FORM_sdata:
|
|
case DW_FORM_udata:
|
|
case DW_FORM_data1:
|
|
case DW_FORM_data2:
|
|
case DW_FORM_data4:
|
|
case DW_FORM_data8:
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
int
|
|
DWARFFormValue::Compare (const DWARFFormValue& a_value, const DWARFFormValue& b_value, const DWARFCompileUnit* a_cu, const DWARFCompileUnit* b_cu, const DataExtractor* debug_str_data_ptr)
|
|
{
|
|
dw_form_t a_form = a_value.Form();
|
|
dw_form_t b_form = b_value.Form();
|
|
if (a_form < b_form)
|
|
return -1;
|
|
if (a_form > b_form)
|
|
return 1;
|
|
switch (a_form)
|
|
{
|
|
case DW_FORM_addr:
|
|
case DW_FORM_flag:
|
|
case DW_FORM_data1:
|
|
case DW_FORM_data2:
|
|
case DW_FORM_data4:
|
|
case DW_FORM_data8:
|
|
case DW_FORM_udata:
|
|
case DW_FORM_ref_addr:
|
|
{
|
|
uint64_t a = a_value.Unsigned();
|
|
uint64_t b = b_value.Unsigned();
|
|
if (a < b)
|
|
return -1;
|
|
if (a > b)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
case DW_FORM_sdata:
|
|
{
|
|
int64_t a = a_value.Signed();
|
|
int64_t b = b_value.Signed();
|
|
if (a < b)
|
|
return -1;
|
|
if (a > b)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
case DW_FORM_string:
|
|
case DW_FORM_strp:
|
|
{
|
|
const char *a_string = a_value.AsCString(debug_str_data_ptr);
|
|
const char *b_string = b_value.AsCString(debug_str_data_ptr);
|
|
if (a_string == b_string)
|
|
return 0;
|
|
else if (a_string && b_string)
|
|
return strcmp(a_string, b_string);
|
|
else if (a_string == NULL)
|
|
return -1; // A string is NULL, and B is valid
|
|
else
|
|
return 1; // A string valid, and B is NULL
|
|
}
|
|
|
|
|
|
case DW_FORM_block:
|
|
case DW_FORM_block1:
|
|
case DW_FORM_block2:
|
|
case DW_FORM_block4:
|
|
{
|
|
uint64_t a_len = a_value.Unsigned();
|
|
uint64_t b_len = b_value.Unsigned();
|
|
if (a_len < b_len)
|
|
return -1;
|
|
if (a_len > b_len)
|
|
return 1;
|
|
// The block lengths are the same
|
|
return memcmp(a_value.BlockData(), b_value.BlockData(), a_value.Unsigned());
|
|
}
|
|
break;
|
|
|
|
case DW_FORM_ref1:
|
|
case DW_FORM_ref2:
|
|
case DW_FORM_ref4:
|
|
case DW_FORM_ref8:
|
|
case DW_FORM_ref_udata:
|
|
{
|
|
uint64_t a = a_value.Reference(a_cu);
|
|
uint64_t b = b_value.Reference(b_cu);
|
|
if (a < b)
|
|
return -1;
|
|
if (a > b)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
case DW_FORM_indirect:
|
|
assert(!"This shouldn't happen after the form has been extracted...");
|
|
break;
|
|
|
|
default:
|
|
assert(!"Unhandled DW_FORM");
|
|
break;
|
|
}
|
|
return -1;
|
|
}
|
|
|