Magic-Mirror/llvm-capstone
1
0
Fork 0
mirror of https://github.com/capstone-engine/llvm-capstone.git synced 2025-01-09 01:29:52 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity

[DWARFExpression] Remove ctor that takes just a compile unit.

Browse Source 
Like many of our DWARF classes, the DWARFExpression can be initialized
in several ways. One such way was through a constructor that takes just
the compile unit. This constructor is used to initialize both empty
DWARFExpressions, and DWARFExpression that will be populated later.

To make the distinction more clear, I changed the constructor to a
default constructor and updated its call sites. Where the
DWARFExpression was being populated later, I replaced that with a call
to the copy assignment constructor.

Differential revision: https://reviews.llvm.org/D62425

llvm-svn: 361849
This commit is contained in:
Jonas Devlieghere 2019-05-28 17:34:05 +00:00
parent 24e80b8d04
commit 04a087ace7
8 changed files with 72 additions and 159 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

102
lldb/include/lldb/Expression/DWARFExpression.h
View File

@ -43,8 +43,7 @@ public:
// (.debug_loclists/.debug_loclists.dwo).
};
/// Constructor
explicit DWARFExpression(DWARFUnit *dwarf_cu);
DWARFExpression();
/// Constructor
///
@ -58,7 +57,7 @@ public:
/// \param[in] data_length
/// The byte length of the location expression.
DWARFExpression(lldb::ModuleSP module, const DataExtractor &data,
DWARFUnit *dwarf_cu, lldb::offset_t data_offset,
const DWARFUnit *dwarf_cu, lldb::offset_t data_offset,
lldb::offset_t data_length);
/// Destructor
@ -132,6 +131,9 @@ public:
bool Update_DW_OP_addr(lldb::addr_t file_addr);
void UpdateValue(uint64_t const_value, lldb::offset_t const_value_byte_size,
uint8_t addr_byte_size);
void SetModule(const lldb::ModuleSP &module) { m_module_wp = module; }
bool ContainsThreadLocalStorage() const;
@ -141,66 +143,6 @@ public:
std::function<lldb::addr_t(lldb::addr_t file_addr)> const
&link_address_callback);
/// Make the expression parser read its location information from a given
/// data source. Does not change the offset and length
///
/// \param[in] data
/// A data extractor configured to read the DWARF location expression's
/// bytecode.
void SetOpcodeData(const DataExtractor &data);
/// Make the expression parser read its location information from a given
/// data source
///
/// \param[in] module_sp
/// The module that defines the DWARF expression.
///
/// \param[in] data
/// A data extractor configured to read the DWARF location expression's
/// bytecode.
///
/// \param[in] data_offset
/// The offset of the location expression in the extractor.
///
/// \param[in] data_length
/// The byte length of the location expression.
void SetOpcodeData(lldb::ModuleSP module_sp, const DataExtractor &data,
lldb::offset_t data_offset, lldb::offset_t data_length);
/// Copy the DWARF location expression into a local buffer.
///
/// It is a good idea to copy the data so we don't keep the entire object
/// file worth of data around just for a few bytes of location expression.
/// LLDB typically will mmap the entire contents of debug information files,
/// and if we use SetOpcodeData, it will get a shared reference to all of
/// this data for the and cause the object file to have to stay around. Even
/// worse, a very very large ".a" that contains one or more .o files could
/// end up being referenced. Location lists are typically small so even
/// though we are copying the data, it shouldn't amount to that much for the
/// variables we end up parsing.
///
/// \param[in] module_sp
/// The module that defines the DWARF expression.
///
/// \param[in] data
/// A data extractor configured to read and copy the DWARF
/// location expression's bytecode.
///
/// \param[in] data_offset
/// The offset of the location expression in the extractor.
///
/// \param[in] data_length
/// The byte length of the location expression.
void CopyOpcodeData(lldb::ModuleSP module_sp, const DataExtractor &data,
lldb::offset_t data_offset, lldb::offset_t data_length);
void CopyOpcodeData(const void *data, lldb::offset_t data_length,
lldb::ByteOrder byte_order, uint8_t addr_byte_size);
void CopyOpcodeData(uint64_t const_value,
lldb::offset_t const_value_byte_size,
uint8_t addr_byte_size);
/// Tells the expression that it refers to a location list.
///
/// \param[in] slide
@ -294,7 +236,7 @@ public:
/// details of the failure are provided through it.
static bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
lldb::ModuleSP opcode_ctx, const DataExtractor &opcodes,
DWARFUnit *dwarf_cu, const lldb::offset_t offset,
const DWARFUnit *dwarf_cu, const lldb::offset_t offset,
const lldb::offset_t length,
const lldb::RegisterKind reg_set,
const Value *initial_value_ptr,
@ -324,7 +266,7 @@ public:
bool MatchesOperand(StackFrame &frame, const Instruction::Operand &op);
protected:
private:
/// Pretty-prints the location expression to a stream
///
/// \param[in] stream
@ -355,20 +297,24 @@ protected:
bool GetOpAndEndOffsets(StackFrame &frame, lldb::offset_t &op_offset,
lldb::offset_t &end_offset);
/// Classes that inherit from DWARFExpression can see and modify these
/// Module which defined this expression.
lldb::ModuleWP m_module_wp;
lldb::ModuleWP m_module_wp; ///< Module which defined this expression.
DataExtractor m_data; ///< A data extractor capable of reading opcode bytes
DWARFUnit *m_dwarf_cu; ///< The DWARF compile unit this expression
///belongs to. It is used
///< to evaluate values indexing into the .debug_addr section (e.g.
///< DW_OP_GNU_addr_index, DW_OP_GNU_const_index)
lldb::RegisterKind
m_reg_kind; ///< One of the defines that starts with LLDB_REGKIND_
lldb::addr_t m_loclist_slide; ///< A value used to slide the location list
///offsets so that
///< they are relative to the object that owns the location list
///< (the function for frame base and variable location lists)
/// A data extractor capable of reading opcode bytes
DataExtractor m_data;
/// The DWARF compile unit this expression belongs to. It is used to evaluate
/// values indexing into the .debug_addr section (e.g. DW_OP_GNU_addr_index,
/// DW_OP_GNU_const_index)
const DWARFUnit *m_dwarf_cu;
/// One of the defines that starts with LLDB_REGKIND_
lldb::RegisterKind m_reg_kind;
/// A value used to slide the location list offsets so that m_c they are
/// relative to the object that owns the location list (the function for
/// frame base and variable location lists)
lldb::addr_t m_loclist_slide;
};
} // namespace lldb_private

61
lldb/source/Expression/DWARFExpression.cpp
View File

@ -53,13 +53,13 @@ ReadAddressFromDebugAddrSection(const DWARFUnit *dwarf_cu,
}
// DWARFExpression constructor
DWARFExpression::DWARFExpression(DWARFUnit *dwarf_cu)
: m_module_wp(), m_data(), m_dwarf_cu(dwarf_cu),
DWARFExpression::DWARFExpression()
: m_module_wp(), m_data(), m_dwarf_cu(nullptr),
m_reg_kind(eRegisterKindDWARF), m_loclist_slide(LLDB_INVALID_ADDRESS) {}
DWARFExpression::DWARFExpression(lldb::ModuleSP module_sp,
const DataExtractor &data,
DWARFUnit *dwarf_cu,
const DWARFUnit *dwarf_cu,
lldb::offset_t data_offset,
lldb::offset_t data_length)
: m_module_wp(), m_data(data, data_offset, data_length),
@ -74,51 +74,16 @@ DWARFExpression::~DWARFExpression() {}
bool DWARFExpression::IsValid() const { return m_data.GetByteSize() > 0; }
void DWARFExpression::SetOpcodeData(const DataExtractor &data) {
m_data = data;
}
void DWARFExpression::UpdateValue(uint64_t const_value,
lldb::offset_t const_value_byte_size,
uint8_t addr_byte_size) {
if (!const_value_byte_size)
return;
void DWARFExpression::CopyOpcodeData(lldb::ModuleSP module_sp,
const DataExtractor &data,
lldb::offset_t data_offset,
lldb::offset_t data_length) {
const uint8_t *bytes = data.PeekData(data_offset, data_length);
if (bytes) {
m_module_wp = module_sp;
m_data.SetData(DataBufferSP(new DataBufferHeap(bytes, data_length)));
m_data.SetByteOrder(data.GetByteOrder());
m_data.SetAddressByteSize(data.GetAddressByteSize());
}
}
void DWARFExpression::CopyOpcodeData(const void *data,
lldb::offset_t data_length,
ByteOrder byte_order,
uint8_t addr_byte_size) {
if (data && data_length) {
m_data.SetData(DataBufferSP(new DataBufferHeap(data, data_length)));
m_data.SetByteOrder(byte_order);
m_data.SetAddressByteSize(addr_byte_size);
}
}
void DWARFExpression::CopyOpcodeData(uint64_t const_value,
lldb::offset_t const_value_byte_size,
uint8_t addr_byte_size) {
if (const_value_byte_size) {
m_data.SetData(
DataBufferSP(new DataBufferHeap(&const_value, const_value_byte_size)));
m_data.SetByteOrder(endian::InlHostByteOrder());
m_data.SetAddressByteSize(addr_byte_size);
}
}
void DWARFExpression::SetOpcodeData(lldb::ModuleSP module_sp,
const DataExtractor &data,
lldb::offset_t data_offset,
lldb::offset_t data_length) {
m_module_wp = module_sp;
m_data.SetData(data, data_offset, data_length);
m_data.SetData(
DataBufferSP(new DataBufferHeap(&const_value, const_value_byte_size)));
m_data.SetByteOrder(endian::InlHostByteOrder());
m_data.SetAddressByteSize(addr_byte_size);
}
void DWARFExpression::DumpLocation(Stream *s, lldb::offset_t offset,
@ -1191,7 +1156,7 @@ bool DWARFExpression::Evaluate(ExecutionContext *exe_ctx,
bool DWARFExpression::Evaluate(
ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
lldb::ModuleSP module_sp, const DataExtractor &opcodes,
DWARFUnit *dwarf_cu, const lldb::offset_t opcodes_offset,
const DWARFUnit *dwarf_cu, const lldb::offset_t opcodes_offset,
const lldb::offset_t opcodes_length, const lldb::RegisterKind reg_kind,
const Value *initial_value_ptr, const Value *object_address_ptr,
Value &result, Status *error_ptr) {

4
lldb/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp
View File

@ -2553,7 +2553,7 @@ Function *DWARFASTParserClang::ParseFunctionFromDWARF(CompileUnit &comp_unit,
int call_file = 0;
int call_line = 0;
int call_column = 0;
DWARFExpression frame_base(die.GetCU());
DWARFExpression frame_base;
const dw_tag_t tag = die.Tag();
@ -2692,7 +2692,6 @@ bool DWARFASTParserClang::ParseChildMembers(
const size_t num_attributes = die.GetAttributes(attributes);
if (num_attributes > 0) {
Declaration decl;
// DWARFExpression location;
const char *name = nullptr;
const char *prop_name = nullptr;
const char *prop_getter_name = nullptr;
@ -3172,7 +3171,6 @@ bool DWARFASTParserClang::ParseChildMembers(
const size_t num_attributes = die.GetAttributes(attributes);
if (num_attributes > 0) {
Declaration decl;
DWARFExpression location(die.GetCU());
DWARFFormValue encoding_form;
AccessType accessibility = default_accessibility;
bool is_virtual = false;

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

@ -504,8 +504,8 @@ bool DWARFDebugInfoEntry::GetDIENamesAndRanges(
uint32_t block_offset =
form_value.BlockData() - debug_info_data.GetDataStart();
uint32_t block_length = form_value.Unsigned();
frame_base->SetOpcodeData(module, debug_info_data, block_offset,
block_length);
*frame_base = DWARFExpression(module, debug_info_data, cu,
block_offset, block_length);
} else {
const DWARFDataExtractor &debug_loc_data =
dwarf2Data->DebugLocData();
@ -514,8 +514,9 @@ bool DWARFDebugInfoEntry::GetDIENamesAndRanges(
size_t loc_list_length = DWARFExpression::LocationListSize(
cu, debug_loc_data, debug_loc_offset);
if (loc_list_length > 0) {
frame_base->SetOpcodeData(module, debug_loc_data,
debug_loc_offset, loc_list_length);
*frame_base =
DWARFExpression(module, debug_loc_data, cu,
debug_loc_offset, loc_list_length);
if (lo_pc != LLDB_INVALID_ADDRESS) {
assert(lo_pc >= cu->GetBaseAddress());
frame_base->SetLocationListSlide(lo_pc -

35
lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp
View File

@ -3102,7 +3102,7 @@ VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
Declaration decl;
uint32_t i;
DWARFFormValue type_die_form;
DWARFExpression location(die.GetCU());
DWARFExpression location;
bool is_external = false;
bool is_artificial = false;
bool location_is_const_value_data = false;
@ -3153,14 +3153,15 @@ VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
uint32_t block_offset =
form_value.BlockData() - debug_info_data.GetDataStart();
uint32_t block_length = form_value.Unsigned();
location.CopyOpcodeData(module, debug_info_data, block_offset,
block_length);
location = DWARFExpression(module, debug_info_data, die.GetCU(),
block_offset, block_length);
} else if (DWARFFormValue::IsDataForm(form_value.Form())) {
// Retrieve the value as a data expression.
uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
if (auto data_length = form_value.GetFixedSize())
location.CopyOpcodeData(module, debug_info_data, data_offset,
*data_length);
location =
DWARFExpression(module, debug_info_data, die.GetCU(),
data_offset, *data_length);
else {
const uint8_t *data_pointer = form_value.BlockData();
if (data_pointer) {
@ -3176,15 +3177,17 @@ VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
if (form_value.Form() == DW_FORM_strp) {
uint32_t data_offset = attributes.DIEOffsetAtIndex(i);
if (auto data_length = form_value.GetFixedSize())
location.CopyOpcodeData(module, debug_info_data,
data_offset, *data_length);
location =
DWARFExpression(module, debug_info_data, die.GetCU(),
data_offset, *data_length);
} else {
const char *str = form_value.AsCString();
uint32_t string_offset =
str - (const char *)debug_info_data.GetDataStart();
uint32_t string_length = strlen(str) + 1;
location.CopyOpcodeData(module, debug_info_data,
string_offset, string_length);
location =
DWARFExpression(module, debug_info_data, die.GetCU(),
string_offset, string_length);
}
}
}
@ -3198,7 +3201,8 @@ VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
uint32_t block_offset =
form_value.BlockData() - data.GetDataStart();
uint32_t block_length = form_value.Unsigned();
location.CopyOpcodeData(module, data, block_offset, block_length);
location = DWARFExpression(module, data, die.GetCU(),
block_offset, block_length);
} else {
const DWARFDataExtractor &debug_loc_data = DebugLocData();
const dw_offset_t debug_loc_offset = form_value.Unsigned();
@ -3206,8 +3210,8 @@ VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
size_t loc_list_length = DWARFExpression::LocationListSize(
die.GetCU(), debug_loc_data, debug_loc_offset);
if (loc_list_length > 0) {
location.CopyOpcodeData(module, debug_loc_data,
debug_loc_offset, loc_list_length);
location = DWARFExpression(module, debug_loc_data, die.GetCU(),
debug_loc_offset, loc_list_length);
assert(func_low_pc != LLDB_INVALID_ADDRESS);
location.SetLocationListSlide(
func_low_pc -
@ -3444,10 +3448,9 @@ VariableSP SymbolFileDWARF::ParseVariableDIE(const SymbolContext &sc,
new SymbolFileType(*this, GetUID(DIERef(type_die_form))));
if (const_value.Form() && type_sp && type_sp->GetType())
location.CopyOpcodeData(
const_value.Unsigned(),
type_sp->GetType()->GetByteSize().getValueOr(0),
die.GetCU()->GetAddressByteSize());
location.UpdateValue(const_value.Unsigned(),
type_sp->GetType()->GetByteSize().getValueOr(0),
die.GetCU()->GetAddressByteSize());
var_sp = std::make_shared<Variable>(
die.GetID(), name, mangled, type_sp, scope, symbol_context_scope,

4
lldb/source/Plugins/SymbolFile/NativePDB/DWARFLocationExpression.cpp
View File

@ -111,13 +111,13 @@ static DWARFExpression MakeLocationExpressionInternal(lldb::ModuleSP module,
uint32_t address_size = architecture.GetAddressByteSize();
uint32_t byte_size = architecture.GetDataByteSize();
if (byte_order == eByteOrderInvalid || address_size == 0)
return DWARFExpression(nullptr);
return DWARFExpression();
RegisterKind register_kind = eRegisterKindDWARF;
StreamBuffer<32> stream(Stream::eBinary, address_size, byte_order);
if (!writer(stream, register_kind))
return DWARFExpression(nullptr);
return DWARFExpression();
DataBufferSP buffer =
std::make_shared<DataBufferHeap>(stream.GetData(), stream.GetSize());

14
lldb/source/Plugins/SymbolFile/PDB/PDBLocationToDWARFExpression.cpp
View File

@ -69,7 +69,7 @@ DWARFExpression ConvertPDBLocationToDWARFExpression(
is_constant = true;
if (!module)
return DWARFExpression(nullptr);
return DWARFExpression();
const ArchSpec &architecture = module->GetArchitecture();
llvm::Triple::ArchType arch_type = architecture.GetMachine();
@ -77,7 +77,7 @@ DWARFExpression ConvertPDBLocationToDWARFExpression(
uint32_t address_size = architecture.GetAddressByteSize();
uint32_t byte_size = architecture.GetDataByteSize();
if (byte_order == eByteOrderInvalid || address_size == 0)
return DWARFExpression(nullptr);
return DWARFExpression();
RegisterKind register_kind = eRegisterKindDWARF;
StreamBuffer<32> stream(Stream::eBinary, address_size, byte_order);
@ -88,13 +88,13 @@ DWARFExpression ConvertPDBLocationToDWARFExpression(
SectionList *section_list = module->GetSectionList();
if (!section_list)
return DWARFExpression(nullptr);
return DWARFExpression();
uint32_t section_id = symbol.getAddressSection();
auto section = section_list->FindSectionByID(section_id);
if (!section)
return DWARFExpression(nullptr);
return DWARFExpression();
uint32_t offset = symbol.getAddressOffset();
stream.PutMaxHex64(section->GetFileAddress() + offset, address_size,
@ -129,7 +129,7 @@ DWARFExpression ConvertPDBLocationToDWARFExpression(
register_kind = eRegisterKindLLDB;
reg_num = GetLLDBRegisterNumber(arch_type, reg_id);
if (reg_num == LLDB_INVALID_REGNUM)
return DWARFExpression(nullptr);
return DWARFExpression();
}
if (reg_num > 31) {
@ -149,7 +149,7 @@ DWARFExpression ConvertPDBLocationToDWARFExpression(
register_kind = eRegisterKindLLDB;
uint32_t reg_num = GetLLDBRegisterNumber(arch_type, symbol.getRegisterId());
if (reg_num == LLDB_INVALID_REGNUM)
return DWARFExpression(nullptr);
return DWARFExpression();
if (reg_num > 31) {
stream.PutHex8(DW_OP_regx);
@ -168,7 +168,7 @@ DWARFExpression ConvertPDBLocationToDWARFExpression(
break;
}
default:
return DWARFExpression(nullptr);
return DWARFExpression();
}
DataBufferSP buffer =

2
lldb/source/Symbol/Function.cpp
View File

@ -184,7 +184,7 @@ Function::Function(CompileUnit *comp_unit, lldb::user_id_t func_uid,
const AddressRange &range)
: UserID(func_uid), m_comp_unit(comp_unit), m_type_uid(type_uid),
m_type(type), m_mangled(mangled), m_block(func_uid), m_range(range),
m_frame_base(nullptr), m_flags(), m_prologue_byte_size(0) {
m_frame_base(), m_flags(), m_prologue_byte_size(0) {
m_block.SetParentScope(this);
assert(comp_unit != nullptr);
}