OSchip
/
llvm-project
mirror of https://github.com/THU-DSP-LAB/llvm-project.git
13
0
Fork 6
Code Issues Packages Projects Releases Wiki Activity

DWARF: s/CompileUnit/Unit/ in DWARFFormValue 

The class has been converted to use DWARFUnit, but a number of uses of
the words compile unit remained. This removes all such references
Get/SetCompileUnit becomes Get/SetUnit, and m_cu becomes m_unit.

llvm-svn: 360754
This commit is contained in:
Pavel Labath 2019-05-15 07:45:40 +00:00
parent 4c1d6ee83d
commit 041f40e5da
5 changed files with 51 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

9
lldb/source/Plugins/SymbolFile/DWARF/DIERef.cpp
View File

@ -16,12 +16,11 @@
DIERef::DIERef(const DWARFFormValue &form_value) DIERef::DIERef(const DWARFFormValue &form_value)
: cu_offset(DW_INVALID_OFFSET), die_offset(DW_INVALID_OFFSET) { : cu_offset(DW_INVALID_OFFSET), die_offset(DW_INVALID_OFFSET) {
if (form_value.IsValid()) { if (form_value.IsValid()) {
const DWARFUnit *dwarf_cu = form_value.GetCompileUnit(); if (const DWARFUnit *unit = form_value.GetUnit()) {
if (dwarf_cu) { if (unit->GetBaseObjOffset() != DW_INVALID_OFFSET)
if (dwarf_cu->GetBaseObjOffset() != DW_INVALID_OFFSET) cu_offset = unit->GetBaseObjOffset();
cu_offset = dwarf_cu->GetBaseObjOffset();
else else
cu_offset = dwarf_cu->GetOffset(); cu_offset = unit->GetOffset();
} }
die_offset = form_value.Reference(); die_offset = form_value.Reference();
} }

2
lldb/source/Plugins/SymbolFile/DWARF/DWARFAttribute.cpp
View File

@ -35,7 +35,7 @@ void DWARFAttributes::Append(const DWARFUnit *cu, dw_offset_t attr_die_offset,
bool DWARFAttributes::ExtractFormValueAtIndex( bool DWARFAttributes::ExtractFormValueAtIndex(
uint32_t i, DWARFFormValue &form_value) const { uint32_t i, DWARFFormValue &form_value) const {
const DWARFUnit *cu = CompileUnitAtIndex(i); const DWARFUnit *cu = CompileUnitAtIndex(i);
form_value.SetCompileUnit(cu); form_value.SetUnit(cu);
form_value.SetForm(FormAtIndex(i)); form_value.SetForm(FormAtIndex(i));
lldb::offset_t offset = DIEOffsetAtIndex(i); lldb::offset_t offset = DIEOffsetAtIndex(i);
return form_value.ExtractValue(cu->GetData(), &offset); return form_value.ExtractValue(cu->GetData(), &offset);

2
lldb/source/Plugins/SymbolFile/DWARF/DWARFDebugInfoEntry.cpp
View File

@ -833,7 +833,7 @@ dw_offset_t DWARFDebugInfoEntry::GetAttributeValue(
debug_info_data, &offset, cu); debug_info_data, &offset, cu);
const dw_offset_t attr_offset = offset; const dw_offset_t attr_offset = offset;
form_value.SetCompileUnit(cu); form_value.SetUnit(cu);
form_value.SetForm(abbrevDecl->GetFormByIndex(idx)); form_value.SetForm(abbrevDecl->GetFormByIndex(idx));
if (form_value.ExtractValue(debug_info_data, &offset)) { if (form_value.ExtractValue(debug_info_data, &offset)) {
if (end_attr_offset_ptr) if (end_attr_offset_ptr)

76
lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.cpp
View File

@ -104,16 +104,8 @@ DWARFFormValue::GetFixedFormSizesForAddressSize(uint8_t addr_size) {
return FixedFormSizes(); return FixedFormSizes();
} }
DWARFFormValue::DWARFFormValue() : m_cu(NULL), m_form(0), m_value() {}
DWARFFormValue::DWARFFormValue(const DWARFUnit *cu)
: m_cu(cu), m_form(0), m_value() {}
DWARFFormValue::DWARFFormValue(const DWARFUnit *cu, dw_form_t form)
: m_cu(cu), m_form(form), m_value() {}
void DWARFFormValue::Clear() { void DWARFFormValue::Clear() {
m_cu = nullptr; m_unit = nullptr;
m_form = 0; m_form = 0;
m_value = ValueTypeTag(); m_value = ValueTypeTag();
} }
@ -133,9 +125,9 @@ bool DWARFFormValue::ExtractValue(const DWARFDataExtractor &data,
indirect = false; indirect = false;
switch (m_form) { switch (m_form) {
case DW_FORM_addr: case DW_FORM_addr:
assert(m_cu); assert(m_unit);
m_value.value.uval = m_value.value.uval =
data.GetMaxU64(offset_ptr, DWARFUnit::GetAddressByteSize(m_cu)); data.GetMaxU64(offset_ptr, DWARFUnit::GetAddressByteSize(m_unit));
break; break;
case DW_FORM_block1: case DW_FORM_block1:
m_value.value.uval = data.GetU8(offset_ptr); m_value.value.uval = data.GetU8(offset_ptr);
@ -207,9 +199,9 @@ bool DWARFFormValue::ExtractValue(const DWARFDataExtractor &data,
m_value.value.uval = data.GetULEB128(offset_ptr); m_value.value.uval = data.GetULEB128(offset_ptr);
break; break;
case DW_FORM_ref_addr: case DW_FORM_ref_addr:
assert(m_cu); assert(m_unit);
if (m_cu->GetVersion() <= 2) if (m_unit->GetVersion() <= 2)
ref_addr_size = m_cu->GetAddressByteSize(); ref_addr_size = m_unit->GetAddressByteSize();
else else
ref_addr_size = 4; ref_addr_size = 4;
m_value.value.uval = data.GetMaxU64(offset_ptr, ref_addr_size); m_value.value.uval = data.GetMaxU64(offset_ptr, ref_addr_size);
@ -238,13 +230,13 @@ bool DWARFFormValue::ExtractValue(const DWARFDataExtractor &data,
bool DWARFFormValue::SkipValue(const DWARFDataExtractor &debug_info_data, bool DWARFFormValue::SkipValue(const DWARFDataExtractor &debug_info_data,
lldb::offset_t *offset_ptr) const { lldb::offset_t *offset_ptr) const {
return DWARFFormValue::SkipValue(m_form, debug_info_data, offset_ptr, m_cu); return DWARFFormValue::SkipValue(m_form, debug_info_data, offset_ptr, m_unit);
} }
bool DWARFFormValue::SkipValue(dw_form_t form, bool DWARFFormValue::SkipValue(dw_form_t form,
const DWARFDataExtractor &debug_info_data, const DWARFDataExtractor &debug_info_data,
lldb::offset_t *offset_ptr, lldb::offset_t *offset_ptr,
const DWARFUnit *cu) { const DWARFUnit *unit) {
uint8_t ref_addr_size; uint8_t ref_addr_size;
switch (form) { switch (form) {
// Blocks if inlined data that have a length field and the data bytes inlined // Blocks if inlined data that have a length field and the data bytes inlined
@ -278,15 +270,15 @@ bool DWARFFormValue::SkipValue(dw_form_t form,
// Compile unit address sized values // Compile unit address sized values
case DW_FORM_addr: case DW_FORM_addr:
*offset_ptr += DWARFUnit::GetAddressByteSize(cu); *offset_ptr += DWARFUnit::GetAddressByteSize(unit);
return true; return true;
case DW_FORM_ref_addr: case DW_FORM_ref_addr:
ref_addr_size = 4; ref_addr_size = 4;
assert(cu); // CU must be valid for DW_FORM_ref_addr objects or we will get assert(unit); // Unit must be valid for DW_FORM_ref_addr objects or we will
// this wrong // get this wrong
if (cu->GetVersion() <= 2) if (unit->GetVersion() <= 2)
ref_addr_size = cu->GetAddressByteSize(); ref_addr_size = unit->GetAddressByteSize();
else else
ref_addr_size = 4; ref_addr_size = 4;
*offset_ptr += ref_addr_size; *offset_ptr += ref_addr_size;
@ -356,7 +348,7 @@ bool DWARFFormValue::SkipValue(dw_form_t form,
case DW_FORM_indirect: { case DW_FORM_indirect: {
dw_form_t indirect_form = debug_info_data.GetULEB128(offset_ptr); dw_form_t indirect_form = debug_info_data.GetULEB128(offset_ptr);
return DWARFFormValue::SkipValue(indirect_form, debug_info_data, offset_ptr, return DWARFFormValue::SkipValue(indirect_form, debug_info_data, offset_ptr,
cu); unit);
} }
default: default:
@ -367,7 +359,7 @@ bool DWARFFormValue::SkipValue(dw_form_t form,
void DWARFFormValue::Dump(Stream &s) const { void DWARFFormValue::Dump(Stream &s) const {
uint64_t uvalue = Unsigned(); uint64_t uvalue = Unsigned();
bool cu_relative_offset = false; bool unit_relative_offset = false;
switch (m_form) { switch (m_form) {
case DW_FORM_addr: case DW_FORM_addr:
@ -444,9 +436,9 @@ void DWARFFormValue::Dump(Stream &s) const {
} break; } break;
case DW_FORM_ref_addr: { case DW_FORM_ref_addr: {
assert(m_cu); // CU must be valid for DW_FORM_ref_addr objects or we will assert(m_unit); // Unit must be valid for DW_FORM_ref_addr objects or we
// get this wrong // will get this wrong
if (m_cu->GetVersion() <= 2) if (m_unit->GetVersion() <= 2)
s.Address(uvalue, sizeof(uint64_t) * 2); s.Address(uvalue, sizeof(uint64_t) * 2);
else else
s.Address(uvalue, 4 * 2); // 4 for DWARF32, 8 for DWARF64, but we don't s.Address(uvalue, 4 * 2); // 4 for DWARF32, 8 for DWARF64, but we don't
@ -454,19 +446,19 @@ void DWARFFormValue::Dump(Stream &s) const {
break; break;
} }
case DW_FORM_ref1: case DW_FORM_ref1:
cu_relative_offset = true; unit_relative_offset = true;
break; break;
case DW_FORM_ref2: case DW_FORM_ref2:
cu_relative_offset = true; unit_relative_offset = true;
break; break;
case DW_FORM_ref4: case DW_FORM_ref4:
cu_relative_offset = true; unit_relative_offset = true;
break; break;
case DW_FORM_ref8: case DW_FORM_ref8:
cu_relative_offset = true; unit_relative_offset = true;
break; break;
case DW_FORM_ref_udata: case DW_FORM_ref_udata:
cu_relative_offset = true; unit_relative_offset = true;
break; break;
// All DW_FORM_indirect attributes should be resolved prior to calling this // All DW_FORM_indirect attributes should be resolved prior to calling this
@ -481,15 +473,15 @@ void DWARFFormValue::Dump(Stream &s) const {
break; break;
} }
if (cu_relative_offset) { if (unit_relative_offset) {
assert(m_cu); // CU must be valid for DW_FORM_ref forms that are compile assert(m_unit); // Unit must be valid for DW_FORM_ref forms that are compile
// unit relative or we will get this wrong // unit relative or we will get this wrong
s.Printf("{0x%8.8" PRIx64 "}", uvalue + m_cu->GetOffset()); s.Printf("{0x%8.8" PRIx64 "}", uvalue + m_unit->GetOffset());
} }
} }
const char *DWARFFormValue::AsCString() const { const char *DWARFFormValue::AsCString() const {
SymbolFileDWARF *symbol_file = m_cu->GetSymbolFileDWARF(); SymbolFileDWARF *symbol_file = m_unit->GetSymbolFileDWARF();
if (m_form == DW_FORM_string) { if (m_form == DW_FORM_string) {
return m_value.value.cstr; return m_value.value.cstr;
@ -520,7 +512,7 @@ const char *DWARFFormValue::AsCString() const {
uint32_t indexSize = 4; uint32_t indexSize = 4;
lldb::offset_t offset = lldb::offset_t offset =
m_cu->GetStrOffsetsBase() + m_value.value.uval * indexSize; m_unit->GetStrOffsetsBase() + m_value.value.uval * indexSize;
dw_offset_t strOffset = dw_offset_t strOffset =
symbol_file->get_debug_str_offsets_data().GetMaxU64(&offset, indexSize); symbol_file->get_debug_str_offsets_data().GetMaxU64(&offset, indexSize);
return symbol_file->get_debug_str_data().PeekCStr(strOffset); return symbol_file->get_debug_str_data().PeekCStr(strOffset);
@ -533,12 +525,12 @@ const char *DWARFFormValue::AsCString() const {
} }
dw_addr_t DWARFFormValue::Address() const { dw_addr_t DWARFFormValue::Address() const {
SymbolFileDWARF *symbol_file = m_cu->GetSymbolFileDWARF(); SymbolFileDWARF *symbol_file = m_unit->GetSymbolFileDWARF();
if (m_form == DW_FORM_addr) if (m_form == DW_FORM_addr)
return Unsigned(); return Unsigned();
assert(m_cu); assert(m_unit);
assert(m_form == DW_FORM_GNU_addr_index || m_form == DW_FORM_addrx || assert(m_form == DW_FORM_GNU_addr_index || m_form == DW_FORM_addrx ||
m_form == DW_FORM_addrx1 || m_form == DW_FORM_addrx2 || m_form == DW_FORM_addrx1 || m_form == DW_FORM_addrx2 ||
m_form == DW_FORM_addrx3 || m_form == DW_FORM_addrx4); m_form == DW_FORM_addrx3 || m_form == DW_FORM_addrx4);
@ -546,8 +538,8 @@ dw_addr_t DWARFFormValue::Address() const {
if (!symbol_file) if (!symbol_file)
return 0; return 0;
uint32_t index_size = m_cu->GetAddressByteSize(); uint32_t index_size = m_unit->GetAddressByteSize();
dw_offset_t addr_base = m_cu->GetAddrBase(); dw_offset_t addr_base = m_unit->GetAddrBase();
lldb::offset_t offset = addr_base + m_value.value.uval * index_size; lldb::offset_t offset = addr_base + m_value.value.uval * index_size;
return symbol_file->get_debug_addr_data().GetMaxU64(&offset, index_size); return symbol_file->get_debug_addr_data().GetMaxU64(&offset, index_size);
} }
@ -560,9 +552,9 @@ uint64_t DWARFFormValue::Reference() const {
case DW_FORM_ref4: case DW_FORM_ref4:
case DW_FORM_ref8: case DW_FORM_ref8:
case DW_FORM_ref_udata: case DW_FORM_ref_udata:
assert(m_cu); // CU must be valid for DW_FORM_ref forms that are compile assert(m_unit); // Unit must be valid for DW_FORM_ref forms that are compile
// unit relative or we will get this wrong // unit relative or we will get this wrong
return value + m_cu->GetOffset(); return value + m_unit->GetOffset();
case DW_FORM_ref_addr: case DW_FORM_ref_addr:
case DW_FORM_ref_sig8: case DW_FORM_ref_sig8:

17
lldb/source/Plugins/SymbolFile/DWARF/DWARFFormValue.h
View File

@ -54,11 +54,12 @@ public:
eValueTypeBlock eValueTypeBlock
}; };
DWARFFormValue(); DWARFFormValue() = default;
DWARFFormValue(const DWARFUnit *cu); DWARFFormValue(const DWARFUnit *unit) : m_unit(unit) {}
DWARFFormValue(const DWARFUnit *cu, dw_form_t form); DWARFFormValue(const DWARFUnit *unit, dw_form_t form)
const DWARFUnit *GetCompileUnit() const { return m_cu; } : m_unit(unit), m_form(form) {}
void SetCompileUnit(const DWARFUnit *cu) { m_cu = cu; } const DWARFUnit *GetUnit() const { return m_unit; }
void SetUnit(const DWARFUnit *unit) { m_unit = unit; }
dw_form_t Form() const { return m_form; } dw_form_t Form() const { return m_form; }
dw_form_t& FormRef() { return m_form; } dw_form_t& FormRef() { return m_form; }
void SetForm(dw_form_t form) { m_form = form; } void SetForm(dw_form_t form) { m_form = form; }
@ -84,7 +85,7 @@ public:
lldb::offset_t *offset_ptr) const; lldb::offset_t *offset_ptr) const;
static bool SkipValue(const dw_form_t form, static bool SkipValue(const dw_form_t form,
const lldb_private::DWARFDataExtractor &debug_info_data, const lldb_private::DWARFDataExtractor &debug_info_data,
lldb::offset_t *offset_ptr, const DWARFUnit *cu); lldb::offset_t *offset_ptr, const DWARFUnit *unit);
static bool IsBlockForm(const dw_form_t form); static bool IsBlockForm(const dw_form_t form);
static bool IsDataForm(const dw_form_t form); static bool IsDataForm(const dw_form_t form);
static FixedFormSizes GetFixedFormSizesForAddressSize(uint8_t addr_size); static FixedFormSizes GetFixedFormSizesForAddressSize(uint8_t addr_size);
@ -93,8 +94,8 @@ public:
static bool FormIsSupported(dw_form_t form); static bool FormIsSupported(dw_form_t form);
protected: protected:
const DWARFUnit *m_cu; // Compile unit for this form const DWARFUnit *m_unit = nullptr; // Unit for this form
dw_form_t m_form; // Form for this value dw_form_t m_form = 0; // Form for this value
ValueType m_value; // Contains all data for the form ValueType m_value; // Contains all data for the form
}; };