Add PrintRegisterOnly flag in struct DIDumpOptions and created new DWARFExpression::DumpLocationWithOptions for simplified expression printing

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.

Author: UltimateForce21

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;
 

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));
                   }
                 }
               }

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; }

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)