| //===-- DWARFExpressionList.h -----------------------------------*- C++ -*-===// |
| // |
| // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
| // See https://llvm.org/LICENSE.txt for license information. |
| // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLDB_EXPRESSION_DWARFEXPRESSIONLIST_H |
| #define LLDB_EXPRESSION_DWARFEXPRESSIONLIST_H |
| |
| #include "lldb/Expression/DWARFExpression.h" |
| #include "lldb/Utility/RangeMap.h" |
| #include "lldb/lldb-private.h" |
| |
| class DWARFUnit; |
| |
| namespace lldb_private { |
| |
| /// \class DWARFExpressionList DWARFExpressionList.h |
| /// "lldb/Expression/DWARFExpressionList.h" Encapsulates a range map from file |
| /// address range to a single DWARF location expression. |
| class DWARFExpressionList { |
| public: |
| DWARFExpressionList() = default; |
| |
| DWARFExpressionList(lldb::ModuleSP module_sp, const DWARFUnit *dwarf_cu, |
| lldb::addr_t func_file_addr) |
| : m_module_wp(module_sp), m_dwarf_cu(dwarf_cu), |
| m_func_file_addr(func_file_addr) {} |
| |
| DWARFExpressionList(lldb::ModuleSP module_sp, DWARFExpression expr, |
| const DWARFUnit *dwarf_cu) |
| : m_module_wp(module_sp), m_dwarf_cu(dwarf_cu) { |
| AddExpression(0, LLDB_INVALID_ADDRESS, expr); |
| } |
| |
| /// Return true if the location expression contains data |
| bool IsValid() const { return !m_exprs.IsEmpty(); } |
| |
| void Clear() { m_exprs.Clear(); } |
| |
| // Return true if the location expression is always valid. |
| bool IsAlwaysValidSingleExpr() const; |
| |
| bool AddExpression(lldb::addr_t base, lldb::addr_t end, DWARFExpression expr); |
| |
| /// Get the expression data at the file address. |
| bool GetExpressionData(DataExtractor &data, |
| lldb::addr_t func_load_addr = LLDB_INVALID_ADDRESS, |
| lldb::addr_t file_addr = 0) const; |
| |
| /// Sort m_expressions. |
| void Sort() { m_exprs.Sort(); } |
| |
| void SetFuncFileAddress(lldb::addr_t func_file_addr) { |
| m_func_file_addr = func_file_addr; |
| } |
| |
| lldb::addr_t GetFuncFileAddress() { return m_func_file_addr; } |
| |
| const DWARFExpression *GetExpressionAtAddress(lldb::addr_t func_load_addr, |
| lldb::addr_t load_addr) const; |
| |
| const DWARFExpression *GetAlwaysValidExpr() const; |
| |
| DWARFExpression *GetMutableExpressionAtAddress( |
| lldb::addr_t func_load_addr = LLDB_INVALID_ADDRESS, |
| lldb::addr_t load_addr = 0); |
| |
| size_t GetSize() const { return m_exprs.GetSize(); } |
| |
| bool ContainsThreadLocalStorage() const; |
| |
| bool LinkThreadLocalStorage( |
| lldb::ModuleSP new_module_sp, |
| std::function<lldb::addr_t(lldb::addr_t file_addr)> const |
| &link_address_callback); |
| |
| bool MatchesOperand(StackFrame &frame, |
| const Instruction::Operand &operand) const; |
| |
| /// Dump locations that contains file_addr if it's valid. Otherwise. dump all |
| /// locations. |
| bool DumpLocations(Stream *s, lldb::DescriptionLevel level, |
| lldb::addr_t func_load_addr, lldb::addr_t file_addr, |
| ABI *abi) const; |
| |
| /// Dump all locaitons with each seperated by new line. |
| void GetDescription(Stream *s, lldb::DescriptionLevel level, ABI *abi) const; |
| |
| /// Search for a load address in the dwarf location list |
| /// |
| /// \param[in] func_load_addr |
| /// The actual address of the function containing this location list. |
| /// |
| /// \param[in] addr |
| /// The address to resolve. |
| /// |
| /// \return |
| /// True if IsLocationList() is true and the address was found; |
| /// false otherwise. |
| // bool |
| // LocationListContainsLoadAddress (Process* process, const Address &addr) |
| // const; |
| // |
| bool ContainsAddress(lldb::addr_t func_load_addr, lldb::addr_t addr) const; |
| |
| void SetModule(const lldb::ModuleSP &module) { m_module_wp = module; } |
| |
| bool Evaluate(ExecutionContext *exe_ctx, RegisterContext *reg_ctx, |
| lldb::addr_t func_load_addr, const Value *initial_value_ptr, |
| const Value *object_address_ptr, Value &result, |
| Status *error_ptr) const; |
| |
| private: |
| // RangeDataVector requires a comparator for DWARFExpression, but it doesn't |
| // make sense to do so. |
| struct DWARFExpressionCompare { |
| public: |
| bool operator()(const DWARFExpression &lhs, |
| const DWARFExpression &rhs) const { |
| return false; |
| } |
| }; |
| using ExprVec = RangeDataVector<lldb::addr_t, lldb::addr_t, DWARFExpression, |
| 0, DWARFExpressionCompare>; |
| using Entry = ExprVec::Entry; |
| |
| // File address range mapping to single dwarf expression. |
| ExprVec m_exprs; |
| |
| /// Module which defined this expression. |
| lldb::ModuleWP m_module_wp; |
| |
| /// 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 = nullptr; |
| |
| // Function base file address. |
| lldb::addr_t m_func_file_addr = LLDB_INVALID_ADDRESS; |
| |
| using const_iterator = ExprVec::Collection::const_iterator; |
| const_iterator begin() const { return m_exprs.begin(); } |
| const_iterator end() const { return m_exprs.end(); } |
| }; |
| } // namespace lldb_private |
| |
| #endif // LLDB_EXPRESSION_DWARFEXPRESSIONLIST_H |