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
21class DWARFUnit;
22
23namespace lldb_private {
24
25/// \class DWARFExpression DWARFExpression.h
26/// "lldb/Expression/DWARFExpression.h" Encapsulates a DWARF location
27/// expression and interprets it.
28///
29/// DWARF location expressions are used in two ways by LLDB. The first
30/// use is to find entities specified in the debug information, since their
31/// locations are specified in precisely this language. The second is to
32/// interpret expressions without having to run the target in cases where the
33/// overhead from copying JIT-compiled code into the target is too high or
34/// where the target cannot be run. This class encapsulates a single DWARF
35/// location expression or a location list and interprets it.
37public:
39
40 /// Constructor
41 ///
42 /// \param[in] data
43 /// A data extractor configured to read the DWARF location expression's
44 /// bytecode.
45 DWARFExpression(const DataExtractor &data);
46
47 /// Destructor
49
50 /// Return true if the location expression contains data
51 bool IsValid() const;
52
53 /// If a location is not a location list, return true if the location
54 /// contains a DW_OP_addr () opcode in the stream that matches \a file_addr.
55 /// If file_addr is LLDB_INVALID_ADDRESS, the this function will return true
56 /// if the variable there is any DW_OP_addr in a location that (yet still is
57 /// NOT a location list). This helps us detect if a variable is a global or
58 /// static variable since there is no other indication from DWARF debug
59 /// info.
60 ///
61 /// \param[in] dwarf_cu
62 /// The dwarf unit this expression belongs to.
63 ///
64 /// \param[in] op_addr_idx
65 /// The DW_OP_addr index to retrieve in case there is more than
66 /// one DW_OP_addr opcode in the location byte stream.
67 ///
68 /// \param[out] error
69 /// If the location stream contains unknown DW_OP opcodes or the
70 /// data is missing, \a error will be set to \b true.
71 ///
72 /// \return
73 /// LLDB_INVALID_ADDRESS if the location doesn't contain a
74 /// DW_OP_addr for \a op_addr_idx, otherwise a valid file address
76 uint32_t op_addr_idx, bool &error) const;
77
78 bool Update_DW_OP_addr(const DWARFUnit *dwarf_cu, lldb::addr_t file_addr);
79
80 void UpdateValue(uint64_t const_value, lldb::offset_t const_value_byte_size,
81 uint8_t addr_byte_size);
82
83 bool ContainsThreadLocalStorage(const DWARFUnit *dwarf_cu) const;
84
86 const DWARFUnit *dwarf_cu,
87 std::function<lldb::addr_t(lldb::addr_t file_addr)> const
88 &link_address_callback);
89
90 /// Return the call-frame-info style register kind
92
93 /// Set the call-frame-info style register kind
94 ///
95 /// \param[in] reg_kind
96 /// The register kind.
98
99 /// Evaluate a DWARF location expression in a particular context
100 ///
101 /// \param[in] exe_ctx
102 /// The execution context in which to evaluate the location
103 /// expression. The location expression may access the target's
104 /// memory, especially if it comes from the expression parser.
105 ///
106 /// \param[in] opcode_ctx
107 /// The module which defined the expression.
108 ///
109 /// \param[in] opcodes
110 /// This is a static method so the opcodes need to be provided
111 /// explicitly.
112 ///
113 /// \param[in] reg_ctx
114 /// An optional parameter which provides a RegisterContext for use
115 /// when evaluating the expression (i.e. for fetching register values).
116 /// Normally this will come from the ExecutionContext's StackFrame but
117 /// in the case where an expression needs to be evaluated while building
118 /// the stack frame list, this short-cut is available.
119 ///
120 /// \param[in] reg_set
121 /// The call-frame-info style register kind.
122 ///
123 /// \param[in] initial_value_ptr
124 /// A value to put on top of the interpreter stack before evaluating
125 /// the expression, if the expression is parametrized. Can be NULL.
126 ///
127 /// \param[in] result
128 /// A value into which the result of evaluating the expression is
129 /// to be placed.
130 ///
131 /// \param[in] error_ptr
132 /// If non-NULL, used to report errors in expression evaluation.
133 ///
134 /// \return
135 /// True on success; false otherwise. If error_ptr is non-NULL,
136 /// details of the failure are provided through it.
137 static bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx,
138 lldb::ModuleSP module_sp, const DataExtractor &opcodes,
139 const DWARFUnit *dwarf_cu,
140 const lldb::RegisterKind reg_set,
141 const Value *initial_value_ptr,
142 const Value *object_address_ptr, Value &result,
143 Status *error_ptr);
144
145 static bool ParseDWARFLocationList(const DWARFUnit *dwarf_cu,
146 const DataExtractor &data,
147 DWARFExpressionList *loc_list);
148
150 data = m_data;
151 return data.GetByteSize() > 0;
152 }
153
154 void DumpLocation(Stream *s, lldb::DescriptionLevel level, ABI *abi) const;
155
156 bool MatchesOperand(StackFrame &frame, const Instruction::Operand &op) const;
157
158private:
159 /// A data extractor capable of reading opcode bytes
161
162 /// One of the defines that starts with LLDB_REGKIND_
164};
165
166} // namespace lldb_private
167
168#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.
static bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx, lldb::ModuleSP module_sp, const DataExtractor &opcodes, const 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.
DataExtractor m_data
A data extractor capable of reading opcode bytes.
virtual ~DWARFExpression()
Destructor.
bool GetExpressionData(DataExtractor &data) const
void DumpLocation(Stream *s, lldb::DescriptionLevel level, ABI *abi) const
bool LinkThreadLocalStorage(const DWARFUnit *dwarf_cu, std::function< lldb::addr_t(lldb::addr_t file_addr)> const &link_address_callback)
lldb::addr_t GetLocation_DW_OP_addr(const DWARFUnit *dwarf_cu, uint32_t op_addr_idx, bool &error) const
If a location is not a location list, return true if the location contains a DW_OP_addr () opcode in ...
void UpdateValue(uint64_t const_value, lldb::offset_t const_value_byte_size, uint8_t addr_byte_size)
bool ContainsThreadLocalStorage(const DWARFUnit *dwarf_cu) const
lldb::RegisterKind m_reg_kind
One of the defines that starts with LLDB_REGKIND_.
bool Update_DW_OP_addr(const DWARFUnit *dwarf_cu, lldb::addr_t file_addr)
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.
static bool ParseDWARFLocationList(const DWARFUnit *dwarf_cu, const DataExtractor &data, DWARFExpressionList *loc_list)
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:41
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
RegisterKind
Register numbering types.
@ eRegisterKindDWARF
the register numbers seen DWARF