[Lldb-commits] [lldb] 7cb8439 - [lldb] Add DWARFExpressionEntry and GetExpressionEntryAtAddress() to … (#144238)
via lldb-commits
lldb-commits at lists.llvm.org
Sat Jul 12 10:03:59 PDT 2025
Author: Abdullah Mohammad Amin
Date: 2025-07-12T10:03:54-07:00
New Revision: 7cb84392fd4abb2190c09045d25abc98571a1396
URL: https://github.com/llvm/llvm-project/commit/7cb84392fd4abb2190c09045d25abc98571a1396
DIFF: https://github.com/llvm/llvm-project/commit/7cb84392fd4abb2190c09045d25abc98571a1396.diff
LOG: [lldb] Add DWARFExpressionEntry and GetExpressionEntryAtAddress() to … (#144238)
This patch introduces a new struct and helper API in
`DWARFExpressionList` to expose
variable location metadata (base address, end address, and
DWARFExpression pointer) for
a given PC address. It will be used in later patches to annotate
disassembly instructions
with source-level variable locations.
## New struct
```
/// Represents one entry in a DWARFExpressionList, with its range and expr.
struct DWARFExpressionEntry {
lldb::addr_t base; // file‐address start of this location range
lldb::addr_t end; // file‐address end of this range (exclusive)
const DWARFExpression *expr; // the DWARF expression for this range
};
```
## New API
```
/// Retrieve the DWARFExpressionEntry covering a particular instruction.
///
/// \param func_load_addr
/// The load address of the start of the function containing this location list;
/// used to translate between file offsets and load addresses. If this is
/// LLDB_INVALID_ADDRESS, the stored CU base (m_func_file_addr) is used.
///
/// \param load_addr
/// The load address of the *current* PC (i.e., the instruction for which
/// we want its variable‐location entry). We first convert this back into
/// the function’s file‐address space to find the correct DWARF range.
///
/// \returns
/// On success, an entry whose `[base,end)` covers this PC; else an Error.
llvm::Expected<DWARFExpressionEntry>
GetExpressionEntryAtAddress(lldb::addr_t func_load_addr,
lldb::addr_t load_addr) const;
```
## Rationale
LLDB already provides:
```
const DWARFExpression *
GetExpressionAtAddress(lldb::addr_t func_load_addr,
lldb::addr_t load_addr) const;
```
However, this only returns the DWARF expression itself, without the
file‐address start (base) and end (end) of the location range. Those
bounds are crucial for:
1) Detecting range beginnings: render a var = <location> annotation
exactly when a variable’s live‐range starts.
2) Detecting range continuation: optionally display a “|” on subsequent
instructions in the same range.
3) Detecting state changes: know when a variable moves (e.g. from one
register to another), becomes a constant, or goes out of scope.
These primitives form the foundation for the Rich Disassembler feature
proposed for GSoC 25.
---------
Co-authored-by: Jonas Devlieghere <jonas at devlieghere.com>
Co-authored-by: Adrian Prantl <adrian.prantl at gmail.com>
Added:
Modified:
lldb/include/lldb/Expression/DWARFExpressionList.h
lldb/source/Expression/DWARFExpressionList.cpp
Removed:
################################################################################
diff --git a/lldb/include/lldb/Expression/DWARFExpressionList.h b/lldb/include/lldb/Expression/DWARFExpressionList.h
index d8f8ec247ed56..d303ad834b354 100644
--- a/lldb/include/lldb/Expression/DWARFExpressionList.h
+++ b/lldb/include/lldb/Expression/DWARFExpressionList.h
@@ -9,6 +9,7 @@
#ifndef LLDB_EXPRESSION_DWARFEXPRESSIONLIST_H
#define LLDB_EXPRESSION_DWARFEXPRESSIONLIST_H
+#include "lldb/Core/AddressRange.h"
#include "lldb/Core/Value.h"
#include "lldb/Expression/DWARFExpression.h"
#include "lldb/Utility/RangeMap.h"
@@ -59,6 +60,21 @@ class DWARFExpressionList {
lldb::addr_t GetFuncFileAddress() { return m_func_file_addr; }
+ /// Represents an entry in the DWARFExpressionList with all needed metadata.
+ struct DWARFExpressionEntry {
+ /// Represents a DWARF location range in the DWARF unit’s file‐address space
+ std::optional<AddressRange> file_range; ///< None = always-valid single expr
+ const DWARFExpression *expr;
+ };
+
+ /// Returns a DWARFExpressionEntry whose file_range contains the given
+ /// load‐address. `func_load_addr` is the load‐address of the function
+ /// start; `load_addr` is the full runtime PC. On success, `expr` is
+ /// non-null.
+ std::optional<DWARFExpressionEntry>
+ GetExpressionEntryAtAddress(lldb::addr_t func_load_addr,
+ lldb::addr_t load_addr) const;
+
const DWARFExpression *GetExpressionAtAddress(lldb::addr_t func_load_addr,
lldb::addr_t load_addr) const;
diff --git a/lldb/source/Expression/DWARFExpressionList.cpp b/lldb/source/Expression/DWARFExpressionList.cpp
index 04592a1eb7ff4..ef7333518f008 100644
--- a/lldb/source/Expression/DWARFExpressionList.cpp
+++ b/lldb/source/Expression/DWARFExpressionList.cpp
@@ -7,6 +7,7 @@
//===----------------------------------------------------------------------===//
#include "lldb/Expression/DWARFExpressionList.h"
+#include "lldb/Core/AddressRange.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Target/RegisterContext.h"
#include "lldb/Target/StackFrame.h"
@@ -20,7 +21,7 @@ bool DWARFExpressionList::IsAlwaysValidSingleExpr() const {
return GetAlwaysValidExpr() != nullptr;
}
-const DWARFExpression * DWARFExpressionList::GetAlwaysValidExpr() const {
+const DWARFExpression *DWARFExpressionList::GetAlwaysValidExpr() const {
if (m_exprs.GetSize() != 1)
return nullptr;
const auto *expr = m_exprs.GetEntryAtIndex(0);
@@ -53,6 +54,38 @@ bool DWARFExpressionList::ContainsAddress(lldb::addr_t func_load_addr,
return GetExpressionAtAddress(func_load_addr, addr) != nullptr;
}
+std::optional<DWARFExpressionList::DWARFExpressionEntry>
+DWARFExpressionList::GetExpressionEntryAtAddress(lldb::addr_t func_load_addr,
+ lldb::addr_t load_addr) const {
+ if (const DWARFExpression *always = GetAlwaysValidExpr()) {
+ return DWARFExpressionEntry{std::nullopt, always};
+ }
+
+ if (func_load_addr == LLDB_INVALID_ADDRESS)
+ func_load_addr = m_func_file_addr;
+
+ // Guard against underflow when translating a load address back into file
+ // space.
+ if (load_addr < func_load_addr)
+ return std::nullopt;
+
+ // Guard against overflow.
+ lldb::addr_t delta = load_addr - func_load_addr;
+ if (delta > std::numeric_limits<lldb::addr_t>::max() - m_func_file_addr)
+ return std::nullopt;
+
+ lldb::addr_t file_pc = (load_addr - func_load_addr) + m_func_file_addr;
+
+ if (const auto *entry = m_exprs.FindEntryThatContains(file_pc)) {
+ AddressRange range_in_file(entry->GetRangeBase(),
+ entry->GetRangeEnd() - entry->GetRangeBase());
+ return DWARFExpressionEntry{range_in_file, &entry->data};
+ }
+
+ // No entry covers this PC:
+ return std::nullopt;
+}
+
const DWARFExpression *
DWARFExpressionList::GetExpressionAtAddress(lldb::addr_t func_load_addr,
lldb::addr_t load_addr) const {
More information about the lldb-commits
mailing list