add instructions_offset to breakppoint resolver

Author: eronnen

lldb/include/lldb/API/SBTarget.h

@@ -23,6 +23,7 @@
 #include "lldb/API/SBValue.h"
 #include "lldb/API/SBWatchpoint.h"
 #include "lldb/API/SBWatchpointOptions.h"
+#include "lldb/lldb-types.h"
 
 namespace lldb_private {
 namespace python {
@@ -738,7 +739,7 @@ class LLDB_API SBTarget {
   lldb::SBBreakpoint BreakpointCreateBySBAddress(SBAddress &address);
 
   lldb::SBBreakpoint BreakpointCreateByFileAddress(const SBFileSpec &file_spec,
-                                                   addr_t file_addr);
+                                                   addr_t file_addr, addr_t offset = 0, addr_t instructions_offset = 0);
 
   /// Create a breakpoint using a scripted resolver.
   ///

lldb/include/lldb/Breakpoint/BreakpointResolver.h

@@ -16,6 +16,7 @@
 #include "lldb/Utility/FileSpec.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/lldb-private.h"
+#include "lldb/lldb-types.h"
 #include <optional>
 
 namespace lldb_private {
@@ -47,7 +48,8 @@ class BreakpointResolver : public Searcher {
   ///   The concrete breakpoint resolver type for this breakpoint.
   BreakpointResolver(const lldb::BreakpointSP &bkpt,
                      unsigned char resolverType,
-                     lldb::addr_t offset = 0);
+                     lldb::addr_t offset = 0,
+                     lldb::addr_t instructions_offset = 0);
 
   /// The Destructor is virtual, all significant breakpoint resolvers derive
   /// from this class.
@@ -182,6 +184,7 @@ class BreakpointResolver : public Searcher {
     SearchDepth,
     SkipPrologue,
     SymbolNameArray,
+    InstructionsOffset,
     LastOptionName
   };
   static const char
@@ -220,6 +223,7 @@ class BreakpointResolver : public Searcher {
   lldb::BreakpointWP m_breakpoint; // This is the breakpoint we add locations to.
   lldb::addr_t m_offset;    // A random offset the user asked us to add to any
                             // breakpoints we set.
+  lldb::addr_t m_instructions_offset; // Number of instructions to add to the resolved breakpoint address.
 
   // Subclass identifier (for llvm isa/dyn_cast)
   const unsigned char SubclassID;

lldb/include/lldb/Breakpoint/BreakpointResolverAddress.h

@@ -28,6 +28,12 @@ class BreakpointResolverAddress : public BreakpointResolver {
                             const Address &addr,
                             const FileSpec &module_spec);
 
+  BreakpointResolverAddress(const lldb::BreakpointSP &bkpt,
+                            const Address &addr,
+                            const FileSpec &module_spec,
+                            lldb::addr_t offset,
+                            lldb::addr_t instructions_offset);
+
   ~BreakpointResolverAddress() override = default;
 
   static lldb::BreakpointResolverSP

lldb/include/lldb/Core/Disassembler.h

@@ -291,6 +291,8 @@ class InstructionList {
 
   size_t GetSize() const;
 
+  size_t GetTotalByteSize() const;
+
   uint32_t GetMaxOpcocdeByteSize() const;
 
   lldb::InstructionSP GetInstructionAtIndex(size_t idx) const;

lldb/include/lldb/Target/Target.h

@@ -18,6 +18,7 @@
 #include "lldb/Breakpoint/BreakpointList.h"
 #include "lldb/Breakpoint/BreakpointName.h"
 #include "lldb/Breakpoint/WatchpointList.h"
+#include "lldb/Core/Address.h"
 #include "lldb/Core/Architecture.h"
 #include "lldb/Core/Disassembler.h"
 #include "lldb/Core/ModuleList.h"
@@ -727,7 +728,9 @@ class Target : public std::enable_shared_from_this<Target>,
   lldb::BreakpointSP CreateAddressInModuleBreakpoint(lldb::addr_t file_addr,
                                                      bool internal,
                                                      const FileSpec &file_spec,
-                                                     bool request_hardware);
+                                                     bool request_hardware,
+                                                     lldb::addr_t offset = 0,
+                                                     lldb::addr_t instructions_offset = 0);
 
   // Use this to create Address breakpoints:
   lldb::BreakpointSP CreateBreakpoint(const Address &addr, bool internal,
@@ -1328,6 +1331,10 @@ class Target : public std::enable_shared_from_this<Target>,
                                const lldb_private::RegisterFlags &flags,
                                uint32_t byte_size);
 
+  lldb::DisassemblerSP ReadInstructions(const Address &start_addr,
+                                        uint32_t count,
+                                        const char *flavor_string = nullptr);
+
   // Target Stop Hooks
   class StopHook : public UserID {
   public:

lldb/source/API/SBTarget.cpp

@@ -950,14 +950,14 @@ SBBreakpoint SBTarget::BreakpointCreateBySBAddress(SBAddress &sb_address) {
   return sb_bp;
 }
 
-SBBreakpoint SBTarget::BreakpointCreateByFileAddress(const SBFileSpec &file_spec, addr_t file_addr) {
+SBBreakpoint SBTarget::BreakpointCreateByFileAddress(const SBFileSpec &file_spec, addr_t file_addr, addr_t offset, addr_t instructions_offset) {
   LLDB_INSTRUMENT_VA(this, file_spec, file_addr);
 
   SBBreakpoint sb_bp;
   if (TargetSP target_sp = GetSP()) {
     std::lock_guard<std::recursive_mutex> guard(target_sp->GetAPIMutex());
     const bool hardware = false;
-    sb_bp = target_sp->CreateAddressInModuleBreakpoint(file_addr, false, *file_spec.get(), hardware);
+    sb_bp = target_sp->CreateAddressInModuleBreakpoint(file_addr, false, *file_spec.get(), hardware, offset, instructions_offset);
   }
 
   return sb_bp;
@@ -1969,29 +1969,8 @@ lldb::SBInstructionList SBTarget::ReadInstructions(lldb::SBAddress base_addr,
 
   if (TargetSP target_sp = GetSP()) {
     if (Address *addr_ptr = base_addr.get()) {
-      DataBufferHeap data(
-          target_sp->GetArchitecture().GetMaximumOpcodeByteSize() * count, 0);
-      bool force_live_memory = true;
-      lldb_private::Status error;
-      lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
-      const size_t bytes_read =
-          target_sp->ReadMemory(*addr_ptr, data.GetBytes(), data.GetByteSize(),
-                                error, force_live_memory, &load_addr);
-
-      const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
-      if (!flavor_string || flavor_string[0] == '\0') {
-        // FIXME - we don't have the mechanism in place to do per-architecture
-        // settings.  But since we know that for now we only support flavors on
-        // x86 & x86_64,
-        const llvm::Triple::ArchType arch =
-            target_sp->GetArchitecture().GetTriple().getArch();
-        if (arch == llvm::Triple::x86 || arch == llvm::Triple::x86_64)
-          flavor_string = target_sp->GetDisassemblyFlavor();
-      }
-      sb_instructions.SetDisassembler(Disassembler::DisassembleBytes(
-          target_sp->GetArchitecture(), nullptr, flavor_string,
-          target_sp->GetDisassemblyCPU(), target_sp->GetDisassemblyFeatures(),
-          *addr_ptr, data.GetBytes(), bytes_read, count, data_from_file));
+      sb_instructions.SetDisassembler(target_sp->ReadInstructions(
+          *addr_ptr, count, flavor_string));
     }
   }
 

lldb/source/Breakpoint/BreakpointResolver.cpp

@@ -29,6 +29,7 @@
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
+#include "lldb/lldb-forward.h"
 #include <optional>
 
 using namespace lldb_private;
@@ -45,7 +46,7 @@ const char *BreakpointResolver::g_option_names[static_cast<uint32_t>(
     "AddressOffset", "Exact",     "FileName",     "Inlines",     "Language",
     "LineNumber",    "Column",    "ModuleName",   "NameMask",    "Offset",
     "PythonClass",   "Regex",     "ScriptArgs",   "SectionName", "SearchDepth",
-    "SkipPrologue",  "SymbolNames"};
+    "SkipPrologue",  "SymbolNames", "InstructionsOffset"};
 
 const char *BreakpointResolver::ResolverTyToName(enum ResolverTy type) {
   if (type > LastKnownResolverType)
@@ -65,8 +66,9 @@ BreakpointResolver::NameToResolverTy(llvm::StringRef name) {
 
 BreakpointResolver::BreakpointResolver(const BreakpointSP &bkpt,
                                        const unsigned char resolverTy,
-                                       lldb::addr_t offset)
-    : m_breakpoint(bkpt), m_offset(offset), SubclassID(resolverTy) {}
+                                       lldb::addr_t offset,
+                                       lldb::addr_t instructions_offset)
+    : m_breakpoint(bkpt), m_offset(offset), m_instructions_offset(instructions_offset), SubclassID(resolverTy) {}
 
 BreakpointResolver::~BreakpointResolver() = default;
 
@@ -364,6 +366,12 @@ void BreakpointResolver::AddLocation(SearchFilter &filter,
 
 BreakpointLocationSP BreakpointResolver::AddLocation(Address loc_addr,
                                                      bool *new_location) {
+  if (m_instructions_offset != 0) {
+    Target &target = GetBreakpoint()->GetTarget();
+    const DisassemblerSP instructions = target.ReadInstructions(loc_addr, m_instructions_offset);
+    loc_addr.Slide(instructions->GetInstructionList().GetTotalByteSize());
+  }
+
   loc_addr.Slide(m_offset);
   return GetBreakpoint()->AddLocation(loc_addr, new_location);
 }

lldb/source/Breakpoint/BreakpointResolverAddress.cpp

@@ -30,6 +30,12 @@ BreakpointResolverAddress::BreakpointResolverAddress(const BreakpointSP &bkpt,
     : BreakpointResolver(bkpt, BreakpointResolver::AddressResolver),
       m_addr(addr), m_resolved_addr(LLDB_INVALID_ADDRESS) {}
 
+BreakpointResolverAddress::BreakpointResolverAddress(
+    const BreakpointSP &bkpt, const Address &addr, const FileSpec &module_spec, lldb::addr_t offset, lldb::addr_t instructions_offset)
+    : BreakpointResolver(bkpt, BreakpointResolver::AddressResolver, offset, instructions_offset),
+      m_addr(addr), m_resolved_addr(LLDB_INVALID_ADDRESS),
+      m_module_filespec(module_spec) {}
+
 BreakpointResolverSP BreakpointResolverAddress::CreateFromStructuredData(
     const StructuredData::Dictionary &options_dict, Status &error) {
   llvm::StringRef module_name;

lldb/source/Core/Disassembler.cpp

@@ -1016,6 +1016,16 @@ uint32_t InstructionList::GetMaxOpcocdeByteSize() const {
   return max_inst_size;
 }
 
+size_t InstructionList::GetTotalByteSize() const {
+  size_t total_byte_size = 0;
+  collection::const_iterator pos, end;
+  for (pos = m_instructions.begin(), end = m_instructions.end(); pos != end;
+       ++pos) {
+    total_byte_size += (*pos)->GetOpcode().GetByteSize();
+  }
+  return total_byte_size;
+}
+
 InstructionSP InstructionList::GetInstructionAtIndex(size_t idx) const {
   InstructionSP inst_sp;
   if (idx < m_instructions.size())

lldb/source/Target/Target.cpp

@@ -65,6 +65,7 @@
 #include "lldb/Utility/State.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/Utility/Timer.h"
+#include "lldb/lldb-forward.h"
 
 #include "llvm/ADT/ScopeExit.h"
 #include "llvm/ADT/SetVector.h"
@@ -567,11 +568,13 @@ BreakpointSP Target::CreateBreakpoint(const Address &addr, bool internal,
 lldb::BreakpointSP
 Target::CreateAddressInModuleBreakpoint(lldb::addr_t file_addr, bool internal,
                                         const FileSpec &file_spec,
-                                        bool request_hardware) {
+                                        bool request_hardware,
+                                        lldb::addr_t offset,
+                                        lldb::addr_t instructions_offset) {
   SearchFilterSP filter_sp(
       new SearchFilterForUnconstrainedSearches(shared_from_this()));
   BreakpointResolverSP resolver_sp(new BreakpointResolverAddress(
-      nullptr, file_addr, file_spec));
+      nullptr, file_addr, file_spec, offset, instructions_offset));
   return CreateBreakpoint(filter_sp, resolver_sp, internal, request_hardware,
                           false);
 }
@@ -2990,6 +2993,35 @@ lldb::addr_t Target::GetBreakableLoadAddress(lldb::addr_t addr) {
   return arch_plugin ? arch_plugin->GetBreakableLoadAddress(addr, *this) : addr;
 }
 
+lldb::DisassemblerSP Target::ReadInstructions(const Address &start_addr, uint32_t count,
+                                             const char *flavor_string) {
+  if (!m_process_sp)
+    return lldb::DisassemblerSP();
+
+  DataBufferHeap data(GetArchitecture().GetMaximumOpcodeByteSize() * count, 0);
+  bool force_live_memory = true;
+  lldb_private::Status error;
+  lldb::addr_t load_addr = LLDB_INVALID_ADDRESS;
+  const size_t bytes_read = ReadMemory(start_addr, data.GetBytes(), data.GetByteSize(),
+                            error, force_live_memory, &load_addr);
+
+  const bool data_from_file = load_addr == LLDB_INVALID_ADDRESS;
+  if (!flavor_string || flavor_string[0] == '\0') {
+    // FIXME - we don't have the mechanism in place to do per-architecture
+    // settings.  But since we know that for now we only support flavors on
+    // x86 & x86_64,
+    const llvm::Triple::ArchType arch =
+      GetArchitecture().GetTriple().getArch();
+    if (arch == llvm::Triple::x86 || arch == llvm::Triple::x86_64)
+      flavor_string = GetDisassemblyFlavor();
+  }
+
+  return Disassembler::DisassembleBytes(
+    GetArchitecture(), nullptr, flavor_string,
+    GetDisassemblyCPU(), GetDisassemblyFeatures(),
+    start_addr, data.GetBytes(), bytes_read, count, data_from_file);
+}
+
 SourceManager &Target::GetSourceManager() {
   if (!m_source_manager_up)
     m_source_manager_up = std::make_unique<SourceManager>(shared_from_this());