[ldb/Breakpoint] Recognize HW breakpoints as breakpoints instead of just mach exceptions.

[jasonmolenda]

Looks like a good change.

lldb/include/lldb/Breakpoint/BreakpointSite.h

public:
   const uint8_t *GetTrapOpcodeBytes() const;
 
   /// Get the size of the trap opcode for this address
   size_t GetTrapOpcodeMaxByteSize() const;
 
   /// Sets the trap opcode
   bool SetTrapOpcode(const uint8_t *trap_opcode, uint32_t trap_opcode_size);
 
+  void SetHardwareIndex(uint32_t index) override;
+
   /// Gets the original instruction bytes that were overwritten by the trap
   uint8_t *GetSavedOpcodeBytes();
 
   /// Gets the original instruction bytes that were overwritten by the trap
   /// const version
   const uint8_t *GetSavedOpcodeBytes() const;
 
   /// Says whether \a addr and size \a size intersects with the address \a

lldb/include/lldb/Breakpoint/StoppointLocation.h

public:
   virtual bool IsHardware() const {
     return m_hardware_index != LLDB_INVALID_INDEX32;
   }
 
   virtual bool ShouldStop(StoppointCallbackContext *context) { return true; }
 
   virtual void Dump(Stream *stream) const {}
 
-  void SetHardwareIndex(uint32_t index) { m_hardware_index = index; }
+  virtual void SetHardwareIndex(uint32_t index) { m_hardware_index = index; }
 
   lldb::break_id_t GetID() const { return m_loc_id; }
 
 protected:
   // Classes that inherit from StoppointLocation can see and modify these
   lldb::break_id_t m_loc_id; // Stoppoint location ID
   lldb::addr_t
       m_addr; // The load address of this stop point. The base Stoppoint doesn't

lldb/packages/Python/lldbsuite/test/functionalities/breakpoint/hardware_breakpoints/hardware_breakpoint_on_multiple_threads/TestHWBreakMultiThread.py

class HardwareBreakpointMultiThreadTestCase(TestBase):
 
     # LLDB on linux supports hardware breakpoints for arm and aarch64
     # architectures.
     @skipUnlessPlatform(oslist=['linux'])
     @skipIf(archs=no_match(['arm', 'aarch64']))
     def test_hw_break_set_delete_multi_thread_linux(self):
         self.build()
         self.setTearDownCleanup()
-        self.break_multi_thread('delete', 'breakpoint')
+        self.break_multi_thread('delete')
 
     # LLDB on linux supports hardware breakpoints for arm and aarch64
     # architectures.
     @skipUnlessPlatform(oslist=['linux'])
     @skipIf(archs=no_match(['arm', 'aarch64']))
     def test_hw_break_set_disable_multi_thread_linux(self):
         self.build()
         self.setTearDownCleanup()
-        self.break_multi_thread('disable', 'breakpoint')
+        self.break_multi_thread('disable')
 
     # LLDB on darwin supports hardware breakpoints for arm, aarch64, x86_64 and
     # i386 architectures.
     @skipUnlessDarwin
     @skipIfOutOfTreeDebugserver
     def test_hw_break_set_delete_multi_thread_macos(self):
         self.build()
         self.setTearDownCleanup()
-        self.break_multi_thread('delete', 'EXC_BREAKPOINT')
+        self.break_multi_thread('delete')
 
     # LLDB on darwin supports hardware breakpoints for arm, aarch64, x86_64 and
     # i386 architectures.
     @skipUnlessDarwin
     @skipIfOutOfTreeDebugserver
     def test_hw_break_set_disable_multi_thread_macos(self):
         self.build()
         self.setTearDownCleanup()
-        self.break_multi_thread('disable', 'EXC_BREAKPOINT')
+        self.break_multi_thread('disable')
 
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.first_stop = line_number(
             self.source, 'Starting thread creation with hardware breakpoint set')
 
-    def break_multi_thread(self, removal_type, stop_reason):
+    def break_multi_thread(self, removal_type):
         """Test that lldb hardware breakpoints work for multiple threads."""
         self.runCmd("file " + self.getBuildArtifact("a.out"),
                     CURRENT_EXECUTABLE_SET)
 
         # Stop in main before creating any threads.
         lldbutil.run_break_set_by_file_and_line(
             self, None, self.first_stop, num_expected_locations=1)
 
def break_multi_thread(self, removal_type):
         while count < 2 :
 
             self.runCmd("process continue")
 
             # We should be stopped in hw_break_function
             # The stop reason of the thread should be breakpoint.
             self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
                 substrs=[
-                    'stop reason = {}'.format(stop_reason),
+                    'stop reason = breakpoint',
                     'hw_break_function'])
 
             # Continue the loop and test that we are stopped 4 times.
             count += 1
 
         if removal_type == 'delete':
             self.runCmd("settings set auto-confirm true")
 

lldb/source/Breakpoint/BreakpointSite.cpp

 
 void BreakpointSite::BumpHitCounts() {
   std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
   for (BreakpointLocationSP loc_sp : m_owners.BreakpointLocations()) {
     loc_sp->BumpHitCount();
   }
 }
 
+void BreakpointSite::SetHardwareIndex(uint32_t index) {
+  std::lock_guard<std::recursive_mutex> guard(m_owners_mutex);
+  for (BreakpointLocationSP loc_sp : m_owners.BreakpointLocations()) {
+    loc_sp->SetHardwareIndex(index);
+  }
+}
+
 bool BreakpointSite::IntersectsRange(lldb::addr_t addr, size_t size,
                                      lldb::addr_t *intersect_addr,
                                      size_t *intersect_size,
                                      size_t *opcode_offset) const {
   // We only use software traps for software breakpoints
   if (!IsHardware()) {
     if (m_byte_size > 0) {
       const lldb::addr_t bp_end_addr = m_addr + m_byte_size;

lldb/source/Plugins/Process/Utility/StopInfoMachException.cpp

 //===-- StopInfoMachException.cpp -----------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "StopInfoMachException.h"
 
+#include "lldb/lldb-forward.h"
 
 #if defined(__APPLE__)
 // Needed for the EXC_RESOURCE interpretation macros
 #include <kern/exc_resource.h>
 #endif
 
 #include "lldb/Breakpoint/Watchpoint.h"
 #include "lldb/Symbol/Symbol.h"
#endif
 
   if (m_exc_data_count > 0)
     strm.PutChar(')');
 
   m_description = strm.GetString();
   return m_description.c_str();
 }
 
+static StopInfoSP GetStopInfoForHardwareBP(Thread &thread, Target *target,
+                                           uint32_t exc_data_count,
+                                           uint64_t exc_sub_code,
+                                           uint64_t exc_sub_sub_code) {
+  // Try hardware watchpoint.
+  if (target) {
+    // The exc_sub_code indicates the data break address.
+    lldb::WatchpointSP wp_sp =
+        target->GetWatchpointList().FindByAddress((lldb::addr_t)exc_sub_code);
+    if (wp_sp && wp_sp->IsEnabled()) {
+      // Debugserver may piggyback the hardware index of the fired watchpoint
+      // in the exception data. Set the hardware index if that's the case.
+      if (exc_data_count >= 3)
+        wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
+      return StopInfo::CreateStopReasonWithWatchpointID(thread, wp_sp->GetID());
+    }
+  }
+
+  // Try hardware breakpoint.
+  ProcessSP process_sp(thread.GetProcess());
+  if (process_sp) {
+    // The exc_sub_code indicates the data break address.
+    lldb::BreakpointSiteSP bp_sp =
+        process_sp->GetBreakpointSiteList().FindByAddress(
+            (lldb::addr_t)exc_sub_code);
+    if (bp_sp && bp_sp->IsEnabled()) {
+      // Debugserver may piggyback the hardware index of the fired breakpoint
+      // in the exception data. Set the hardware index if that's the case.
+      if (exc_data_count >= 3)
+        bp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
+      return StopInfo::CreateStopReasonWithBreakpointSiteID(thread,
+                                                            bp_sp->GetID());
+    }
+  }
+
+  return nullptr;
+}
+
 StopInfoSP StopInfoMachException::CreateStopReasonWithMachException(
     Thread &thread, uint32_t exc_type, uint32_t exc_data_count,
     uint64_t exc_code, uint64_t exc_sub_code, uint64_t exc_sub_sub_code,
     bool pc_already_adjusted, bool adjust_pc_if_needed) {
   if (exc_type == 0)
     return StopInfoSP();
 
   uint32_t pc_decrement = 0;
case llvm::Triple::x86_64:
         if (!exc_sub_code) {
           // This looks like a plain trap.
           // Have to check if there is a breakpoint here as well.  When you
           // single-step onto a trap, the single step stops you not to trap.
           // Since we also do that check below, let's just use that logic.
           is_actual_breakpoint = true;
           is_trace_if_actual_breakpoint_missing = true;
         } else {
-
-          // It's a watchpoint, then.
-          // The exc_sub_code indicates the data break address.
-          lldb::WatchpointSP wp_sp;
-          if (target)
-            wp_sp = target->GetWatchpointList().FindByAddress(
-                (lldb::addr_t)exc_sub_code);
-          if (wp_sp && wp_sp->IsEnabled()) {
-            // Debugserver may piggyback the hardware index of the fired
-            // watchpoint in the exception data. Set the hardware index if
-            // that's the case.
-            if (exc_data_count >= 3)
-              wp_sp->SetHardwareIndex((uint32_t)exc_sub_sub_code);
-            return StopInfo::CreateStopReasonWithWatchpointID(thread,
-                                                              wp_sp->GetID());
-          }
+          if (StopInfoSP stop_info =
+                  GetStopInfoForHardwareBP(thread, target, exc_data_count,
+                                           exc_sub_code, exc_sub_sub_code))
+            return stop_info;
         }
       } else if (exc_code == 2 || // EXC_I386_BPT
                  exc_code == 3)   // EXC_I386_BPTFLT
       {
         // KDP returns EXC_I386_BPTFLT for trace breakpoints
         if (exc_code == 3)
           is_trace_if_actual_breakpoint_missing = true;