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() {
- m_cu = nullptr;
+ m_unit = nullptr;
m_form = 0;
m_value = ValueTypeTag();
}
indirect = false;
switch (m_form) {
case DW_FORM_addr:
- assert(m_cu);
+ assert(m_unit);
m_value.value.uval =
- data.GetMaxU64(offset_ptr, DWARFUnit::GetAddressByteSize(m_cu));
+ data.GetMaxU64(offset_ptr, DWARFUnit::GetAddressByteSize(m_unit));
break;
case DW_FORM_block1:
m_value.value.uval = data.GetU8(offset_ptr);
m_value.value.uval = data.GetULEB128(offset_ptr);
break;
case DW_FORM_ref_addr:
- assert(m_cu);
- if (m_cu->GetVersion() <= 2)
- ref_addr_size = m_cu->GetAddressByteSize();
+ assert(m_unit);
+ if (m_unit->GetVersion() <= 2)
+ ref_addr_size = m_unit->GetAddressByteSize();
else
ref_addr_size = 4;
m_value.value.uval = data.GetMaxU64(offset_ptr, ref_addr_size);
bool DWARFFormValue::SkipValue(const DWARFDataExtractor &debug_info_data,
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,
const DWARFDataExtractor &debug_info_data,
lldb::offset_t *offset_ptr,
- const DWARFUnit *cu) {
+ const DWARFUnit *unit) {
uint8_t ref_addr_size;
switch (form) {
// Blocks if inlined data that have a length field and the data bytes inlined
// Compile unit address sized values
case DW_FORM_addr:
- *offset_ptr += DWARFUnit::GetAddressByteSize(cu);
+ *offset_ptr += DWARFUnit::GetAddressByteSize(unit);
return true;
case DW_FORM_ref_addr:
ref_addr_size = 4;
- assert(cu); // CU must be valid for DW_FORM_ref_addr objects or we will get
- // this wrong
- if (cu->GetVersion() <= 2)
- ref_addr_size = cu->GetAddressByteSize();
+ assert(unit); // Unit must be valid for DW_FORM_ref_addr objects or we will
+ // get this wrong
+ if (unit->GetVersion() <= 2)
+ ref_addr_size = unit->GetAddressByteSize();
else
ref_addr_size = 4;
*offset_ptr += ref_addr_size;
case DW_FORM_indirect: {
dw_form_t indirect_form = debug_info_data.GetULEB128(offset_ptr);
return DWARFFormValue::SkipValue(indirect_form, debug_info_data, offset_ptr,
- cu);
+ unit);
}
default:
void DWARFFormValue::Dump(Stream &s) const {
uint64_t uvalue = Unsigned();
- bool cu_relative_offset = false;
+ bool unit_relative_offset = false;
switch (m_form) {
case DW_FORM_addr:
} break;
case DW_FORM_ref_addr: {
- assert(m_cu); // CU must be valid for DW_FORM_ref_addr objects or we will
- // get this wrong
- if (m_cu->GetVersion() <= 2)
+ assert(m_unit); // Unit must be valid for DW_FORM_ref_addr objects or we
+ // will get this wrong
+ if (m_unit->GetVersion() <= 2)
s.Address(uvalue, sizeof(uint64_t) * 2);
else
s.Address(uvalue, 4 * 2); // 4 for DWARF32, 8 for DWARF64, but we don't
break;
}
case DW_FORM_ref1:
- cu_relative_offset = true;
+ unit_relative_offset = true;
break;
case DW_FORM_ref2:
- cu_relative_offset = true;
+ unit_relative_offset = true;
break;
case DW_FORM_ref4:
- cu_relative_offset = true;
+ unit_relative_offset = true;
break;
case DW_FORM_ref8:
- cu_relative_offset = true;
+ unit_relative_offset = true;
break;
case DW_FORM_ref_udata:
- cu_relative_offset = true;
+ unit_relative_offset = true;
break;
// All DW_FORM_indirect attributes should be resolved prior to calling this
break;
}
- if (cu_relative_offset) {
- assert(m_cu); // CU must be valid for DW_FORM_ref forms that are compile
- // unit relative or we will get this wrong
- s.Printf("{0x%8.8" PRIx64 "}", uvalue + m_cu->GetOffset());
+ if (unit_relative_offset) {
+ assert(m_unit); // Unit must be valid for DW_FORM_ref forms that are compile
+ // unit relative or we will get this wrong
+ s.Printf("{0x%8.8" PRIx64 "}", uvalue + m_unit->GetOffset());
}
}
const char *DWARFFormValue::AsCString() const {
- SymbolFileDWARF *symbol_file = m_cu->GetSymbolFileDWARF();
+ SymbolFileDWARF *symbol_file = m_unit->GetSymbolFileDWARF();
if (m_form == DW_FORM_string) {
return m_value.value.cstr;
uint32_t indexSize = 4;
lldb::offset_t offset =
- m_cu->GetStrOffsetsBase() + m_value.value.uval * indexSize;
+ m_unit->GetStrOffsetsBase() + m_value.value.uval * indexSize;
dw_offset_t strOffset =
symbol_file->get_debug_str_offsets_data().GetMaxU64(&offset, indexSize);
return symbol_file->get_debug_str_data().PeekCStr(strOffset);
}
dw_addr_t DWARFFormValue::Address() const {
- SymbolFileDWARF *symbol_file = m_cu->GetSymbolFileDWARF();
+ SymbolFileDWARF *symbol_file = m_unit->GetSymbolFileDWARF();
if (m_form == DW_FORM_addr)
return Unsigned();
- assert(m_cu);
+ assert(m_unit);
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_addrx3 || m_form == DW_FORM_addrx4);
if (!symbol_file)
return 0;
- uint32_t index_size = m_cu->GetAddressByteSize();
- dw_offset_t addr_base = m_cu->GetAddrBase();
+ uint32_t index_size = m_unit->GetAddressByteSize();
+ dw_offset_t addr_base = m_unit->GetAddrBase();
lldb::offset_t offset = addr_base + m_value.value.uval * index_size;
return symbol_file->get_debug_addr_data().GetMaxU64(&offset, index_size);
}
case DW_FORM_ref4:
case DW_FORM_ref8:
case DW_FORM_ref_udata:
- assert(m_cu); // CU must be valid for DW_FORM_ref forms that are compile
- // unit relative or we will get this wrong
- return value + m_cu->GetOffset();
+ assert(m_unit); // Unit must be valid for DW_FORM_ref forms that are compile
+ // unit relative or we will get this wrong
+ return value + m_unit->GetOffset();
case DW_FORM_ref_addr:
case DW_FORM_ref_sig8:
eValueTypeBlock
};
- DWARFFormValue();
- DWARFFormValue(const DWARFUnit *cu);
- DWARFFormValue(const DWARFUnit *cu, dw_form_t form);
- const DWARFUnit *GetCompileUnit() const { return m_cu; }
- void SetCompileUnit(const DWARFUnit *cu) { m_cu = cu; }
+ DWARFFormValue() = default;
+ DWARFFormValue(const DWARFUnit *unit) : m_unit(unit) {}
+ DWARFFormValue(const DWARFUnit *unit, dw_form_t form)
+ : m_unit(unit), m_form(form) {}
+ 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& FormRef() { return m_form; }
void SetForm(dw_form_t form) { m_form = form; }
lldb::offset_t *offset_ptr) const;
static bool SkipValue(const dw_form_t form,
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 IsDataForm(const dw_form_t form);
static FixedFormSizes GetFixedFormSizesForAddressSize(uint8_t addr_size);
static bool FormIsSupported(dw_form_t form);
protected:
- const DWARFUnit *m_cu; // Compile unit for this form
- dw_form_t m_form; // Form for this value
+ const DWARFUnit *m_unit = nullptr; // Unit for this form
+ dw_form_t m_form = 0; // Form for this value
ValueType m_value; // Contains all data for the form
};