https://github.com/UltimateForce21 updated
https://github.com/llvm/llvm-project/pull/147460
>From 8ed8c540e7600d720a63bc2882a81a2c65c11d41 Mon Sep 17 00:00:00 2001
From: ultimateforce21 <abdullahmohammad...@gmail.com>
Date: Wed, 11 Jun 2025 00:11:09 -0400
Subject: [PATCH 01/20] [lldb] Add DWARFExpressionEntry and
GetExpressionEntryAtAddress() to DWARFExpressionList
This introduces a new API for retrieving DWARF expression metadata associated
with variable location entries at a given PC address. It provides the base,
end, and expression pointer for downstream consumers such as disassembler
annotations.
Intended for use in richer instruction annotations in Instruction::Dump().
---
.../lldb/Expression/DWARFExpressionList.h | 12 +++++++++++
.../source/Expression/DWARFExpressionList.cpp | 21 +++++++++++++++++++
2 files changed, 33 insertions(+)
diff --git a/lldb/include/lldb/Expression/DWARFExpressionList.h
b/lldb/include/lldb/Expression/DWARFExpressionList.h
index d8f8ec247ed56..a329b37393018 100644
--- a/lldb/include/lldb/Expression/DWARFExpressionList.h
+++ b/lldb/include/lldb/Expression/DWARFExpressionList.h
@@ -59,6 +59,18 @@ class DWARFExpressionList {
lldb::addr_t GetFuncFileAddress() { return m_func_file_addr; }
+ /// Represents an entry in the DWARFExpressionList with all needed metadata
+ struct DWARFExpressionEntry {
+ lldb::addr_t base;
+ lldb::addr_t end;
+ const DWARFExpression *expr;
+ };
+
+ /// Returns the entry (base, end, data) for a given PC address
+ llvm::Expected<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..b55bc7120c4af 100644
--- a/lldb/source/Expression/DWARFExpressionList.cpp
+++ b/lldb/source/Expression/DWARFExpressionList.cpp
@@ -53,6 +53,27 @@ bool DWARFExpressionList::ContainsAddress(lldb::addr_t
func_load_addr,
return GetExpressionAtAddress(func_load_addr, addr) != nullptr;
}
+llvm::Expected<DWARFExpressionList::DWARFExpressionEntry>
+DWARFExpressionList::GetExpressionEntryAtAddress(lldb::addr_t func_load_addr,
+ lldb::addr_t load_addr) const
{
+ if (const DWARFExpression *expr = GetAlwaysValidExpr()) {
+ return DWARFExpressionEntry{0, LLDB_INVALID_ADDRESS, expr};
+ }
+
+ if (func_load_addr == LLDB_INVALID_ADDRESS)
+ func_load_addr = m_func_file_addr;
+
+ addr_t addr = load_addr - func_load_addr + m_func_file_addr;
+ uint32_t index = m_exprs.FindEntryIndexThatContains(addr);
+ if (index == UINT32_MAX) {
+ return llvm::createStringError(llvm::inconvertibleErrorCode(),
+ "No DWARF expression found for address
0x%llx", addr);
+ }
+
+ const Entry &entry = *m_exprs.GetEntryAtIndex(index);
+ return DWARFExpressionEntry{entry.base, entry.GetRangeEnd(), &entry.data};
+}
+
const DWARFExpression *
DWARFExpressionList::GetExpressionAtAddress(lldb::addr_t func_load_addr,
lldb::addr_t load_addr) const {
>From 1db5002a69dba4f88aaac56d61520b7b4b214b01 Mon Sep 17 00:00:00 2001
From: Abdullah Mohammad Amin
<67847674+ultimateforc...@users.noreply.github.com>
Date: Thu, 19 Jun 2025 11:55:35 -0400
Subject: [PATCH 02/20] Update
lldb/include/lldb/Expression/DWARFExpressionList.h
Co-authored-by: Jonas Devlieghere <jo...@devlieghere.com>
---
lldb/include/lldb/Expression/DWARFExpressionList.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/lldb/include/lldb/Expression/DWARFExpressionList.h
b/lldb/include/lldb/Expression/DWARFExpressionList.h
index a329b37393018..89e55ffc07659 100644
--- a/lldb/include/lldb/Expression/DWARFExpressionList.h
+++ b/lldb/include/lldb/Expression/DWARFExpressionList.h
@@ -59,7 +59,7 @@ class DWARFExpressionList {
lldb::addr_t GetFuncFileAddress() { return m_func_file_addr; }
- /// Represents an entry in the DWARFExpressionList with all needed metadata
+ /// Represents an entry in the DWARFExpressionList with all needed metadata.
struct DWARFExpressionEntry {
lldb::addr_t base;
lldb::addr_t end;
>From a26010b06e5067b8b3b223cbd76e8848ecb9a289 Mon Sep 17 00:00:00 2001
From: Abdullah Mohammad Amin
<67847674+ultimateforc...@users.noreply.github.com>
Date: Thu, 19 Jun 2025 11:58:28 -0400
Subject: [PATCH 03/20] Update
lldb/include/lldb/Expression/DWARFExpressionList.h
Updated comment for GetExpressionEntryAtAddress to directly refer to struct
DWARFExpressionEntry
Co-authored-by: Jonas Devlieghere <jo...@devlieghere.com>
---
lldb/include/lldb/Expression/DWARFExpressionList.h | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/lldb/include/lldb/Expression/DWARFExpressionList.h
b/lldb/include/lldb/Expression/DWARFExpressionList.h
index 89e55ffc07659..f6a269809decc 100644
--- a/lldb/include/lldb/Expression/DWARFExpressionList.h
+++ b/lldb/include/lldb/Expression/DWARFExpressionList.h
@@ -66,7 +66,7 @@ class DWARFExpressionList {
const DWARFExpression *expr;
};
- /// Returns the entry (base, end, data) for a given PC address
+ /// Returns the DWARFExpressionEntry for a given PC address.
llvm::Expected<DWARFExpressionEntry>
GetExpressionEntryAtAddress(lldb::addr_t func_load_addr,
lldb::addr_t load_addr) const;
>From 72237b75a12daa94f887f7492b2dfc141519b8a8 Mon Sep 17 00:00:00 2001
From: Abdullah Mohammad Amin
<67847674+ultimateforc...@users.noreply.github.com>
Date: Thu, 19 Jun 2025 11:59:35 -0400
Subject: [PATCH 04/20] Update lldb/source/Expression/DWARFExpressionList.cpp
updating code style for function GetExpressionEntryAtAddress
Co-authored-by: Jonas Devlieghere <jo...@devlieghere.com>
---
lldb/source/Expression/DWARFExpressionList.cpp | 3 +--
1 file changed, 1 insertion(+), 2 deletions(-)
diff --git a/lldb/source/Expression/DWARFExpressionList.cpp
b/lldb/source/Expression/DWARFExpressionList.cpp
index b55bc7120c4af..ebf57dd457769 100644
--- a/lldb/source/Expression/DWARFExpressionList.cpp
+++ b/lldb/source/Expression/DWARFExpressionList.cpp
@@ -56,9 +56,8 @@ bool DWARFExpressionList::ContainsAddress(lldb::addr_t
func_load_addr,
llvm::Expected<DWARFExpressionList::DWARFExpressionEntry>
DWARFExpressionList::GetExpressionEntryAtAddress(lldb::addr_t func_load_addr,
lldb::addr_t load_addr) const
{
- if (const DWARFExpression *expr = GetAlwaysValidExpr()) {
+ if (const DWARFExpression *expr = GetAlwaysValidExpr())
return DWARFExpressionEntry{0, LLDB_INVALID_ADDRESS, expr};
- }
if (func_load_addr == LLDB_INVALID_ADDRESS)
func_load_addr = m_func_file_addr;
>From 94e4951ac8eb39f078b783c2d3a7006c395ae4b2 Mon Sep 17 00:00:00 2001
From: Abdullah Mohammad Amin
<67847674+ultimateforc...@users.noreply.github.com>
Date: Tue, 24 Jun 2025 16:28:14 -0400
Subject: [PATCH 05/20] Update DWARFExpressionList.h
Replace raw base/end with `AddressRange` in `DWARFExpressionEntry` and cleans
up helper comments to follow Doxygen convention.
Using `AddressRange` makes the intent clearer, avoids duplication of basic
`AddressRange` logic usage
---
lldb/include/lldb/Expression/DWARFExpressionList.h | 10 ++++++----
1 file changed, 6 insertions(+), 4 deletions(-)
diff --git a/lldb/include/lldb/Expression/DWARFExpressionList.h
b/lldb/include/lldb/Expression/DWARFExpressionList.h
index f6a269809decc..4af6f99b9c23a 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"
@@ -58,15 +59,16 @@ class DWARFExpressionList {
}
lldb::addr_t GetFuncFileAddress() { return m_func_file_addr; }
-
+
/// Represents an entry in the DWARFExpressionList with all needed metadata.
struct DWARFExpressionEntry {
- lldb::addr_t base;
- lldb::addr_t end;
+ AddressRange file_range; /// Represents a DWARF location range in the
DWARF unit’s file‐address space
const DWARFExpression *expr;
};
- /// Returns the DWARFExpressionEntry for a given PC address.
+ /// 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.
llvm::Expected<DWARFExpressionEntry>
GetExpressionEntryAtAddress(lldb::addr_t func_load_addr,
lldb::addr_t load_addr) const;
>From e8142dab5a1c90f05deb659a57059313c055b99d Mon Sep 17 00:00:00 2001
From: Abdullah Mohammad Amin
<67847674+ultimateforc...@users.noreply.github.com>
Date: Tue, 24 Jun 2025 16:36:41 -0400
Subject: [PATCH 06/20] Update DWARFExpressionList.cpp
Converts `GetExpressionEntryAtAddress` to return
`llvm::Expected<DWARFExpressionEntry>` using the updated
`DWARFExpressionEntry`. Updates the implementation to compute a single
`AddressRange file_range` for each DWARF location interval.
---
.../source/Expression/DWARFExpressionList.cpp | 26 +++++++++++--------
1 file changed, 15 insertions(+), 11 deletions(-)
diff --git a/lldb/source/Expression/DWARFExpressionList.cpp
b/lldb/source/Expression/DWARFExpressionList.cpp
index ebf57dd457769..8b8378eb895d3 100644
--- a/lldb/source/Expression/DWARFExpressionList.cpp
+++ b/lldb/source/Expression/DWARFExpressionList.cpp
@@ -6,6 +6,7 @@
//
//===----------------------------------------------------------------------===//
+#include "lldb/Core/AddressRange.h"
#include "lldb/Expression/DWARFExpressionList.h"
#include "lldb/Symbol/Function.h"
#include "lldb/Target/RegisterContext.h"
@@ -55,22 +56,25 @@ bool DWARFExpressionList::ContainsAddress(lldb::addr_t
func_load_addr,
llvm::Expected<DWARFExpressionList::DWARFExpressionEntry>
DWARFExpressionList::GetExpressionEntryAtAddress(lldb::addr_t func_load_addr,
- lldb::addr_t load_addr) const
{
- if (const DWARFExpression *expr = GetAlwaysValidExpr())
- return DWARFExpressionEntry{0, LLDB_INVALID_ADDRESS, expr};
+ lldb::addr_t load_addr) const {
+ if (const DWARFExpression *always = GetAlwaysValidExpr()) {
+ AddressRange full_range(m_func_file_addr, /*size=*/LLDB_INVALID_ADDRESS);
+ return DWARFExpressionEntry{full_range, always};
+ }
if (func_load_addr == LLDB_INVALID_ADDRESS)
func_load_addr = m_func_file_addr;
+ lldb::addr_t file_pc = load_addr - func_load_addr + m_func_file_addr;
- addr_t addr = load_addr - func_load_addr + m_func_file_addr;
- uint32_t index = m_exprs.FindEntryIndexThatContains(addr);
- if (index == UINT32_MAX) {
- return llvm::createStringError(llvm::inconvertibleErrorCode(),
- "No DWARF expression found for address
0x%llx", addr);
- }
+ uint32_t idx = m_exprs.FindEntryIndexThatContains(file_pc);
+ if (idx == UINT32_MAX)
+ return llvm::createStringError(
+ llvm::inconvertibleErrorCode(),
+ "no DWARF location list entry for PC 0x%" PRIx64, load_addr);
- const Entry &entry = *m_exprs.GetEntryAtIndex(index);
- return DWARFExpressionEntry{entry.base, entry.GetRangeEnd(), &entry.data};
+ const auto &entry = *m_exprs.GetEntryAtIndex(idx);
+ AddressRange range_in_file(entry.base, entry.GetRangeEnd() - entry.base);
+ return DWARFExpressionEntry{range_in_file, &entry.data};
}
const DWARFExpression *
>From 7e8741edfefa6989d06b4e50e11dfd4a47d57d28 Mon Sep 17 00:00:00 2001
From: Abdullah Mohammad Amin
<67847674+ultimateforc...@users.noreply.github.com>
Date: Sat, 28 Jun 2025 12:59:08 -0400
Subject: [PATCH 07/20] Update DWARFExpressionList.h
Updated commenting style for struct DWARFExpressionEntry
---
lldb/include/lldb/Expression/DWARFExpressionList.h | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/lldb/include/lldb/Expression/DWARFExpressionList.h
b/lldb/include/lldb/Expression/DWARFExpressionList.h
index 4af6f99b9c23a..31b852eb1ec80 100644
--- a/lldb/include/lldb/Expression/DWARFExpressionList.h
+++ b/lldb/include/lldb/Expression/DWARFExpressionList.h
@@ -62,7 +62,8 @@ class DWARFExpressionList {
/// Represents an entry in the DWARFExpressionList with all needed metadata.
struct DWARFExpressionEntry {
- AddressRange file_range; /// Represents a DWARF location range in the
DWARF unit’s file‐address space
+ /// Represents a DWARF location range in the DWARF unit’s file‐address
space
+ AddressRange file_range;
const DWARFExpression *expr;
};
>From c4cd77fa3605b3f1653b3987ed0a65b4c264f655 Mon Sep 17 00:00:00 2001
From: Abdullah Mohammad Amin
<67847674+ultimateforc...@users.noreply.github.com>
Date: Sat, 28 Jun 2025 13:24:57 -0400
Subject: [PATCH 08/20] Update DWARFExpressionList.cpp
Updated function `llvm::Expected<DWARFExpressionList::DWARFExpressionEntry>
DWARFExpressionList::GetExpressionEntryAtAddress` to use
`FindEntryThatContains` instead of `FindEntryIndexThatContains`
---
lldb/source/Expression/DWARFExpressionList.cpp | 18 ++++++++++--------
1 file changed, 10 insertions(+), 8 deletions(-)
diff --git a/lldb/source/Expression/DWARFExpressionList.cpp
b/lldb/source/Expression/DWARFExpressionList.cpp
index 8b8378eb895d3..9a6cccf445028 100644
--- a/lldb/source/Expression/DWARFExpressionList.cpp
+++ b/lldb/source/Expression/DWARFExpressionList.cpp
@@ -64,17 +64,19 @@
DWARFExpressionList::GetExpressionEntryAtAddress(lldb::addr_t func_load_addr,
if (func_load_addr == LLDB_INVALID_ADDRESS)
func_load_addr = m_func_file_addr;
+
+ // translate to file-relative PC
lldb::addr_t file_pc = load_addr - func_load_addr + m_func_file_addr;
- uint32_t idx = m_exprs.FindEntryIndexThatContains(file_pc);
- if (idx == UINT32_MAX)
- return llvm::createStringError(
- llvm::inconvertibleErrorCode(),
- "no DWARF location list entry for PC 0x%" PRIx64, load_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};
+ }
- const auto &entry = *m_exprs.GetEntryAtIndex(idx);
- AddressRange range_in_file(entry.base, entry.GetRangeEnd() - entry.base);
- return DWARFExpressionEntry{range_in_file, &entry.data};
+ return llvm::createStringError(
+ llvm::inconvertibleErrorCode(),
+ "no DWARF location list entry for PC 0x%" PRIx64, load_addr);
}
const DWARFExpression *
>From 62c02a9f1afd2018e0bd11541bf001047e4f7917 Mon Sep 17 00:00:00 2001
From: ultimateforce21 <abdullahmohammad...@gmail.com>
Date: Sat, 28 Jun 2025 21:46:46 -0400
Subject: [PATCH 09/20] Change GetExpressionEntryAtAddress to return
std::optional instead of llvm::Expected
---
lldb/include/lldb/Expression/DWARFExpressionList.h | 2 +-
lldb/source/Expression/DWARFExpressionList.cpp | 7 +++----
2 files changed, 4 insertions(+), 5 deletions(-)
diff --git a/lldb/include/lldb/Expression/DWARFExpressionList.h
b/lldb/include/lldb/Expression/DWARFExpressionList.h
index 31b852eb1ec80..b21b694694ddc 100644
--- a/lldb/include/lldb/Expression/DWARFExpressionList.h
+++ b/lldb/include/lldb/Expression/DWARFExpressionList.h
@@ -70,7 +70,7 @@ class DWARFExpressionList {
/// 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.
- llvm::Expected<DWARFExpressionEntry>
+ std::optional<DWARFExpressionEntry>
GetExpressionEntryAtAddress(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 9a6cccf445028..763dcb568d2ec 100644
--- a/lldb/source/Expression/DWARFExpressionList.cpp
+++ b/lldb/source/Expression/DWARFExpressionList.cpp
@@ -54,7 +54,7 @@ bool DWARFExpressionList::ContainsAddress(lldb::addr_t
func_load_addr,
return GetExpressionAtAddress(func_load_addr, addr) != nullptr;
}
-llvm::Expected<DWARFExpressionList::DWARFExpressionEntry>
+std::optional<DWARFExpressionList::DWARFExpressionEntry>
DWARFExpressionList::GetExpressionEntryAtAddress(lldb::addr_t func_load_addr,
lldb::addr_t load_addr) const {
if (const DWARFExpression *always = GetAlwaysValidExpr()) {
@@ -74,9 +74,8 @@ DWARFExpressionList::GetExpressionEntryAtAddress(lldb::addr_t
func_load_addr,
return DWARFExpressionEntry{range_in_file, &entry->data};
}
- return llvm::createStringError(
- llvm::inconvertibleErrorCode(),
- "no DWARF location list entry for PC 0x%" PRIx64, load_addr);
+ // No entry covers this PC:
+ return std::nullopt;
}
const DWARFExpression *
>From d015971a280d41a68e17530b00258c193ea46a82 Mon Sep 17 00:00:00 2001
From: Abdullah Mohammad Amin
<67847674+ultimateforc...@users.noreply.github.com>
Date: Wed, 2 Jul 2025 11:45:48 -0400
Subject: [PATCH 10/20] Update DWARFExpressionList.cpp
Co-authored-by: Adrian Prantl <adrian.pra...@gmail.com>
---
lldb/source/Expression/DWARFExpressionList.cpp | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/lldb/source/Expression/DWARFExpressionList.cpp
b/lldb/source/Expression/DWARFExpressionList.cpp
index 763dcb568d2ec..2f0f034b613db 100644
--- a/lldb/source/Expression/DWARFExpressionList.cpp
+++ b/lldb/source/Expression/DWARFExpressionList.cpp
@@ -65,7 +65,7 @@ DWARFExpressionList::GetExpressionEntryAtAddress(lldb::addr_t
func_load_addr,
if (func_load_addr == LLDB_INVALID_ADDRESS)
func_load_addr = m_func_file_addr;
- // translate to file-relative PC
+ // Translate to file-relative PC.
lldb::addr_t file_pc = load_addr - func_load_addr + m_func_file_addr;
if (const auto *entry = m_exprs.FindEntryThatContains(file_pc)) {
>From 60898ea58bf178a2aa87f86b44ddfe7fd8b5d6da Mon Sep 17 00:00:00 2001
From: ultimateforce21 <abdullahmohammad...@gmail.com>
Date: Thu, 3 Jul 2025 00:05:26 -0400
Subject: [PATCH 11/20] Add underflow/overflow checks to
GetExpressionEntryAtAddressi This patch adds explicit checks: - ensure
`load_addr >= func_load_addr` to avoid underflow, - compute and verify a
temporary delta variable, then verify `delta + m_func_file_addr` does not
exceed `addr_t` max to avoid overflow.
---
lldb/source/Expression/DWARFExpressionList.cpp | 14 +++++++++++---
1 file changed, 11 insertions(+), 3 deletions(-)
diff --git a/lldb/source/Expression/DWARFExpressionList.cpp
b/lldb/source/Expression/DWARFExpressionList.cpp
index 2f0f034b613db..772c23fd96d0f 100644
--- a/lldb/source/Expression/DWARFExpressionList.cpp
+++ b/lldb/source/Expression/DWARFExpressionList.cpp
@@ -64,10 +64,18 @@
DWARFExpressionList::GetExpressionEntryAtAddress(lldb::addr_t func_load_addr,
if (func_load_addr == LLDB_INVALID_ADDRESS)
func_load_addr = m_func_file_addr;
-
- // Translate to file-relative PC.
- lldb::addr_t file_pc = load_addr - 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());
>From 3462165da7811d190d1896ed41372af25548abd5 Mon Sep 17 00:00:00 2001
From: ultimateforce21 <abdullahmohammad...@gmail.com>
Date: Mon, 7 Jul 2025 22:39:45 -0400
Subject: [PATCH 12/20] Make file_range optional in DWARFExpressionEntry for
always-valid expr
---
lldb/include/lldb/Expression/DWARFExpressionList.h | 2 +-
lldb/source/Expression/DWARFExpressionList.cpp | 3 +--
2 files changed, 2 insertions(+), 3 deletions(-)
diff --git a/lldb/include/lldb/Expression/DWARFExpressionList.h
b/lldb/include/lldb/Expression/DWARFExpressionList.h
index b21b694694ddc..1bd762a9836e8 100644
--- a/lldb/include/lldb/Expression/DWARFExpressionList.h
+++ b/lldb/include/lldb/Expression/DWARFExpressionList.h
@@ -63,7 +63,7 @@ class DWARFExpressionList {
/// 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
- AddressRange file_range;
+ std::optional<AddressRange> file_range; ///< None = always-valid single
expr
const DWARFExpression *expr;
};
diff --git a/lldb/source/Expression/DWARFExpressionList.cpp
b/lldb/source/Expression/DWARFExpressionList.cpp
index 772c23fd96d0f..b51317a98365c 100644
--- a/lldb/source/Expression/DWARFExpressionList.cpp
+++ b/lldb/source/Expression/DWARFExpressionList.cpp
@@ -58,8 +58,7 @@ std::optional<DWARFExpressionList::DWARFExpressionEntry>
DWARFExpressionList::GetExpressionEntryAtAddress(lldb::addr_t func_load_addr,
lldb::addr_t load_addr) const {
if (const DWARFExpression *always = GetAlwaysValidExpr()) {
- AddressRange full_range(m_func_file_addr, /*size=*/LLDB_INVALID_ADDRESS);
- return DWARFExpressionEntry{full_range, always};
+ return DWARFExpressionEntry{std::nullopt, always};
}
if (func_load_addr == LLDB_INVALID_ADDRESS)
>From 2ed84430163412eec217f8cabc653191f5be4766 Mon Sep 17 00:00:00 2001
From: ultimateforce21 <abdullahmohammad...@gmail.com>
Date: Thu, 3 Jul 2025 19:54:27 -0400
Subject: [PATCH 13/20] Annotate Instruction::Dump() with DWARF variable
locations
---
lldb/source/Core/Disassembler.cpp | 49 +++++++++++++++++++++++++++++++
1 file changed, 49 insertions(+)
diff --git a/lldb/source/Core/Disassembler.cpp
b/lldb/source/Core/Disassembler.cpp
index dce3d59457c0e..f818eb20bdad5 100644
--- a/lldb/source/Core/Disassembler.cpp
+++ b/lldb/source/Core/Disassembler.cpp
@@ -26,7 +26,10 @@
#include "lldb/Symbol/Function.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/SymbolContext.h"
+#include "lldb/Symbol/Variable.h"
+#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/Process.h"
#include "lldb/Target/SectionLoadList.h"
#include "lldb/Target/StackFrame.h"
#include "lldb/Target/Target.h"
@@ -702,6 +705,52 @@ void Instruction::Dump(lldb_private::Stream *s, uint32_t
max_opcode_byte_size,
ss.FillLastLineToColumn(opcode_pos + opcode_column_width, ' ');
ss.PutCString(mnemonics);
+ if (exe_ctx && exe_ctx->GetFramePtr()) {
+ StackFrame *frame = exe_ctx->GetFramePtr();
+ TargetSP target_sp = exe_ctx->GetTargetSP();
+ if (frame && target_sp) {
+ addr_t current_pc = m_address.GetLoadAddress(target_sp.get());
+ addr_t original_pc =
frame->GetFrameCodeAddress().GetLoadAddress(target_sp.get());
+ if (frame->ChangePC(current_pc)) {
+ VariableListSP var_list_sp = frame->GetInScopeVariableList(true);
+ SymbolContext sc = frame->GetSymbolContext(eSymbolContextFunction);
+ addr_t func_load_addr = LLDB_INVALID_ADDRESS;
+ if (sc.function)
+ func_load_addr =
sc.function->GetAddress().GetLoadAddress(target_sp.get());
+
+ if (var_list_sp) {
+ for (size_t i = 0; i < var_list_sp->GetSize(); ++i) {
+ VariableSP var_sp = var_list_sp->GetVariableAtIndex(i);
+ if (!var_sp)
+ continue;
+
+ const char *name = var_sp->GetName().AsCString();
+ auto &expr_list = var_sp->LocationExpressionList();
+
+ // Handle std::optional<DWARFExpressionEntry>.
+ if (auto entryOrErr =
expr_list.GetExpressionEntryAtAddress(func_load_addr, current_pc)) {
+ auto entry = *entryOrErr;
+
+ // Translate file-range to load-space start.
+ addr_t file_base =
entry.file_range.GetBaseAddress().GetFileAddress();
+ addr_t start_load_addr = file_base + (func_load_addr -
expr_list.GetFuncFileAddress());
+
+ if (current_pc == start_load_addr) {
+ StreamString loc_str;
+ ABI *abi = exe_ctx->GetProcessPtr()->GetABI().get();
+ entry.expr->DumpLocation(&loc_str, eDescriptionLevelBrief,
abi);
+ ss.FillLastLineToColumn(opcode_pos + opcode_column_width +
operand_column_width, ' ');
+ ss.Printf(" ; %s = %s", name,
loc_str.GetString().str().c_str());
+ }
+ }
+ }
+ }
+
+ frame->ChangePC(original_pc);
+ }
+ }
+ }
+
if (!m_comment.empty()) {
ss.FillLastLineToColumn(
opcode_pos + opcode_column_width + operand_column_width, ' ');
>From 8c6b22dab6ef744742ae46e948f204d6b27f8145 Mon Sep 17 00:00:00 2001
From: ultimateforce21 <abdullahmohammad...@gmail.com>
Date: Sat, 5 Jul 2025 01:22:33 -0400
Subject: [PATCH 14/20] Added Initial Basic API test for rich variable
annotation in disassembly output. Right now just checks if DW annotations
show up for a basic program and that a variable location is annotated (i.e 'a
= DW_OP_reg...').
---
.../rich-disassembler/Makefile | 4 ++
.../rich-disassembler/TestRichDisassembler.py | 38 ++++++++++++++++++
.../rich-disassembler/main.cpp | 15 +++++++
.../rich-disassembler/unoptimized_output | Bin 0 -> 17184 bytes
4 files changed, 57 insertions(+)
create mode 100644 lldb/test/API/functionalities/rich-disassembler/Makefile
create mode 100644
lldb/test/API/functionalities/rich-disassembler/TestRichDisassembler.py
create mode 100644 lldb/test/API/functionalities/rich-disassembler/main.cpp
create mode 100755
lldb/test/API/functionalities/rich-disassembler/unoptimized_output
diff --git a/lldb/test/API/functionalities/rich-disassembler/Makefile
b/lldb/test/API/functionalities/rich-disassembler/Makefile
new file mode 100644
index 0000000000000..5fcbc722e7559
--- /dev/null
+++ b/lldb/test/API/functionalities/rich-disassembler/Makefile
@@ -0,0 +1,4 @@
+CXX := clang++
+CXX_SOURCES := main.cpp
+CXXFLAGS_EXTRAS := -g -O0 -fno-inline
+include Makefile.rules
diff --git
a/lldb/test/API/functionalities/rich-disassembler/TestRichDisassembler.py
b/lldb/test/API/functionalities/rich-disassembler/TestRichDisassembler.py
new file mode 100644
index 0000000000000..2a8b7df1947c1
--- /dev/null
+++ b/lldb/test/API/functionalities/rich-disassembler/TestRichDisassembler.py
@@ -0,0 +1,38 @@
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test.decorators import *
+
+class TestRichDisassembler(TestBase):
+ """
+ Tests that the disassembler includes DWARF variable annotations in output.
+ Specifically checks that variables like 'a' and 'temp' are shown with
DW_OP locations.
+ """
+ def test_variable_annotation(self):
+ print("Building with:", self.getCompiler())
+ self.build()
+ exe = self.getBuildArtifact("a.out")
+ target = self.dbg.CreateTarget(exe)
+ self.assertTrue(target)
+
+ src_file = lldb.SBFileSpec("main.cpp")
+ breakpoint = target.BreakpointCreateByName("test")
+ print("Breakpoint locations:", breakpoint.GetNumLocations())
+ self.assertGreater(breakpoint.GetNumLocations(), 0)
+
+ process = target.LaunchSimple(None, None,
self.get_process_working_directory())
+ print("Process state:", process.GetState())
+ print("Exit status:", process.GetExitStatus())
+ print("Exit description:", process.GetExitDescription())
+
+ self.assertTrue(process, "Failed to launch process")
+ self.assertEqual(process.GetState(), lldb.eStateStopped, "Process did
not stop")
+
+ frame = process.GetSelectedThread().GetSelectedFrame()
+ disasm = frame.Disassemble()
+ print(disasm)
+
+ # Check that at least one DWARF annotation is shown.
+ self.assertIn("DW_OP_", disasm)
+
+ # Check that at least one variable name is annotated.
+ self.assertRegex(disasm, r'[a-zA-Z_]\w*\s*=\s*DW_OP_')
+
diff --git a/lldb/test/API/functionalities/rich-disassembler/main.cpp
b/lldb/test/API/functionalities/rich-disassembler/main.cpp
new file mode 100644
index 0000000000000..4fa182b9fa0de
--- /dev/null
+++ b/lldb/test/API/functionalities/rich-disassembler/main.cpp
@@ -0,0 +1,15 @@
+// main.cpp
+
+
+__attribute__((noinline))
+void test(int a) {
+ for (int i = 0; i < 3; ++i) { // i should be in a register
+ int temp = i + 1; // temp also likely register
+ }
+}
+
+int main() {
+ test(5);
+ return 0;
+}
+
diff --git a/lldb/test/API/functionalities/rich-disassembler/unoptimized_output
b/lldb/test/API/functionalities/rich-disassembler/unoptimized_output
new file mode 100755
index
0000000000000000000000000000000000000000..3ead1df962fa45b59eb04f5957d72195cfbe1332
GIT binary patch
literal 17184
zcmeHOYiu0V6~43UUE4VEBamVe6mKA=;o-5@aY7Ⓢuj*MhTC^fwUzI<K3~nWgljD
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
T;$5w_KD*J8s|laLXR3b!>b;%1
literal 0
HcmV?d00001
>From 842a9e51bd89282277e067a66cd6f1651fa61a74 Mon Sep 17 00:00:00 2001
From: ultimateforce21 <abdullahmohammad...@gmail.com>
Date: Sun, 6 Jul 2025 01:09:36 -0400
Subject: [PATCH 15/20] Improved DWARF variable annotation printing and
alignment
- Fixed an issue where variable location annotations were not shown if the
current instruction address did not exactly match the DWARF base address. Now,
annotations are shown as long as the PC is within the valid range.
- Improved alignment of annotation comments in Instruction::Dump(). While
`FillLastLineToColumn` can sometimes overcompensate due to internal formatting
or byte-width mismatches, the overall alignment is now significantly more
consistent and readable.
---
lldb/source/Core/Disassembler.cpp | 64 ++++++++++++++++++++-----------
1 file changed, 41 insertions(+), 23 deletions(-)
diff --git a/lldb/source/Core/Disassembler.cpp
b/lldb/source/Core/Disassembler.cpp
index f818eb20bdad5..a3f8efe3487ef 100644
--- a/lldb/source/Core/Disassembler.cpp
+++ b/lldb/source/Core/Disassembler.cpp
@@ -705,6 +705,8 @@ void Instruction::Dump(lldb_private::Stream *s, uint32_t
max_opcode_byte_size,
ss.FillLastLineToColumn(opcode_pos + opcode_column_width, ' ');
ss.PutCString(mnemonics);
+ const size_t annotation_column = 150;
+
if (exe_ctx && exe_ctx->GetFramePtr()) {
StackFrame *frame = exe_ctx->GetFramePtr();
TargetSP target_sp = exe_ctx->GetTargetSP();
@@ -718,29 +720,45 @@ void Instruction::Dump(lldb_private::Stream *s, uint32_t
max_opcode_byte_size,
if (sc.function)
func_load_addr =
sc.function->GetAddress().GetLoadAddress(target_sp.get());
- if (var_list_sp) {
- for (size_t i = 0; i < var_list_sp->GetSize(); ++i) {
- VariableSP var_sp = var_list_sp->GetVariableAtIndex(i);
- if (!var_sp)
- continue;
-
- const char *name = var_sp->GetName().AsCString();
- auto &expr_list = var_sp->LocationExpressionList();
-
- // Handle std::optional<DWARFExpressionEntry>.
- if (auto entryOrErr =
expr_list.GetExpressionEntryAtAddress(func_load_addr, current_pc)) {
- auto entry = *entryOrErr;
-
- // Translate file-range to load-space start.
- addr_t file_base =
entry.file_range.GetBaseAddress().GetFileAddress();
- addr_t start_load_addr = file_base + (func_load_addr -
expr_list.GetFuncFileAddress());
-
- if (current_pc == start_load_addr) {
- StreamString loc_str;
- ABI *abi = exe_ctx->GetProcessPtr()->GetABI().get();
- entry.expr->DumpLocation(&loc_str, eDescriptionLevelBrief,
abi);
- ss.FillLastLineToColumn(opcode_pos + opcode_column_width +
operand_column_width, ' ');
- ss.Printf(" ; %s = %s", name,
loc_str.GetString().str().c_str());
+
+ if(ss.GetSizeOfLastLine() < annotation_column) {
+
+ std::vector<std::string> annotations;
+
+ if (var_list_sp) {
+ for (size_t i = 0; i < var_list_sp->GetSize(); ++i) {
+ VariableSP var_sp = var_list_sp->GetVariableAtIndex(i);
+ if (!var_sp)
+ continue;
+
+ const char *name = var_sp->GetName().AsCString();
+ auto &expr_list = var_sp->LocationExpressionList();
+ if (!expr_list.IsValid())
+ continue;
+ // Handle std::optional<DWARFExpressionEntry>.
+ if (auto entryOrErr =
expr_list.GetExpressionEntryAtAddress(func_load_addr, current_pc)) {
+ auto entry = *entryOrErr;
+
+ // Translate file-range to load-space start.
+ addr_t file_base =
entry.file_range.GetBaseAddress().GetFileAddress();
+ addr_t start_load_addr = file_base + (func_load_addr -
expr_list.GetFuncFileAddress());
+
+ if (current_pc >= start_load_addr) {
+ StreamString loc_str;
+ ABI *abi = exe_ctx->GetProcessPtr()->GetABI().get();
+ entry.expr->DumpLocation(&loc_str, eDescriptionLevelBrief,
abi);
+ annotations.push_back(llvm::formatv("{0} = {1}", name,
loc_str.GetString()));
+ }
+ }
+ }
+
+ if (!annotations.empty()) {
+ ss.FillLastLineToColumn(annotation_column, ' ');
+ ss.PutCString(" ; ");
+ for (size_t i = 0; i < annotations.size(); ++i) {
+ if (i > 0)
+ ss.PutCString(", ");
+ ss.PutCString(annotations[i]);
}
}
}
>From 2fa6d243b24927510af426cfbd57c112c7289b0e Mon Sep 17 00:00:00 2001
From: ultimateforce21 <abdullahmohammad...@gmail.com>
Date: Sun, 6 Jul 2025 11:10:46 -0400
Subject: [PATCH 16/20] Filter out partial DWARF decoding errors from
disassembly annotations
Previously, when a DWARF expression contained any decoding error,
the entire variable location annotation was printed with the error,
e.g. `c = DW_OP_addr 0x0, <decoding error> 00 00 00`. This was
misleading and cluttered the disassembly view.
This patch improves the formatting by stripping out the
`<decoding error ...>` fragments while preserving the valid portions
of the expression, so that partial information like
`c = DW_OP_addr 0x0` can still be shown.
This allows the rich disassembler to give more meaningful variable
annotations, especially in optimized (-O1/-O2) builds where partial
DWARF corruption or unsupported expressions may occur.
---
lldb/source/Core/Disassembler.cpp | 15 ++++++++++++++-
1 file changed, 14 insertions(+), 1 deletion(-)
diff --git a/lldb/source/Core/Disassembler.cpp
b/lldb/source/Core/Disassembler.cpp
index a3f8efe3487ef..0982c98fd80c0 100644
--- a/lldb/source/Core/Disassembler.cpp
+++ b/lldb/source/Core/Disassembler.cpp
@@ -49,6 +49,7 @@
#include <cstdint>
#include <cstring>
+#include <regex>
#include <utility>
#include <cassert>
@@ -747,7 +748,19 @@ void Instruction::Dump(lldb_private::Stream *s, uint32_t
max_opcode_byte_size,
StreamString loc_str;
ABI *abi = exe_ctx->GetProcessPtr()->GetABI().get();
entry.expr->DumpLocation(&loc_str, eDescriptionLevelBrief,
abi);
- annotations.push_back(llvm::formatv("{0} = {1}", name,
loc_str.GetString()));
+
+ std::string loc_output = loc_str.GetString().str();
+
+ // Remove ", <decoding error> ..." segments.
+ std::regex decoding_err_re(", <decoding error>[^,]*");
+ loc_output = std::regex_replace(loc_output, decoding_err_re,
"");
+
+ llvm::StringRef cleaned_output =
llvm::StringRef(loc_output).trim();
+
+ // Only keep this annotation if there is still something
useful left.
+ if (!cleaned_output.empty()) {
+ annotations.push_back(llvm::formatv("{0} = {1}", name,
cleaned_output));
+ }
}
}
}
>From 6bbc8aaa45e8df045ccb5be4db52ab23fa169aa2 Mon Sep 17 00:00:00 2001
From: ultimateforce21 <abdullahmohammad...@gmail.com>
Date: Sun, 6 Jul 2025 11:45:19 -0400
Subject: [PATCH 17/20] Ignore annotations with only decoding errors
Handled edge case where the entire DWARF expression is a `<decoding error>`,
ensuring no misleading or empty annotations are printed for such variables.
---
lldb/source/Core/Disassembler.cpp | 35 +++++++++++++++++++++++++------
1 file changed, 29 insertions(+), 6 deletions(-)
diff --git a/lldb/source/Core/Disassembler.cpp
b/lldb/source/Core/Disassembler.cpp
index 0982c98fd80c0..710856404b67a 100644
--- a/lldb/source/Core/Disassembler.cpp
+++ b/lldb/source/Core/Disassembler.cpp
@@ -751,15 +751,38 @@ void Instruction::Dump(lldb_private::Stream *s, uint32_t
max_opcode_byte_size,
std::string loc_output = loc_str.GetString().str();
- // Remove ", <decoding error> ..." segments.
- std::regex decoding_err_re(", <decoding error>[^,]*");
- loc_output = std::regex_replace(loc_output, decoding_err_re,
"");
+ // // Remove ", <decoding error> ..." segments.
+ // std::regex decoding_err_re(", <decoding error>[^,]*");
+ // loc_output = std::regex_replace(loc_output,
decoding_err_re, "");
- llvm::StringRef cleaned_output =
llvm::StringRef(loc_output).trim();
+ // llvm::StringRef cleaned_output =
llvm::StringRef(loc_output).trim();
+
+ // // Only keep this annotation if there is still something
useful left.
+ // if (!cleaned_output.empty()) {
+ // annotations.push_back(llvm::formatv("{0} = {1}", name,
cleaned_output));
+ // }
+
+ llvm::SmallVector<llvm::StringRef, 4> parts;
+ llvm::StringRef(loc_str.GetString()).split(parts, ", ");
+
+ // Reconstruct the string without the decoding error chunks
+ std::string cleaned_output;
+ bool first = true;
+
+ for (const auto &part : parts) {
+ if (part.contains("<decoding error>"))
+ continue;
+
+ if (!first)
+ cleaned_output += ", ";
+ cleaned_output += part.str();
+ first = false;
+ }
// Only keep this annotation if there is still something
useful left.
- if (!cleaned_output.empty()) {
- annotations.push_back(llvm::formatv("{0} = {1}", name,
cleaned_output));
+ llvm::StringRef cleaned_ref =
llvm::StringRef(cleaned_output).trim();
+ if (!cleaned_ref.empty()) {
+ annotations.push_back(llvm::formatv("{0} = {1}", name,
cleaned_ref));
}
}
}
>From cbbc9241e0b620f7cc8e925fd83fe36dd94536a4 Mon Sep 17 00:00:00 2001
From: ultimateforce21 <abdullahmohammad...@gmail.com>
Date: Sun, 6 Jul 2025 14:19:12 -0400
Subject: [PATCH 18/20] Add tests for disassembly variable annotations and
decoding edge cases
This patch adds API tests to verify that DWARF variable location
annotations are correctly displayed in the disassembly output.
The tests cover:
- Local variables in loops and functions
- Multiple stack variables
- Control flow edge cases
- Different optimization levels (-O0, -O1, -O2)
- Ensuring decoding errors are excluded from output
---
.../rich-disassembler/Makefile | 8 +-
.../rich-disassembler/TestRichDisassembler.py | 295 +++++++++++++++++-
.../a_loop_with_local_variable.c | 8 +
.../b_multiple_stack_variables.c | 9 +
.../c_variable_passed_to_another_function.c | 11 +
.../rich-disassembler/d_original_example.c | 7 +
.../rich-disassembler/e_control_flow_edge.c | 10 +
.../rich-disassembler/main.cpp | 15 -
.../rich-disassembler/unoptimized_output | Bin 17184 -> 0 bytes
9 files changed, 328 insertions(+), 35 deletions(-)
create mode 100644
lldb/test/API/functionalities/rich-disassembler/a_loop_with_local_variable.c
create mode 100644
lldb/test/API/functionalities/rich-disassembler/b_multiple_stack_variables.c
create mode 100644
lldb/test/API/functionalities/rich-disassembler/c_variable_passed_to_another_function.c
create mode 100644
lldb/test/API/functionalities/rich-disassembler/d_original_example.c
create mode 100644
lldb/test/API/functionalities/rich-disassembler/e_control_flow_edge.c
delete mode 100644 lldb/test/API/functionalities/rich-disassembler/main.cpp
delete mode 100755
lldb/test/API/functionalities/rich-disassembler/unoptimized_output
diff --git a/lldb/test/API/functionalities/rich-disassembler/Makefile
b/lldb/test/API/functionalities/rich-disassembler/Makefile
index 5fcbc722e7559..ae3330e632a0e 100644
--- a/lldb/test/API/functionalities/rich-disassembler/Makefile
+++ b/lldb/test/API/functionalities/rich-disassembler/Makefile
@@ -1,4 +1,6 @@
-CXX := clang++
-CXX_SOURCES := main.cpp
-CXXFLAGS_EXTRAS := -g -O0 -fno-inline
+
+# CXX_SOURCES := a_loop_with_local_variable.c b_multiple_stack_variables.c
c_variable_passed_to_another_function.c d_original_example.c
e_control_flow_edge.c
+C_SOURCES := a_loop_with_local_variable.c b_multiple_stack_variables.c
c_variable_passed_to_another_function.c d_original_example.c
e_control_flow_edge.c
+
+
include Makefile.rules
diff --git
a/lldb/test/API/functionalities/rich-disassembler/TestRichDisassembler.py
b/lldb/test/API/functionalities/rich-disassembler/TestRichDisassembler.py
index 2a8b7df1947c1..d85e6488575b7 100644
--- a/lldb/test/API/functionalities/rich-disassembler/TestRichDisassembler.py
+++ b/lldb/test/API/functionalities/rich-disassembler/TestRichDisassembler.py
@@ -2,37 +2,298 @@
from lldbsuite.test.decorators import *
class TestRichDisassembler(TestBase):
- """
- Tests that the disassembler includes DWARF variable annotations in output.
- Specifically checks that variables like 'a' and 'temp' are shown with
DW_OP locations.
- """
- def test_variable_annotation(self):
- print("Building with:", self.getCompiler())
- self.build()
+
+ @no_debug_info_test
+ def test_a_loop_with_local_variable(self):
+ """
+ Tests that the disassembler includes basic DWARF variable annotation
in output.
+ Specifically checks that local variables in a loop are shown with
DW_OP locations.
+ Additionally, it verifies that the disassembly does not contain
decoding errors.
+ """
+ self.build(dictionary={
+ 'C_SOURCES': 'a_loop_with_local_variable.c',
+ 'CFLAGS_EXTRAS': '-g -O0'
+ })
+ exe = self.getBuildArtifact("a.out")
+ target = self.dbg.CreateTarget(exe)
+ self.assertTrue(target)
+
+ # Set a breakpoint inside main's loop
+ src_file = lldb.SBFileSpec("test_loop_function_call.c")
+ breakpoint = target.BreakpointCreateByName("main")
+ self.assertGreater(breakpoint.GetNumLocations(), 0)
+
+ process = target.LaunchSimple(None, None,
self.get_process_working_directory())
+ self.assertTrue(process, "Failed to launch process")
+ self.assertEqual(process.GetState(), lldb.eStateStopped)
+
+ frame = process.GetSelectedThread().GetSelectedFrame()
+ disasm = frame.Disassemble()
+ print(disasm)
+
+ # Check that we have DWARF annotations for variables
+ self.assertIn("i = ", disasm)
+ self.assertIn("DW_OP", disasm)
+ self.assertNotIn("<decoding error>", disasm)
+
+
+ @no_debug_info_test
+ def test_b_multiple_stack_variables_O0(self):
+ """
+ Tests disassembler output for b_multiple_stack_variables.c built with
-O0.
+ This test checks that multiple local variables are annotated with DWARF
+ and that their locations are distinct. It also ensures that no
decoding errors appear.
+ """
+ self.build(dictionary={
+ 'C_SOURCES': 'b_multiple_stack_variables.c',
+ 'CFLAGS_EXTRAS': '-g -O0'
+ })
+ exe = self.getBuildArtifact("a.out")
+ target = self.dbg.CreateTarget(exe)
+ self.assertTrue(target)
+
+ # Set a breakpoint inside main's loop
+ src_file = lldb.SBFileSpec("test_loop_function_call.c")
+ breakpoint = target.BreakpointCreateByName("main")
+ self.assertGreater(breakpoint.GetNumLocations(), 0)
+
+ process = target.LaunchSimple(None, None,
self.get_process_working_directory())
+ self.assertTrue(process, "Failed to launch process")
+ self.assertEqual(process.GetState(), lldb.eStateStopped)
+
+ frame = process.GetSelectedThread().GetSelectedFrame()
+ disasm = frame.Disassemble()
+ print(disasm)
+
+ # Check that we have DWARF annotations for variables
+ self.assertIn("a = ", disasm)
+ self.assertIn("b = ", disasm)
+ self.assertIn("c = ", disasm)
+ self.assertIn("DW_OP", disasm)
+ self.assertNotIn("<decoding error>", disasm)
+
+
+ @no_debug_info_test
+ def test_b_multiple_stack_variables_O1(self):
+ """
+ Tests disassembler output for b_multiple_stack_variables.c built with
-O1.
+ Due to optimizations, some variables may be optimized out.
+ We only check for 'c' and ensure no decoding errors appear.
+ """
+ self.build(dictionary={
+ 'C_SOURCES': 'b_multiple_stack_variables.c',
+ 'CFLAGS_EXTRAS': '-g -O1'
+ })
+ exe = self.getBuildArtifact("a.out")
+ target = self.dbg.CreateTarget(exe)
+ self.assertTrue(target)
+
+ breakpoint = target.BreakpointCreateByName("main")
+ self.assertGreater(breakpoint.GetNumLocations(), 0)
+
+ process = target.LaunchSimple(None, None,
self.get_process_working_directory())
+ self.assertTrue(process, "Failed to launch process")
+ self.assertEqual(process.GetState(), lldb.eStateStopped)
+
+ frame = process.GetSelectedThread().GetSelectedFrame()
+ disasm = frame.Disassemble()
+ print(disasm)
+
+ self.assertIn("c = ", disasm)
+ self.assertIn("DW_OP", disasm)
+ self.assertNotIn("<decoding error>", disasm)
+
+
+ @no_debug_info_test
+ def test_c_variable_passed_to_another_function(self):
+ """
+ Tests disassembler output for c_variable_passed_to_another_function.c.
+ This test checks that a variable passed to another function is
annotated
+ with DWARF and that its location is distinct. It also ensures that no
decoding errors appear.
+ """
+ self.build(dictionary={
+ 'C_SOURCES': 'c_variable_passed_to_another_function.c',
+ 'CFLAGS_EXTRAS': '-g -O0'
+ })
+ exe = self.getBuildArtifact("a.out")
+ target = self.dbg.CreateTarget(exe)
+ self.assertTrue(target)
+
+ breakpoint = target.BreakpointCreateByName("main")
+ self.assertGreater(breakpoint.GetNumLocations(), 0)
+
+ process = target.LaunchSimple(None, None,
self.get_process_working_directory())
+ self.assertTrue(process, "Failed to launch process")
+ self.assertEqual(process.GetState(), lldb.eStateStopped)
+
+ frame = process.GetSelectedThread().GetSelectedFrame()
+ disasm = frame.Disassemble()
+ print(disasm)
+
+ self.assertIn("x = ", disasm)
+ self.assertIn("DW_OP", disasm)
+ self.assertNotIn("<decoding error>", disasm)
+
+
+ @no_debug_info_test
+ def test_c_variable_passed_to_another_function_O1(self):
+ """
+ Tests disassembler output for c_variable_passed_to_another_function.c
built with -O1.
+ """
+ self.build(dictionary={
+ 'C_SOURCES': 'c_variable_passed_to_another_function.c',
+ 'CFLAGS_EXTRAS': '-g -O1'
+ })
+ exe = self.getBuildArtifact("a.out")
+ target = self.dbg.CreateTarget(exe)
+ self.assertTrue(target)
+
+ breakpoint = target.BreakpointCreateByName("main")
+ self.assertGreater(breakpoint.GetNumLocations(), 0)
+
+ process = target.LaunchSimple(None, None,
self.get_process_working_directory())
+ self.assertTrue(process, "Failed to launch process")
+ self.assertEqual(process.GetState(), lldb.eStateStopped)
+
+ frame = process.GetSelectedThread().GetSelectedFrame()
+ disasm = frame.Disassemble()
+ print(disasm)
+
+ self.assertIn("x = ", disasm)
+ self.assertIn("arg = ", disasm)
+ self.assertIn("DW_OP", disasm)
+ self.assertNotIn("<decoding error>", disasm)
+
+ @no_debug_info_test
+ def test_d_original_example(self):
+ """
+ Tests disassembler output for d_original_example.c.
+ This test checks that the disassembly includes basic DWARF variable
annotations
+ and that local variables in the main function are shown with DW_OP
locations.
+ Additionally, it verifies that the disassembly does not contain
decoding errors.
+ """
+ self.build(dictionary={
+ 'C_SOURCES': 'd_original_example.c',
+ 'CFLAGS_EXTRAS': '-g -O0'
+ })
exe = self.getBuildArtifact("a.out")
target = self.dbg.CreateTarget(exe)
self.assertTrue(target)
- src_file = lldb.SBFileSpec("main.cpp")
- breakpoint = target.BreakpointCreateByName("test")
- print("Breakpoint locations:", breakpoint.GetNumLocations())
+ breakpoint = target.BreakpointCreateByName("main")
self.assertGreater(breakpoint.GetNumLocations(), 0)
process = target.LaunchSimple(None, None,
self.get_process_working_directory())
- print("Process state:", process.GetState())
- print("Exit status:", process.GetExitStatus())
- print("Exit description:", process.GetExitDescription())
+ self.assertTrue(process, "Failed to launch process")
+ self.assertEqual(process.GetState(), lldb.eStateStopped)
+
+ frame = process.GetSelectedThread().GetSelectedFrame()
+ disasm = frame.Disassemble()
+ print(disasm)
+
+ self.assertIn("argc = ", disasm)
+ self.assertIn("argv = ", disasm)
+ self.assertIn("i = ", disasm)
+ self.assertIn("DW_OP", disasm)
+ self.assertNotIn("<decoding error>", disasm)
+
+ @no_debug_info_test
+ def test_d_original_example_O1(self):
+ """
+ Tests disassembler output for d_original_example.c built with -O1.
+ """
+ self.build(dictionary={
+ 'C_SOURCES': 'd_original_example.c',
+ 'CFLAGS_EXTRAS': '-g -O1'
+ })
+ exe = self.getBuildArtifact("a.out")
+ target = self.dbg.CreateTarget(exe)
+ self.assertTrue(target)
+
+ breakpoint = target.BreakpointCreateByName("main")
+ self.assertGreater(breakpoint.GetNumLocations(), 0)
+
+ process = target.LaunchSimple(None, None,
self.get_process_working_directory())
+ self.assertTrue(process, "Failed to launch process")
+ self.assertEqual(process.GetState(), lldb.eStateStopped)
+
+ frame = process.GetSelectedThread().GetSelectedFrame()
+ disasm = frame.Disassemble()
+ print(disasm)
+
+ self.assertIn("argc = ", disasm)
+ self.assertIn("argv = ", disasm)
+ self.assertIn("i = ", disasm)
+ self.assertIn("DW_OP_reg", disasm)
+ self.assertIn("DW_OP_stack_value", disasm)
+ self.assertNotIn("<decoding error>", disasm)
+
+
+ @no_debug_info_test
+ def test_e_control_flow_edge(self):
+ """
+ Tests disassembler output for e_control_flow_edge.c with a focus on
control flow edges.
+ This test checks that the disassembly includes basic DWARF variable
annotations
+ and that local variables in the main function are shown with DW_OP
locations.
+ Additionally, it verifies that the disassembly does not contain
decoding errors.
+ """
+ self.build(dictionary={
+ 'C_SOURCES': 'e_control_flow_edge.c',
+ 'CFLAGS_EXTRAS': '-g -O0'
+ })
+ exe = self.getBuildArtifact("a.out")
+ target = self.dbg.CreateTarget(exe)
+ self.assertTrue(target)
+
+ breakpoint = target.BreakpointCreateByName("main")
+ self.assertGreater(breakpoint.GetNumLocations(), 0)
+ process = target.LaunchSimple(None, None,
self.get_process_working_directory())
self.assertTrue(process, "Failed to launch process")
- self.assertEqual(process.GetState(), lldb.eStateStopped, "Process did
not stop")
+ self.assertEqual(process.GetState(), lldb.eStateStopped)
frame = process.GetSelectedThread().GetSelectedFrame()
disasm = frame.Disassemble()
print(disasm)
- # Check that at least one DWARF annotation is shown.
+ self.assertIn("a = ", disasm)
+ self.assertIn("b = ", disasm)
self.assertIn("DW_OP_", disasm)
+ self.assertNotIn("<decoding error>", disasm)
+
+ @no_debug_info_test
+ def test_e_control_flow_edge_O1(self):
+ """
+ Tests disassembler output for e_control_flow_edge.c built with -O1.
+ This test checks that the disassembly annotation does not contain
decoding errors.
+ """
+ self.build(dictionary={
+ 'C_SOURCES': 'e_control_flow_edge.c',
+ 'CFLAGS_EXTRAS': '-g -O1'
+ })
+ exe = self.getBuildArtifact("a.out")
+ target = self.dbg.CreateTarget(exe)
+ self.assertTrue(target)
+
+ breakpoint = target.BreakpointCreateByName("main")
+ self.assertGreater(breakpoint.GetNumLocations(), 0)
+
+ process = target.LaunchSimple(None, None,
self.get_process_working_directory())
+ self.assertTrue(process, "Failed to launch process")
+ self.assertEqual(process.GetState(), lldb.eStateStopped)
+
+ frame = process.GetSelectedThread().GetSelectedFrame()
+ disasm = frame.Disassemble()
+ print(disasm)
+
+ self.assertNotIn("<decoding error>", disasm)
+
+
+
+
+
+
+
+
- # Check that at least one variable name is annotated.
- self.assertRegex(disasm, r'[a-zA-Z_]\w*\s*=\s*DW_OP_')
diff --git
a/lldb/test/API/functionalities/rich-disassembler/a_loop_with_local_variable.c
b/lldb/test/API/functionalities/rich-disassembler/a_loop_with_local_variable.c
new file mode 100644
index 0000000000000..6555f3822187f
--- /dev/null
+++
b/lldb/test/API/functionalities/rich-disassembler/a_loop_with_local_variable.c
@@ -0,0 +1,8 @@
+#include <stdio.h>
+
+int main() {
+ for (int i = 0; i < 3; ++i) {
+ puts("Hi");
+ }
+ return 0;
+}
diff --git
a/lldb/test/API/functionalities/rich-disassembler/b_multiple_stack_variables.c
b/lldb/test/API/functionalities/rich-disassembler/b_multiple_stack_variables.c
new file mode 100644
index 0000000000000..d3cd447b43d65
--- /dev/null
+++
b/lldb/test/API/functionalities/rich-disassembler/b_multiple_stack_variables.c
@@ -0,0 +1,9 @@
+#include <stdio.h>
+
+int main() {
+ int a = 1;
+ int b = 2;
+ int c = a + b;
+ return c;
+}
+
diff --git
a/lldb/test/API/functionalities/rich-disassembler/c_variable_passed_to_another_function.c
b/lldb/test/API/functionalities/rich-disassembler/c_variable_passed_to_another_function.c
new file mode 100644
index 0000000000000..9603bdc636043
--- /dev/null
+++
b/lldb/test/API/functionalities/rich-disassembler/c_variable_passed_to_another_function.c
@@ -0,0 +1,11 @@
+#include <stdio.h>
+
+void foo(int arg) {
+ printf("%d\n", arg);
+}
+
+int main() {
+ int x = 10;
+ foo(x);
+ return 0;
+}
diff --git
a/lldb/test/API/functionalities/rich-disassembler/d_original_example.c
b/lldb/test/API/functionalities/rich-disassembler/d_original_example.c
new file mode 100644
index 0000000000000..4f245f518a182
--- /dev/null
+++ b/lldb/test/API/functionalities/rich-disassembler/d_original_example.c
@@ -0,0 +1,7 @@
+#include <stdio.h>
+
+int main(int argc, char **argv) {
+ for (int i = 1; i < argc; ++i)
+ puts(argv[i]);
+ return 0;
+}
diff --git
a/lldb/test/API/functionalities/rich-disassembler/e_control_flow_edge.c
b/lldb/test/API/functionalities/rich-disassembler/e_control_flow_edge.c
new file mode 100644
index 0000000000000..d8d69f501eb4f
--- /dev/null
+++ b/lldb/test/API/functionalities/rich-disassembler/e_control_flow_edge.c
@@ -0,0 +1,10 @@
+#include <stdio.h>
+
+int main() {
+ int a = 1;
+ if (a > 0) {
+ int b = 2;
+ return b;
+ }
+ return a;
+}
diff --git a/lldb/test/API/functionalities/rich-disassembler/main.cpp
b/lldb/test/API/functionalities/rich-disassembler/main.cpp
deleted file mode 100644
index 4fa182b9fa0de..0000000000000
--- a/lldb/test/API/functionalities/rich-disassembler/main.cpp
+++ /dev/null
@@ -1,15 +0,0 @@
-// main.cpp
-
-
-__attribute__((noinline))
-void test(int a) {
- for (int i = 0; i < 3; ++i) { // i should be in a register
- int temp = i + 1; // temp also likely register
- }
-}
-
-int main() {
- test(5);
- return 0;
-}
-
diff --git a/lldb/test/API/functionalities/rich-disassembler/unoptimized_output
b/lldb/test/API/functionalities/rich-disassembler/unoptimized_output
deleted file mode 100755
index
3ead1df962fa45b59eb04f5957d72195cfbe1332..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 17184
zcmeHOYiu0V6~43UUE4VEBamVe6mKA=;o-5@aY7Ⓢuj*MhTC^fwUzI<K3~nWgljD
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
T;$5w_KD*J8s|laLXR3b!>b;%1
>From b887db2cb51c170ec8c6b0159768344d919cab10 Mon Sep 17 00:00:00 2001
From: ultimateforce21 <abdullahmohammad...@gmail.com>
Date: Mon, 7 Jul 2025 23:52:24 -0400
Subject: [PATCH 19/20] Rebase disassembler annotations branch onto updated
DWARFExpressionEntry API
This rebases the `add-disassembler-annotations` work onto the
latest `add-dwarfexprentry-api` branch so that the instruction
annotation patches sit cleanly atop the new DWARFExpressionEntry
struct and helper API. All conflicts have been resolved and the
annotation code now integrates with the updated
std::optional<AddressRange>-based
GetExpressionEntryAtAddress signature.
---
lldb/source/Core/Disassembler.cpp | 19 +++----------------
1 file changed, 3 insertions(+), 16 deletions(-)
diff --git a/lldb/source/Core/Disassembler.cpp
b/lldb/source/Core/Disassembler.cpp
index 710856404b67a..30a028d005dc1 100644
--- a/lldb/source/Core/Disassembler.cpp
+++ b/lldb/source/Core/Disassembler.cpp
@@ -49,7 +49,6 @@
#include <cstdint>
#include <cstring>
-#include <regex>
#include <utility>
#include <cassert>
@@ -740,28 +739,16 @@ void Instruction::Dump(lldb_private::Stream *s, uint32_t
max_opcode_byte_size,
if (auto entryOrErr =
expr_list.GetExpressionEntryAtAddress(func_load_addr, current_pc)) {
auto entry = *entryOrErr;
- // Translate file-range to load-space start.
- addr_t file_base =
entry.file_range.GetBaseAddress().GetFileAddress();
- addr_t start_load_addr = file_base + (func_load_addr -
expr_list.GetFuncFileAddress());
+ // Check if entry has a file_range, and filter on address if
so.
+ if (!entry.file_range || entry.file_range->ContainsFileAddress(
+ (current_pc - func_load_addr) +
expr_list.GetFuncFileAddress())) {
- if (current_pc >= start_load_addr) {
StreamString loc_str;
ABI *abi = exe_ctx->GetProcessPtr()->GetABI().get();
entry.expr->DumpLocation(&loc_str, eDescriptionLevelBrief,
abi);
std::string loc_output = loc_str.GetString().str();
- // // Remove ", <decoding error> ..." segments.
- // std::regex decoding_err_re(", <decoding error>[^,]*");
- // loc_output = std::regex_replace(loc_output,
decoding_err_re, "");
-
- // llvm::StringRef cleaned_output =
llvm::StringRef(loc_output).trim();
-
- // // Only keep this annotation if there is still something
useful left.
- // if (!cleaned_output.empty()) {
- // annotations.push_back(llvm::formatv("{0} = {1}", name,
cleaned_output));
- // }
-
llvm::SmallVector<llvm::StringRef, 4> parts;
llvm::StringRef(loc_str.GetString()).split(parts, ", ");
>From 912ba6d5a7a00c9111aae12a89ef84ccf0de00b4 Mon Sep 17 00:00:00 2001
From: ultimateforce21 <abdullahmohammad...@gmail.com>
Date: Wed, 9 Jul 2025 11:48:09 -0400
Subject: [PATCH 20/20] Add `PrintRegisterOnly` flag in `struct DIDumpOptions`
and created new `DWARFExpression::DumpLocationWithOptions` for simplified
expression printing
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
This patch introduces a PrintRegisterOnly flag to the DIDumpOptions struct,
enabling concise rendering of DWARF expressions for disassembler annotations.
Key changes:
- Added DumpLocationWithOptions to DWARFExpression for flexible dumping with
DIDumpOptions.
- Updated DWARFExpression::print and Operation::print to respect
PrintRegisterOnly, rendering registers like RDI without DW_OP_ or llvm:
prefixes.
- Suppressed <decoding error> output when PrintRegisterOnly is true to avoid
clutter during register-only disassembly output.
These changes are motivated by LLDB’s rich disassembler feature, where
annotations should match user-facing register names without DWARF-level detail.
Test impact:
Some rich-disassembler tests that relied on DW_OP_ for validation were
deprecated. Updated tests aligned with the new formatting will be added next.
---
.../include/lldb/Expression/DWARFExpression.h | 1 +
lldb/source/Core/Disassembler.cpp | 33 +--
lldb/source/Expression/DWARFExpression.cpp | 13 +-
.../rich-disassembler/TestRichDisassembler.py | 260 +-----------------
.../a_loop_with_local_variable.c | 8 -
.../b_multiple_stack_variables.c | 9 -
.../c_variable_passed_to_another_function.c | 11 -
.../rich-disassembler/e_control_flow_edge.c | 10 -
llvm/include/llvm/DebugInfo/DIContext.h | 1 +
llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp | 118 ++++----
10 files changed, 84 insertions(+), 380 deletions(-)
delete mode 100644
lldb/test/API/functionalities/rich-disassembler/a_loop_with_local_variable.c
delete mode 100644
lldb/test/API/functionalities/rich-disassembler/b_multiple_stack_variables.c
delete mode 100644
lldb/test/API/functionalities/rich-disassembler/c_variable_passed_to_another_function.c
delete mode 100644
lldb/test/API/functionalities/rich-disassembler/e_control_flow_edge.c
diff --git a/lldb/include/lldb/Expression/DWARFExpression.h
b/lldb/include/lldb/Expression/DWARFExpression.h
index 0adbe3e8df2ee..6eb421bc94e90 100644
--- a/lldb/include/lldb/Expression/DWARFExpression.h
+++ b/lldb/include/lldb/Expression/DWARFExpression.h
@@ -158,6 +158,7 @@ class DWARFExpression {
}
void DumpLocation(Stream *s, lldb::DescriptionLevel level, ABI *abi) const;
+ void DumpLocationWithOptions(Stream *s, lldb::DescriptionLevel level, ABI
*abi, llvm::DIDumpOptions options) const;
bool MatchesOperand(StackFrame &frame, const Instruction::Operand &op) const;
diff --git a/lldb/source/Core/Disassembler.cpp
b/lldb/source/Core/Disassembler.cpp
index 30a028d005dc1..683db0f541389 100644
--- a/lldb/source/Core/Disassembler.cpp
+++ b/lldb/source/Core/Disassembler.cpp
@@ -742,34 +742,19 @@ void Instruction::Dump(lldb_private::Stream *s, uint32_t
max_opcode_byte_size,
// Check if entry has a file_range, and filter on address if
so.
if (!entry.file_range || entry.file_range->ContainsFileAddress(
(current_pc - func_load_addr) +
expr_list.GetFuncFileAddress())) {
-
+
StreamString loc_str;
ABI *abi = exe_ctx->GetProcessPtr()->GetABI().get();
- entry.expr->DumpLocation(&loc_str, eDescriptionLevelBrief,
abi);
-
- std::string loc_output = loc_str.GetString().str();
-
- llvm::SmallVector<llvm::StringRef, 4> parts;
- llvm::StringRef(loc_str.GetString()).split(parts, ", ");
+ llvm::DIDumpOptions opts;
+ opts.ShowAddresses = false;
+ opts.PrintRegisterOnly = true; // <-- important: suppress
DW_OP_... annotations, etc.
- // Reconstruct the string without the decoding error chunks
- std::string cleaned_output;
- bool first = true;
-
- for (const auto &part : parts) {
- if (part.contains("<decoding error>"))
- continue;
-
- if (!first)
- cleaned_output += ", ";
- cleaned_output += part.str();
- first = false;
- }
+ entry.expr->DumpLocationWithOptions(&loc_str,
eDescriptionLevelBrief, abi, opts);
- // Only keep this annotation if there is still something
useful left.
- llvm::StringRef cleaned_ref =
llvm::StringRef(cleaned_output).trim();
- if (!cleaned_ref.empty()) {
- annotations.push_back(llvm::formatv("{0} = {1}", name,
cleaned_ref));
+ // Only include if not empty
+ llvm::StringRef loc_clean =
llvm::StringRef(loc_str.GetString()).trim();
+ if (!loc_clean.empty()) {
+ annotations.push_back(llvm::formatv("{0} = {1}", name,
loc_clean));
}
}
}
diff --git a/lldb/source/Expression/DWARFExpression.cpp
b/lldb/source/Expression/DWARFExpression.cpp
index 4b2b111e08e6d..d0d4278c98ae5 100644
--- a/lldb/source/Expression/DWARFExpression.cpp
+++ b/lldb/source/Expression/DWARFExpression.cpp
@@ -67,6 +67,12 @@ void DWARFExpression::UpdateValue(uint64_t const_value,
void DWARFExpression::DumpLocation(Stream *s, lldb::DescriptionLevel level,
ABI *abi) const {
+ llvm::DIDumpOptions DumpOpts;
+ this->DumpLocationWithOptions(s, level, abi, DumpOpts);
+}
+
+void DWARFExpression::DumpLocationWithOptions(Stream *s,
lldb::DescriptionLevel level,
+ ABI *abi, llvm::DIDumpOptions options)
const {
auto *MCRegInfo = abi ? &abi->GetMCRegisterInfo() : nullptr;
auto GetRegName = [&MCRegInfo](uint64_t DwarfRegNum,
bool IsEH) -> llvm::StringRef {
@@ -78,10 +84,9 @@ void DWARFExpression::DumpLocation(Stream *s,
lldb::DescriptionLevel level,
return llvm::StringRef(RegName);
return {};
};
- llvm::DIDumpOptions DumpOpts;
- DumpOpts.GetNameForDWARFReg = GetRegName;
- llvm::DWARFExpression(m_data.GetAsLLVM(), m_data.GetAddressByteSize())
- .print(s->AsRawOstream(), DumpOpts, nullptr);
+ options.GetNameForDWARFReg = GetRegName;
+ llvm::DWARFExpression expression (m_data.GetAsLLVM(),
m_data.GetAddressByteSize());
+ expression.print(s->AsRawOstream(), options, nullptr);
}
RegisterKind DWARFExpression::GetRegisterKind() const { return m_reg_kind; }
diff --git
a/lldb/test/API/functionalities/rich-disassembler/TestRichDisassembler.py
b/lldb/test/API/functionalities/rich-disassembler/TestRichDisassembler.py
index d85e6488575b7..0164402dfa587 100644
--- a/lldb/test/API/functionalities/rich-disassembler/TestRichDisassembler.py
+++ b/lldb/test/API/functionalities/rich-disassembler/TestRichDisassembler.py
@@ -2,202 +2,6 @@
from lldbsuite.test.decorators import *
class TestRichDisassembler(TestBase):
-
- @no_debug_info_test
- def test_a_loop_with_local_variable(self):
- """
- Tests that the disassembler includes basic DWARF variable annotation
in output.
- Specifically checks that local variables in a loop are shown with
DW_OP locations.
- Additionally, it verifies that the disassembly does not contain
decoding errors.
- """
- self.build(dictionary={
- 'C_SOURCES': 'a_loop_with_local_variable.c',
- 'CFLAGS_EXTRAS': '-g -O0'
- })
- exe = self.getBuildArtifact("a.out")
- target = self.dbg.CreateTarget(exe)
- self.assertTrue(target)
-
- # Set a breakpoint inside main's loop
- src_file = lldb.SBFileSpec("test_loop_function_call.c")
- breakpoint = target.BreakpointCreateByName("main")
- self.assertGreater(breakpoint.GetNumLocations(), 0)
-
- process = target.LaunchSimple(None, None,
self.get_process_working_directory())
- self.assertTrue(process, "Failed to launch process")
- self.assertEqual(process.GetState(), lldb.eStateStopped)
-
- frame = process.GetSelectedThread().GetSelectedFrame()
- disasm = frame.Disassemble()
- print(disasm)
-
- # Check that we have DWARF annotations for variables
- self.assertIn("i = ", disasm)
- self.assertIn("DW_OP", disasm)
- self.assertNotIn("<decoding error>", disasm)
-
-
- @no_debug_info_test
- def test_b_multiple_stack_variables_O0(self):
- """
- Tests disassembler output for b_multiple_stack_variables.c built with
-O0.
- This test checks that multiple local variables are annotated with DWARF
- and that their locations are distinct. It also ensures that no
decoding errors appear.
- """
- self.build(dictionary={
- 'C_SOURCES': 'b_multiple_stack_variables.c',
- 'CFLAGS_EXTRAS': '-g -O0'
- })
- exe = self.getBuildArtifact("a.out")
- target = self.dbg.CreateTarget(exe)
- self.assertTrue(target)
-
- # Set a breakpoint inside main's loop
- src_file = lldb.SBFileSpec("test_loop_function_call.c")
- breakpoint = target.BreakpointCreateByName("main")
- self.assertGreater(breakpoint.GetNumLocations(), 0)
-
- process = target.LaunchSimple(None, None,
self.get_process_working_directory())
- self.assertTrue(process, "Failed to launch process")
- self.assertEqual(process.GetState(), lldb.eStateStopped)
-
- frame = process.GetSelectedThread().GetSelectedFrame()
- disasm = frame.Disassemble()
- print(disasm)
-
- # Check that we have DWARF annotations for variables
- self.assertIn("a = ", disasm)
- self.assertIn("b = ", disasm)
- self.assertIn("c = ", disasm)
- self.assertIn("DW_OP", disasm)
- self.assertNotIn("<decoding error>", disasm)
-
-
- @no_debug_info_test
- def test_b_multiple_stack_variables_O1(self):
- """
- Tests disassembler output for b_multiple_stack_variables.c built with
-O1.
- Due to optimizations, some variables may be optimized out.
- We only check for 'c' and ensure no decoding errors appear.
- """
- self.build(dictionary={
- 'C_SOURCES': 'b_multiple_stack_variables.c',
- 'CFLAGS_EXTRAS': '-g -O1'
- })
- exe = self.getBuildArtifact("a.out")
- target = self.dbg.CreateTarget(exe)
- self.assertTrue(target)
-
- breakpoint = target.BreakpointCreateByName("main")
- self.assertGreater(breakpoint.GetNumLocations(), 0)
-
- process = target.LaunchSimple(None, None,
self.get_process_working_directory())
- self.assertTrue(process, "Failed to launch process")
- self.assertEqual(process.GetState(), lldb.eStateStopped)
-
- frame = process.GetSelectedThread().GetSelectedFrame()
- disasm = frame.Disassemble()
- print(disasm)
-
- self.assertIn("c = ", disasm)
- self.assertIn("DW_OP", disasm)
- self.assertNotIn("<decoding error>", disasm)
-
-
- @no_debug_info_test
- def test_c_variable_passed_to_another_function(self):
- """
- Tests disassembler output for c_variable_passed_to_another_function.c.
- This test checks that a variable passed to another function is
annotated
- with DWARF and that its location is distinct. It also ensures that no
decoding errors appear.
- """
- self.build(dictionary={
- 'C_SOURCES': 'c_variable_passed_to_another_function.c',
- 'CFLAGS_EXTRAS': '-g -O0'
- })
- exe = self.getBuildArtifact("a.out")
- target = self.dbg.CreateTarget(exe)
- self.assertTrue(target)
-
- breakpoint = target.BreakpointCreateByName("main")
- self.assertGreater(breakpoint.GetNumLocations(), 0)
-
- process = target.LaunchSimple(None, None,
self.get_process_working_directory())
- self.assertTrue(process, "Failed to launch process")
- self.assertEqual(process.GetState(), lldb.eStateStopped)
-
- frame = process.GetSelectedThread().GetSelectedFrame()
- disasm = frame.Disassemble()
- print(disasm)
-
- self.assertIn("x = ", disasm)
- self.assertIn("DW_OP", disasm)
- self.assertNotIn("<decoding error>", disasm)
-
-
- @no_debug_info_test
- def test_c_variable_passed_to_another_function_O1(self):
- """
- Tests disassembler output for c_variable_passed_to_another_function.c
built with -O1.
- """
- self.build(dictionary={
- 'C_SOURCES': 'c_variable_passed_to_another_function.c',
- 'CFLAGS_EXTRAS': '-g -O1'
- })
- exe = self.getBuildArtifact("a.out")
- target = self.dbg.CreateTarget(exe)
- self.assertTrue(target)
-
- breakpoint = target.BreakpointCreateByName("main")
- self.assertGreater(breakpoint.GetNumLocations(), 0)
-
- process = target.LaunchSimple(None, None,
self.get_process_working_directory())
- self.assertTrue(process, "Failed to launch process")
- self.assertEqual(process.GetState(), lldb.eStateStopped)
-
- frame = process.GetSelectedThread().GetSelectedFrame()
- disasm = frame.Disassemble()
- print(disasm)
-
- self.assertIn("x = ", disasm)
- self.assertIn("arg = ", disasm)
- self.assertIn("DW_OP", disasm)
- self.assertNotIn("<decoding error>", disasm)
-
- @no_debug_info_test
- def test_d_original_example(self):
- """
- Tests disassembler output for d_original_example.c.
- This test checks that the disassembly includes basic DWARF variable
annotations
- and that local variables in the main function are shown with DW_OP
locations.
- Additionally, it verifies that the disassembly does not contain
decoding errors.
- """
- self.build(dictionary={
- 'C_SOURCES': 'd_original_example.c',
- 'CFLAGS_EXTRAS': '-g -O0'
- })
- exe = self.getBuildArtifact("a.out")
- target = self.dbg.CreateTarget(exe)
- self.assertTrue(target)
-
- breakpoint = target.BreakpointCreateByName("main")
- self.assertGreater(breakpoint.GetNumLocations(), 0)
-
- process = target.LaunchSimple(None, None,
self.get_process_working_directory())
- self.assertTrue(process, "Failed to launch process")
- self.assertEqual(process.GetState(), lldb.eStateStopped)
-
- frame = process.GetSelectedThread().GetSelectedFrame()
- disasm = frame.Disassemble()
- print(disasm)
-
- self.assertIn("argc = ", disasm)
- self.assertIn("argv = ", disasm)
- self.assertIn("i = ", disasm)
- self.assertIn("DW_OP", disasm)
- self.assertNotIn("<decoding error>", disasm)
-
- @no_debug_info_test
def test_d_original_example_O1(self):
"""
Tests disassembler output for d_original_example.c built with -O1.
@@ -224,68 +28,8 @@ def test_d_original_example_O1(self):
self.assertIn("argc = ", disasm)
self.assertIn("argv = ", disasm)
self.assertIn("i = ", disasm)
- self.assertIn("DW_OP_reg", disasm)
- self.assertIn("DW_OP_stack_value", disasm)
- self.assertNotIn("<decoding error>", disasm)
-
-
- @no_debug_info_test
- def test_e_control_flow_edge(self):
- """
- Tests disassembler output for e_control_flow_edge.c with a focus on
control flow edges.
- This test checks that the disassembly includes basic DWARF variable
annotations
- and that local variables in the main function are shown with DW_OP
locations.
- Additionally, it verifies that the disassembly does not contain
decoding errors.
- """
- self.build(dictionary={
- 'C_SOURCES': 'e_control_flow_edge.c',
- 'CFLAGS_EXTRAS': '-g -O0'
- })
- exe = self.getBuildArtifact("a.out")
- target = self.dbg.CreateTarget(exe)
- self.assertTrue(target)
-
- breakpoint = target.BreakpointCreateByName("main")
- self.assertGreater(breakpoint.GetNumLocations(), 0)
-
- process = target.LaunchSimple(None, None,
self.get_process_working_directory())
- self.assertTrue(process, "Failed to launch process")
- self.assertEqual(process.GetState(), lldb.eStateStopped)
-
- frame = process.GetSelectedThread().GetSelectedFrame()
- disasm = frame.Disassemble()
- print(disasm)
-
- self.assertIn("a = ", disasm)
- self.assertIn("b = ", disasm)
- self.assertIn("DW_OP_", disasm)
- self.assertNotIn("<decoding error>", disasm)
-
- @no_debug_info_test
- def test_e_control_flow_edge_O1(self):
- """
- Tests disassembler output for e_control_flow_edge.c built with -O1.
- This test checks that the disassembly annotation does not contain
decoding errors.
- """
- self.build(dictionary={
- 'C_SOURCES': 'e_control_flow_edge.c',
- 'CFLAGS_EXTRAS': '-g -O1'
- })
- exe = self.getBuildArtifact("a.out")
- target = self.dbg.CreateTarget(exe)
- self.assertTrue(target)
-
- breakpoint = target.BreakpointCreateByName("main")
- self.assertGreater(breakpoint.GetNumLocations(), 0)
-
- process = target.LaunchSimple(None, None,
self.get_process_working_directory())
- self.assertTrue(process, "Failed to launch process")
- self.assertEqual(process.GetState(), lldb.eStateStopped)
-
- frame = process.GetSelectedThread().GetSelectedFrame()
- disasm = frame.Disassemble()
- print(disasm)
-
+ # self.assertIn("DW_OP_reg", disasm)
+ # self.assertIn("DW_OP_stack_value", disasm)
self.assertNotIn("<decoding error>", disasm)
diff --git
a/lldb/test/API/functionalities/rich-disassembler/a_loop_with_local_variable.c
b/lldb/test/API/functionalities/rich-disassembler/a_loop_with_local_variable.c
deleted file mode 100644
index 6555f3822187f..0000000000000
---
a/lldb/test/API/functionalities/rich-disassembler/a_loop_with_local_variable.c
+++ /dev/null
@@ -1,8 +0,0 @@
-#include <stdio.h>
-
-int main() {
- for (int i = 0; i < 3; ++i) {
- puts("Hi");
- }
- return 0;
-}
diff --git
a/lldb/test/API/functionalities/rich-disassembler/b_multiple_stack_variables.c
b/lldb/test/API/functionalities/rich-disassembler/b_multiple_stack_variables.c
deleted file mode 100644
index d3cd447b43d65..0000000000000
---
a/lldb/test/API/functionalities/rich-disassembler/b_multiple_stack_variables.c
+++ /dev/null
@@ -1,9 +0,0 @@
-#include <stdio.h>
-
-int main() {
- int a = 1;
- int b = 2;
- int c = a + b;
- return c;
-}
-
diff --git
a/lldb/test/API/functionalities/rich-disassembler/c_variable_passed_to_another_function.c
b/lldb/test/API/functionalities/rich-disassembler/c_variable_passed_to_another_function.c
deleted file mode 100644
index 9603bdc636043..0000000000000
---
a/lldb/test/API/functionalities/rich-disassembler/c_variable_passed_to_another_function.c
+++ /dev/null
@@ -1,11 +0,0 @@
-#include <stdio.h>
-
-void foo(int arg) {
- printf("%d\n", arg);
-}
-
-int main() {
- int x = 10;
- foo(x);
- return 0;
-}
diff --git
a/lldb/test/API/functionalities/rich-disassembler/e_control_flow_edge.c
b/lldb/test/API/functionalities/rich-disassembler/e_control_flow_edge.c
deleted file mode 100644
index d8d69f501eb4f..0000000000000
--- a/lldb/test/API/functionalities/rich-disassembler/e_control_flow_edge.c
+++ /dev/null
@@ -1,10 +0,0 @@
-#include <stdio.h>
-
-int main() {
- int a = 1;
- if (a > 0) {
- int b = 2;
- return b;
- }
- return a;
-}
diff --git a/llvm/include/llvm/DebugInfo/DIContext.h
b/llvm/include/llvm/DebugInfo/DIContext.h
index 0347f90c236d1..e7e87bbfebf38 100644
--- a/llvm/include/llvm/DebugInfo/DIContext.h
+++ b/llvm/include/llvm/DebugInfo/DIContext.h
@@ -209,6 +209,7 @@ struct DIDumpOptions {
bool IsEH = false;
bool DumpNonSkeleton = false;
bool ShowAggregateErrors = false;
+ bool PrintRegisterOnly = false;
std::string JsonErrSummaryFile;
std::function<llvm::StringRef(uint64_t DwarfRegNum, bool IsEH)>
GetNameForDWARFReg;
diff --git a/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp
b/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp
index 2ae5ff3efc8c5..fbf6fbf2cd368 100644
--- a/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp
+++ b/llvm/lib/DebugInfo/DWARF/DWARFExpression.cpp
@@ -302,14 +302,16 @@ std::optional<unsigned>
DWARFExpression::Operation::getSubCode() const {
bool DWARFExpression::Operation::print(raw_ostream &OS, DIDumpOptions DumpOpts,
const DWARFExpression *Expr,
DWARFUnit *U) const {
- if (Error) {
+ if (Error && !DumpOpts.PrintRegisterOnly) {
OS << "<decoding error>";
return false;
}
- StringRef Name = OperationEncodingString(Opcode);
- assert(!Name.empty() && "DW_OP has no name!");
- OS << Name;
+ if (!DumpOpts.PrintRegisterOnly) {
+ StringRef Name = OperationEncodingString(Opcode);
+ assert(!Name.empty() && "DW_OP has no name!");
+ OS << Name;
+ }
if ((Opcode >= DW_OP_breg0 && Opcode <= DW_OP_breg31) ||
(Opcode >= DW_OP_reg0 && Opcode <= DW_OP_reg31) ||
@@ -318,44 +320,46 @@ bool DWARFExpression::Operation::print(raw_ostream &OS,
DIDumpOptions DumpOpts,
if (prettyPrintRegisterOp(U, OS, DumpOpts, Opcode, Operands))
return true;
- for (unsigned Operand = 0; Operand < Desc.Op.size(); ++Operand) {
- unsigned Size = Desc.Op[Operand];
- unsigned Signed = Size & Operation::SignBit;
-
- if (Size == Operation::SizeSubOpLEB) {
- StringRef SubName = SubOperationEncodingString(Opcode,
Operands[Operand]);
- assert(!SubName.empty() && "DW_OP SubOp has no name!");
- OS << " " << SubName;
- } else if (Size == Operation::BaseTypeRef && U) {
- // For DW_OP_convert the operand may be 0 to indicate that conversion to
- // the generic type should be done. The same holds for DW_OP_reinterpret,
- // which is currently not supported.
- if (Opcode == DW_OP_convert && Operands[Operand] == 0)
- OS << " 0x0";
- else
- prettyPrintBaseTypeRef(U, OS, DumpOpts, Operands, Operand);
- } else if (Size == Operation::WasmLocationArg) {
- assert(Operand == 1);
- switch (Operands[0]) {
- case 0:
- case 1:
- case 2:
- case 3: // global as uint32
- case 4:
- OS << format(" 0x%" PRIx64, Operands[Operand]);
- break;
- default: assert(false);
+ if (!DumpOpts.PrintRegisterOnly) {
+ for (unsigned Operand = 0; Operand < Desc.Op.size(); ++Operand) {
+ unsigned Size = Desc.Op[Operand];
+ unsigned Signed = Size & Operation::SignBit;
+
+ if (Size == Operation::SizeSubOpLEB) {
+ StringRef SubName = SubOperationEncodingString(Opcode,
Operands[Operand]);
+ assert(!SubName.empty() && "DW_OP SubOp has no name!");
+ OS << " " << SubName;
+ } else if (Size == Operation::BaseTypeRef && U) {
+ // For DW_OP_convert the operand may be 0 to indicate that conversion
to
+ // the generic type should be done. The same holds for
DW_OP_reinterpret,
+ // which is currently not supported.
+ if (Opcode == DW_OP_convert && Operands[Operand] == 0)
+ OS << " 0x0";
+ else
+ prettyPrintBaseTypeRef(U, OS, DumpOpts, Operands, Operand);
+ } else if (Size == Operation::WasmLocationArg) {
+ assert(Operand == 1);
+ switch (Operands[0]) {
+ case 0:
+ case 1:
+ case 2:
+ case 3: // global as uint32
+ case 4:
+ OS << format(" 0x%" PRIx64, Operands[Operand]);
+ break;
+ default: assert(false);
+ }
+ } else if (Size == Operation::SizeBlock) {
+ uint64_t Offset = Operands[Operand];
+ for (unsigned i = 0; i < Operands[Operand - 1]; ++i)
+ OS << format(" 0x%02x", Expr->Data.getU8(&Offset));
+ } else {
+ if (Signed)
+ OS << format(" %+" PRId64, (int64_t)Operands[Operand]);
+ else if (Opcode != DW_OP_entry_value &&
+ Opcode != DW_OP_GNU_entry_value)
+ OS << format(" 0x%" PRIx64, Operands[Operand]);
}
- } else if (Size == Operation::SizeBlock) {
- uint64_t Offset = Operands[Operand];
- for (unsigned i = 0; i < Operands[Operand - 1]; ++i)
- OS << format(" 0x%02x", Expr->Data.getU8(&Offset));
- } else {
- if (Signed)
- OS << format(" %+" PRId64, (int64_t)Operands[Operand]);
- else if (Opcode != DW_OP_entry_value &&
- Opcode != DW_OP_GNU_entry_value)
- OS << format(" 0x%" PRIx64, Operands[Operand]);
}
}
return true;
@@ -370,29 +374,31 @@ void DWARFExpression::print(raw_ostream &OS,
DIDumpOptions DumpOpts,
for (auto &Op : *this) {
DumpOpts.IsEH = IsEH;
- if (!Op.print(OS, DumpOpts, this, U)) {
+ if (!Op.print(OS, DumpOpts, this, U) && !DumpOpts.PrintRegisterOnly) {
uint64_t FailOffset = Op.getEndOffset();
while (FailOffset < Data.getData().size())
OS << format(" %02x", Data.getU8(&FailOffset));
return;
}
- if (Op.getCode() == DW_OP_entry_value ||
- Op.getCode() == DW_OP_GNU_entry_value) {
- OS << "(";
- EntryValExprSize = Op.getRawOperand(0);
- EntryValStartOffset = Op.getEndOffset();
- continue;
- }
+ if (!DumpOpts.PrintRegisterOnly){
+ if (Op.getCode() == DW_OP_entry_value ||
+ Op.getCode() == DW_OP_GNU_entry_value) {
+ OS << "(";
+ EntryValExprSize = Op.getRawOperand(0);
+ EntryValStartOffset = Op.getEndOffset();
+ continue;
+ }
- if (EntryValExprSize) {
- EntryValExprSize -= Op.getEndOffset() - EntryValStartOffset;
- if (EntryValExprSize == 0)
- OS << ")";
+ if (EntryValExprSize) {
+ EntryValExprSize -= Op.getEndOffset() - EntryValStartOffset;
+ if (EntryValExprSize == 0)
+ OS << ")";
+ }
+
+ if (Op.getEndOffset() < Data.getData().size())
+ OS << ", ";
}
-
- if (Op.getEndOffset() < Data.getData().size())
- OS << ", ";
}
}
_______________________________________________
lldb-commits mailing list
lldb-commits@lists.llvm.org
https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
