apply source mapping when getting line entry from an address

Author: eronnen

lldb/include/lldb/API/SBAddress.h

@@ -11,6 +11,7 @@
 
 #include "lldb/API/SBDefines.h"
 #include "lldb/API/SBModule.h"
+#include "lldb/API/SBTarget.h"
 
 namespace lldb {
 
@@ -58,6 +59,9 @@ class LLDB_API SBAddress {
   // "lldb::SBAddress SBTarget::ResolveLoadAddress (...)".
   lldb::SBSymbolContext GetSymbolContext(uint32_t resolve_scope);
 
+  lldb::SBSymbolContext GetSymbolContext(const SBTarget &target,
+                                         uint32_t resolve_scope);
+
   // The following functions grab individual objects for a given address and
   // are less efficient if you want more than one symbol related objects. Use
   // one of the following when you want multiple debug symbol related objects
@@ -122,6 +126,9 @@ class LLDB_API SBAddress {
 
   void SetAddress(const lldb_private::Address &address);
 
+  void CalculateSymbolContext(lldb_private::SymbolContext &sc,
+                              uint32_t resolve_scope);
+
 private:
   std::unique_ptr<lldb_private::Address> m_opaque_up;
 };

lldb/source/API/SBAddress.cpp

@@ -213,9 +213,18 @@ SBSymbolContext SBAddress::GetSymbolContext(uint32_t resolve_scope) {
   LLDB_INSTRUMENT_VA(this, resolve_scope);
 
   SBSymbolContext sb_sc;
-  SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
-  if (m_opaque_up->IsValid())
-    m_opaque_up->CalculateSymbolContext(&sb_sc.ref(), scope);
+  CalculateSymbolContext(sb_sc.ref(), resolve_scope);
+  return sb_sc;
+}
+
+SBSymbolContext SBAddress::GetSymbolContext(const SBTarget &target,
+                                            uint32_t resolve_scope) {
+  LLDB_INSTRUMENT_VA(this, target, resolve_scope);
+
+  SBSymbolContext sb_sc;
+  lldb_private::SymbolContext &sc = sb_sc.ref();
+  sc.target_sp = target.GetSP();
+  CalculateSymbolContext(sc, resolve_scope);
   return sb_sc;
 }
 
@@ -266,3 +275,10 @@ SBLineEntry SBAddress::GetLineEntry() {
   }
   return sb_line_entry;
 }
+
+void SBAddress::CalculateSymbolContext(lldb_private::SymbolContext &sc,
+                                       uint32_t resolve_scope) {
+  SymbolContextItem scope = static_cast<SymbolContextItem>(resolve_scope);
+  if (m_opaque_up->IsValid())
+    m_opaque_up->CalculateSymbolContext(&sc, scope);
+}

lldb/source/Core/Module.cpp

@@ -483,6 +483,9 @@ uint32_t Module::ResolveSymbolContextForAddress(
       symfile->SetLoadDebugInfoEnabled();
       resolved_flags |=
           symfile->ResolveSymbolContext(so_addr, resolve_scope, sc);
+
+      if ((resolve_scope & eSymbolContextLineEntry) && sc.line_entry.IsValid())
+        sc.line_entry.ApplyFileMappings(sc.target_sp);
     }
 
     // Resolve the symbol if requested, but don't re-look it up if we've

lldb/tools/lldb-dap/Breakpoint.cpp

@@ -64,7 +64,7 @@ protocol::Breakpoint Breakpoint::ToProtocolBreakpoint() {
         "0x" + llvm::utohexstr(bp_addr.GetLoadAddress(m_bp.GetTarget()));
     breakpoint.instructionReference = formatted_addr;
 
-    auto source = CreateSource(bp_addr, m_dap.debugger);
+    auto source = CreateSource(bp_addr, m_dap.target);
     if (!source.IsAssemblySource()) {
       auto line_entry = bp_addr.GetLineEntry();
       const auto line = line_entry.GetLine();

lldb/tools/lldb-dap/Handler/DisassembleRequestHandler.cpp

@@ -9,11 +9,11 @@
 #include "DAP.h"
 #include "EventHelper.h"
 #include "JSONUtils.h"
+#include "LLDBUtils.h"
 #include "Protocol/ProtocolRequests.h"
 #include "Protocol/ProtocolTypes.h"
 #include "RequestHandler.h"
 #include "lldb/API/SBAddress.h"
-#include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBInstruction.h"
 #include "lldb/API/SBTarget.h"
 #include "lldb/lldb-types.h"
@@ -82,15 +82,12 @@ static lldb::SBAddress GetDisassembleStartAddress(lldb::SBTarget target,
       .GetAddress();
 }
 
-static DisassembledInstruction
-ConvertSBInstructionToDisassembledInstruction(lldb::SBDebugger &debugger,
-                                              lldb::SBInstruction &inst,
-                                              bool resolve_symbols) {
+static DisassembledInstruction ConvertSBInstructionToDisassembledInstruction(
+    lldb::SBTarget &target, lldb::SBInstruction &inst, bool resolve_symbols) {
   if (!inst.IsValid())
     return GetInvalidInstruction();
 
-  lldb::SBTarget target = debugger.GetSelectedTarget();
-  lldb::SBAddress addr = inst.GetAddress();
+  auto addr = inst.GetAddress();
   const auto inst_addr = addr.GetLoadAddress(target);
 
   // FIXME: This is a workaround - this address might come from
@@ -143,9 +140,11 @@ ConvertSBInstructionToDisassembledInstruction(lldb::SBDebugger &debugger,
 
   disassembled_inst.instruction = std::move(instruction);
 
-  auto source = CreateSource(addr, debugger);
-  auto line_entry = addr.GetLineEntry();
+  auto source = CreateSource(addr, target);
+  auto line_entry = GetLineEntryForAddress(target, addr);
 
+  // If the line number is 0 then the entry represents a compiler generated
+  // location.
   if (!source.IsAssemblySource() && line_entry.IsValid() &&
       line_entry.GetStartAddress() == addr && line_entry.IsValid() &&
       line_entry.GetFileSpec().IsValid() && line_entry.GetLine() != 0) {
@@ -159,7 +158,8 @@ ConvertSBInstructionToDisassembledInstruction(lldb::SBDebugger &debugger,
     if (column != 0 && column != LLDB_INVALID_COLUMN_NUMBER)
       disassembled_inst.column = column;
 
-    auto end_line_entry = line_entry.GetEndAddress().GetLineEntry();
+    lldb::SBAddress end_addr = line_entry.GetEndAddress();
+    auto end_line_entry = GetLineEntryForAddress(target, end_addr);
     if (end_line_entry.IsValid() &&
         end_line_entry.GetFileSpec() == line_entry.GetFileSpec()) {
       const auto end_line = end_line_entry.GetLine();
@@ -238,7 +238,7 @@ DisassembleRequestHandler::Run(const DisassembleArguments &args) const {
       original_address_index = i;
 
     instructions.push_back(ConvertSBInstructionToDisassembledInstruction(
-        dap.debugger, inst, resolve_symbols));
+        dap.target, inst, resolve_symbols));
   }
 
   // Check if we miss instructions at the beginning.

lldb/tools/lldb-dap/Handler/LocationsRequestHandler.cpp

@@ -9,6 +9,7 @@
 #include "DAP.h"
 #include "EventHelper.h"
 #include "JSONUtils.h"
+#include "LLDBUtils.h"
 #include "RequestHandler.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBDeclaration.h"
@@ -126,7 +127,7 @@ void LocationsRequestHandler::operator()(
 
     lldb::addr_t raw_addr = variable.GetValueAsAddress();
     lldb::SBAddress addr = dap.target.ResolveLoadAddress(raw_addr);
-    lldb::SBLineEntry line_entry = addr.GetLineEntry();
+    lldb::SBLineEntry line_entry = GetLineEntryForAddress(dap.target, addr);
 
     if (!line_entry.IsValid()) {
       response["success"] = false;
@@ -135,7 +136,7 @@ void LocationsRequestHandler::operator()(
       return;
     }
 
-    body.try_emplace("source", CreateSource(addr, dap.debugger));
+    body.try_emplace("source", CreateSource(line_entry.GetFileSpec()));
     if (int line = line_entry.GetLine())
       body.try_emplace("line", line);
     if (int column = line_entry.GetColumn())

lldb/tools/lldb-dap/Handler/StackTraceRequestHandler.cpp

@@ -69,8 +69,7 @@ static bool FillStackFrames(DAP &dap, lldb::SBThread &thread,
       break;
     }
 
-    stack_frames.emplace_back(
-        CreateStackFrame(frame, frame_format, dap.debugger));
+    stack_frames.emplace_back(CreateStackFrame(frame, frame_format));
   }
 
   if (include_all && reached_end_of_stack) {

lldb/tools/lldb-dap/JSONUtils.cpp

@@ -12,6 +12,7 @@
 #include "LLDBUtils.h"
 #include "lldb/API/SBAddress.h"
 #include "lldb/API/SBCompileUnit.h"
+#include "lldb/API/SBDebugger.h"
 #include "lldb/API/SBDeclaration.h"
 #include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBError.h"
@@ -571,14 +572,16 @@ protocol::Source CreateSource(const lldb::SBFileSpec &file) {
   return source;
 }
 
-protocol::Source CreateSource(lldb::SBAddress address,
-                              lldb::SBDebugger &debugger) {
+protocol::Source CreateSource(lldb::SBAddress address, lldb::SBTarget &target) {
+  lldb::SBDebugger debugger = target.GetDebugger();
   lldb::StopDisassemblyType stop_disassembly_display =
       GetStopDisassemblyDisplay(debugger);
-  if (!ShouldDisplayAssemblySource(address, stop_disassembly_display))
-    return CreateSource(address.GetLineEntry().GetFileSpec());
+  if (!ShouldDisplayAssemblySource(address, stop_disassembly_display)) {
+    lldb::SBLineEntry line_entry = GetLineEntryForAddress(target, address);
+    return CreateSource(line_entry.GetFileSpec());
+  }
 
-  return CreateAssemblySource(debugger.GetSelectedTarget(), address);
+  return CreateAssemblySource(target, address);
 }
 
 protocol::Source CreateSource(llvm::StringRef source_path) {
@@ -650,8 +653,8 @@ protocol::Source CreateSource(llvm::StringRef source_path) {
 //   },
 //   "required": [ "id", "name", "line", "column" ]
 // }
-llvm::json::Value CreateStackFrame(lldb::SBFrame &frame, lldb::SBFormat &format,
-                                   lldb::SBDebugger &debugger) {
+llvm::json::Value CreateStackFrame(lldb::SBFrame &frame,
+                                   lldb::SBFormat &format) {
   llvm::json::Object object;
   int64_t frame_id = MakeDAPFrameID(frame);
   object.try_emplace("id", frame_id);
@@ -679,9 +682,10 @@ llvm::json::Value CreateStackFrame(lldb::SBFrame &frame, lldb::SBFormat &format,
 
   EmplaceSafeString(object, "name", frame_name);
 
-  auto source = CreateSource(frame.GetPCAddress(), debugger);
+  auto target = frame.GetThread().GetProcess().GetTarget();
+  auto source = CreateSource(frame.GetPCAddress(), target);
   if (!source.IsAssemblySource()) {
-    // This is a normal source with valid line entry.
+    // This is a normal source with a valid line entry.
     auto line_entry = frame.GetLineEntry();
     object.try_emplace("line", line_entry.GetLine());
     auto column = line_entry.GetColumn();

lldb/tools/lldb-dap/JSONUtils.h

@@ -255,14 +255,13 @@ protocol::Source CreateSource(const lldb::SBFileSpec &file);
 /// \param[in] address
 ///     The address to use when populating out the "Source" object.
 ///
-/// \param[in] debugger
-///     The debugger, used to get relevant settings.
+/// \param[in] target
+///     The target that has the address.
 ///
 /// \return
 ///     A "Source" JSON object that follows the formal JSON
 ///     definition outlined by Microsoft.
-protocol::Source CreateSource(lldb::SBAddress address,
-                              lldb::SBDebugger &debugger);
+protocol::Source CreateSource(lldb::SBAddress address, lldb::SBTarget &target);
 
 /// Create a "Source" object for a given source path.
 ///
@@ -292,15 +291,11 @@ protocol::Source CreateSource(llvm::StringRef source_path);
 ///     The LLDB format to use when populating out the "StackFrame"
 ///     object.
 ///
-/// \param[in] debugger
-///     The LLDB debugger to use when populating out the "StackFrame"
-///     object.
-///
 /// \return
 ///     A "StackFrame" JSON object with that follows the formal JSON
 ///     definition outlined by Microsoft.
-llvm::json::Value CreateStackFrame(lldb::SBFrame &frame, lldb::SBFormat &format,
-                                   lldb::SBDebugger &debugger);
+llvm::json::Value CreateStackFrame(lldb::SBFrame &frame,
+                                   lldb::SBFormat &format);
 
 /// Create a "StackFrame" label object for a LLDB thread.
 ///

lldb/tools/lldb-dap/LLDBUtils.cpp

@@ -252,4 +252,11 @@ std::string GetSBFileSpecPath(const lldb::SBFileSpec &file_spec) {
   return path;
 }
 
+lldb::SBLineEntry GetLineEntryForAddress(lldb::SBTarget &target,
+                                         lldb::SBAddress &address) {
+  lldb::SBSymbolContext sc =
+      address.GetSymbolContext(target, lldb::eSymbolContextLineEntry);
+  return sc.GetLineEntry();
+}
+
 } // namespace lldb_dap

lldb/tools/lldb-dap/LLDBUtils.h

@@ -14,6 +14,8 @@
 #include "lldb/API/SBEnvironment.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBFileSpec.h"
+#include "lldb/API/SBLineEntry.h"
+#include "lldb/API/SBTarget.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Error.h"
@@ -171,6 +173,18 @@ GetEnvironmentFromArguments(const llvm::json::Object &arguments);
 ///     The file path as a string.
 std::string GetSBFileSpecPath(const lldb::SBFileSpec &file_spec);
 
+/// Gets the line entry for a given address.
+/// \param[in] target
+///     The target that has the address.
+///
+/// \param[in] address
+///     The address for which to get the line entry.
+///
+/// \return
+///     The line entry for the given address.
+lldb::SBLineEntry GetLineEntryForAddress(lldb::SBTarget &target,
+                                         lldb::SBAddress &address);
+
 /// Helper for sending telemetry to lldb server, if client-telemetry is enabled.
 class TelemetryDispatcher {
 public: