[lldb] [disassembler] chore: enhance VariableAnnotator to return structured data: remove target and module from Annotate methods signature

Signed-off-by: Nikita B <[email protected]>

Author: n2h9

lldb/include/lldb/API/SBInstruction.h

@@ -89,7 +89,7 @@ class LLDB_API SBInstruction {
   /// - "decl_file": string path to the file where variable is declared
   /// - "decl_line": unsigned integer line number where variable is declared
   /// - "type_name": string type name of the variable
-  lldb::SBStructuredData GetVariableAnnotations(lldb::SBTarget target);
+  lldb::SBStructuredData GetVariableAnnotations();
 
 protected:
   friend class SBInstructionList;

lldb/include/lldb/Core/Disassembler.h

@@ -597,13 +597,10 @@ class VariableAnnotator {
 public:
   /// Compute annotation strings for a single instruction and update `Live_`.
   /// Returns only the events that should be printed *at this instruction*.
-  std::vector<std::string> Annotate(Instruction &inst, Target &target,
-                                    lldb::ModuleSP module_sp);
+  std::vector<std::string> Annotate(Instruction &inst);
 
   /// Returns structured data for all variables relevant at this instruction.
-  std::vector<VariableAnnotation> AnnotateStructured(Instruction &inst,
-                                                     Target &target,
-                                                     lldb::ModuleSP module_sp);
+  std::vector<VariableAnnotation> AnnotateStructured(Instruction &inst);
 };
 
 } // namespace lldb_private

lldb/source/API/SBInstruction.cpp

@@ -351,19 +351,16 @@ bool SBInstruction::TestEmulation(lldb::SBStream &output_stream,
   return false;
 }
 
-lldb::SBStructuredData
-SBInstruction::GetVariableAnnotations(lldb::SBTarget target) {
-  LLDB_INSTRUMENT_VA(this, target);
+lldb::SBStructuredData SBInstruction::GetVariableAnnotations() {
+  LLDB_INSTRUMENT_VA(this);
 
   SBStructuredData result;
 
-  if (!m_opaque_sp || !m_opaque_sp->IsValid() || !target.IsValid())
+  if (!m_opaque_sp || !m_opaque_sp->IsValid())
     return result;
 
   lldb::InstructionSP inst_sp = m_opaque_sp->GetSP();
-  lldb::TargetSP target_sp = target.GetSP();
-
-  if (!inst_sp || !target_sp)
+  if (!inst_sp)
     return result;
 
   const Address &addr = inst_sp->GetAddress();
@@ -374,7 +371,7 @@ SBInstruction::GetVariableAnnotations(lldb::SBTarget target) {
 
   VariableAnnotator annotator;
   std::vector<VariableAnnotation> annotations =
-      annotator.AnnotateStructured(*inst_sp, *target_sp, module_sp);
+      annotator.AnnotateStructured(*inst_sp);
 
   auto array_sp = std::make_shared<StructuredData::Array>();
 

lldb/source/Core/Disassembler.cpp

@@ -302,10 +302,8 @@ const std::string VariableAnnotator::kUndefLocationFormatted =
 // The goal is to give users helpful live variable hints alongside the
 // disassembled instruction stream, similar to how debug information
 // enhances source-level debugging.
-std::vector<std::string> VariableAnnotator::Annotate(Instruction &inst,
-                                                     Target &target,
-                                                     lldb::ModuleSP module_sp) {
-  auto structured_annotations = AnnotateStructured(inst, target, module_sp);
+std::vector<std::string> VariableAnnotator::Annotate(Instruction &inst) {
+  auto structured_annotations = AnnotateStructured(inst);
 
   std::vector<std::string> events;
   events.reserve(structured_annotations.size());
@@ -328,10 +326,11 @@ std::vector<std::string> VariableAnnotator::Annotate(Instruction &inst,
 }
 
 std::vector<VariableAnnotation>
-VariableAnnotator::AnnotateStructured(Instruction &inst, Target &target,
-                                      lldb::ModuleSP module_sp) {
+VariableAnnotator::AnnotateStructured(Instruction &inst) {
   std::vector<VariableAnnotation> annotations;
 
+  ModuleSP module_sp = inst.GetAddress().GetModule();
+
   // If we lost module context, mark all live variables as undefined.
   if (!module_sp) {
     for (const auto &KV : m_live_vars) {
@@ -377,7 +376,7 @@ VariableAnnotator::AnnotateStructured(Instruction &inst, Target &target,
   const lldb::addr_t func_file = sc.function->GetAddress().GetFileAddress();
 
   // ABI from Target (pretty reg names if plugin exists). Safe to be null.
-  lldb::ABISP abi_sp = ABI::FindPlugin(nullptr, target.GetArchitecture());
+  lldb::ABISP abi_sp = ABI::FindPlugin(nullptr, module_sp->GetArchitecture());
   ABI *abi = abi_sp.get();
 
   llvm::DIDumpOptions opts;
@@ -737,7 +736,7 @@ void Disassembler::PrintInstructions(Debugger &debugger, const ArchSpec &arch,
                  address_text_size);
 
       if ((options & eOptionVariableAnnotations) && target_sp) {
-        auto annotations = annot.Annotate(*inst, *target_sp, module_sp);
+        auto annotations = annot.Annotate(*inst);
         if (!annotations.empty()) {
           const size_t annotation_column = 100;
           inst_line.FillLastLineToColumn(annotation_column, ' ');

lldb/test/API/functionalities/disassembler-variables/TestVariableAnnotationsDisassembler.py

@@ -146,7 +146,7 @@ def test_structured_annotations_api(self):
             inst = instructions.GetInstructionAtIndex(i)
             self.assertTrue(inst.IsValid(), f"Invalid instruction at index {i}")
 
-            annotations = inst.GetVariableAnnotations(target)
+            annotations = inst.GetVariableAnnotations()
 
             self.assertIsInstance(annotations, lldb.SBStructuredData,
                                 "GetVariableAnnotations should return SBStructuredData")