LLDB mainline
DWARFExpression.h
Go to the documentation of this file.
1//===-- DWARFExpression.h ---------------------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#ifndef LLDB_EXPRESSION_DWARFEXPRESSION_H
10#define LLDB_EXPRESSION_DWARFEXPRESSION_H
11
12#include "lldb/Core/Address.h"
15#include "lldb/Utility/Scalar.h"
16#include "lldb/Utility/Status.h"
17#include "lldb/lldb-private.h"
18#include "llvm/DebugInfo/DWARF/DWARFLocationExpression.h"
19#include <functional>
20
21namespace lldb_private {
22
23namespace plugin {
24namespace dwarf {
25class DWARFUnit;
26} // namespace dwarf
27} // namespace plugin
28
29/// \class DWARFExpression DWARFExpression.h
30/// "lldb/Expression/DWARFExpression.h" Encapsulates a DWARF location
31/// expression and interprets it.
32///
33/// DWARF location expressions are used in two ways by LLDB. The first
34/// use is to find entities specified in the debug information, since their
35/// locations are specified in precisely this language. The second is to
36/// interpret expressions without having to run the target in cases where the
37/// overhead from copying JIT-compiled code into the target is too high or
38/// where the target cannot be run. This class encapsulates a single DWARF
39/// location expression or a location list and interprets it.
41public:
43
44 /// Constructor
45 ///
46 /// \param[in] data
47 /// A data extractor configured to read the DWARF location expression's
48 /// bytecode.
49 DWARFExpression(const DataExtractor &data);
50
51 /// Destructor
53
54 /// Return true if the location expression contains data
55 bool IsValid() const;
56
57 /// Return the address specified by the first
58 /// DW_OP_{addr, addrx, GNU_addr_index} in the operation stream.
59 ///
60 /// \param[in] dwarf_cu
61 /// The dwarf unit this expression belongs to. Only required to resolve
62 /// DW_OP{addrx, GNU_addr_index}.
63 ///
64 /// \param[out] error
65 /// If the location stream contains unknown DW_OP opcodes or the
66 /// data is missing, \a error will be set to \b true.
67 ///
68 /// \return
69 /// The address specified by the operation, if the operation exists, or
70 /// LLDB_INVALID_ADDRESS otherwise.
72 bool &error) const;
73
75 lldb::addr_t file_addr);
76
77 void UpdateValue(uint64_t const_value, lldb::offset_t const_value_byte_size,
78 uint8_t addr_byte_size);
79
80 bool
82
84 const plugin::dwarf::DWARFUnit *dwarf_cu,
85 std::function<lldb::addr_t(lldb::addr_t file_addr)> const
86 &link_address_callback);
87
88 /// Return the call-frame-info style register kind
90
91 /// Set the call-frame-info style register kind
92 ///
93 /// \param[in] reg_kind
94 /// The register kind.
96
97 /// Evaluate a DWARF location expression in a particular context
98 ///
99 /// \param[in] exe_ctx
100 /// The execution context in which to evaluate the location
101 /// expression. The location expression may access the target's
102 /// memory, especially if it comes from the expression parser.
103 ///
104 /// \param[in] opcode_ctx
105 /// The module which defined the expression.
106 ///
107 /// \param[in] opcodes
108 /// This is a static method so the opcodes need to be provided
109 /// explicitly.
110 ///
111 /// \param[in] reg_ctx
112 /// An optional parameter which provides a RegisterContext for use
113 /// when evaluating the expression (i.e. for fetching register values).
114 /// Normally this will come from the ExecutionContext's StackFrame but
115 /// in the case where an expression needs to be evaluated while building
116 /// the stack frame list, this short-cut is available.
117 ///
118 /// \param[in] reg_set
119 /// The call-frame-info style register kind.
120 ///
121 /// \param[in] initial_value_ptr
122 /// A value to put on top of the interpreter stack before evaluating
123 /// the expression, if the expression is parametrized. Can be NULL.
124 ///
125 /// \param[in] result
126 /// A value into which the result of evaluating the expression is
127 /// to be placed.
128 ///
129 /// \param[in] error_ptr
130 /// If non-NULL, used to report errors in expression evaluation.
131 ///
132 /// \return
133 /// True on success; false otherwise. If error_ptr is non-NULL,
134 /// details of the failure are provided through it.
135 static bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
136 lldb::ModuleSP module_sp, const DataExtractor &opcodes,
137 const plugin::dwarf::DWARFUnit *dwarf_cu,
138 const lldb::RegisterKind reg_set,
139 const Value *initial_value_ptr,
140 const Value *object_address_ptr, Value &result,
141 Status *error_ptr);
142
143 static bool ParseDWARFLocationList(const plugin::dwarf::DWARFUnit *dwarf_cu,
144 const DataExtractor &data,
145 DWARFExpressionList *loc_list);
146
148 data = m_data;
149 return data.GetByteSize() > 0;
150 }
151
152 void DumpLocation(Stream *s, lldb::DescriptionLevel level, ABI *abi) const;
153
154 bool MatchesOperand(StackFrame &frame, const Instruction::Operand &op) const;
155
156private:
157 /// A data extractor capable of reading opcode bytes
159
160 /// One of the defines that starts with LLDB_REGKIND_
162};
163
164} // namespace lldb_private
165
166#endif // LLDB_EXPRESSION_DWARFEXPRESSION_H
static llvm::raw_ostream & error(Stream &strm)
"lldb/Expression/DWARFExpressionList.h" Encapsulates a range map from file address range to a single ...
"lldb/Expression/DWARFExpression.h" Encapsulates a DWARF location expression and interprets it.
DataExtractor m_data
A data extractor capable of reading opcode bytes.
bool LinkThreadLocalStorage(const plugin::dwarf::DWARFUnit *dwarf_cu, std::function< lldb::addr_t(lldb::addr_t file_addr)> const &link_address_callback)
bool GetExpressionData(DataExtractor &data) const
void DumpLocation(Stream *s, lldb::DescriptionLevel level, ABI *abi) const
lldb::addr_t GetLocation_DW_OP_addr(const plugin::dwarf::DWARFUnit *dwarf_cu, bool &error) const
Return the address specified by the first DW_OP_{addr, addrx, GNU_addr_index} in the operation stream...
bool Update_DW_OP_addr(const plugin::dwarf::DWARFUnit *dwarf_cu, lldb::addr_t file_addr)
void UpdateValue(uint64_t const_value, lldb::offset_t const_value_byte_size, uint8_t addr_byte_size)
static bool ParseDWARFLocationList(const plugin::dwarf::DWARFUnit *dwarf_cu, const DataExtractor &data, DWARFExpressionList *loc_list)
bool ContainsThreadLocalStorage(const plugin::dwarf::DWARFUnit *dwarf_cu) const
lldb::RegisterKind m_reg_kind
One of the defines that starts with LLDB_REGKIND_.
static bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx, lldb::ModuleSP module_sp, const DataExtractor &opcodes, const plugin::dwarf::DWARFUnit *dwarf_cu, const lldb::RegisterKind reg_set, const Value *initial_value_ptr, const Value *object_address_ptr, Value &result, Status *error_ptr)
Evaluate a DWARF location expression in a particular context.
void SetRegisterKind(lldb::RegisterKind reg_kind)
Set the call-frame-info style register kind.
bool MatchesOperand(StackFrame &frame, const Instruction::Operand &op) const
lldb::RegisterKind GetRegisterKind() const
Return the call-frame-info style register kind.
bool IsValid() const
Return true if the location expression contains data.
An data extractor class.
Definition: DataExtractor.h:48
uint64_t GetByteSize() const
Get the number of bytes contained in this object.
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
This base class provides an interface to stack frames.
Definition: StackFrame.h:42
An error handling class.
Definition: Status.h:44
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
A class that represents a running process on the host machine.
Definition: SBAttachInfo.h:14
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
uint64_t offset_t
Definition: lldb-types.h:83
uint64_t addr_t
Definition: lldb-types.h:79
std::shared_ptr< lldb_private::Module > ModuleSP
Definition: lldb-forward.h:365
RegisterKind
Register numbering types.
@ eRegisterKindDWARF
the register numbers seen DWARF