Hardware breakpoints implementation for Arm/AArch64 targets

[omjavaid]

Summary

This patch implements hardware breakpoint functionality in LLDB for AArch64 targets. AArch64 targets supports hardware breakpoints via ptrace interface similar to hardware watchpoints. Hardware breakpoints provide fast way to stop target not requiring any memory read/write like software breakpoints.

This patch fixes areas which required tweaking to put hardware breakpoints implementation in place via process gdb remote. We are able to test these breakpoints via a simple application on Android Nexux5x devices.

I am in process of testing on various other platforms and also writing lldb testsuite test cases.

Also added in final revision.

1. LLDB Testsuite testcases for hardware breakpoints testing. (Done)
2. Similar implementation for Arm targets.

Looking forward to upstream comments on this.

Test code in case someone wants to test:

#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>

#define THREAD_COUNT 8

void *thread_function( void *ptr )
{

int *argument = (int *) ptr;

printf("Thread #%i \n", *argument);

}

int main()
{

int argument[THREAD_COUNT];
pthread_t thread_handle[THREAD_COUNT];

int i;
for (i = 0; i < THREAD_COUNT; i++)
{ 
  argument[i] = i;
  if (pthread_create( &thread_handle[i], NULL, thread_function, (void*) &argument[i]))
  {
    printf("Error - pthread_create() failed\n");
    exit(EXIT_FAILURE);
  }
}

for (i = 0; i < THREAD_COUNT; i++)
  pthread_join( thread_handle[i], NULL);

exit(EXIT_SUCCESS);

return 0;

}

[labath]

Don't be intimidated by the number of comments :) - I think the change looks reasonable as a whole - most of them are just about style and come from the fact you were probably working on the patch while I was refactoring this code. As for tests, what I'd definitely want to see is a lldb-server-style test, which tests just the server changes without the client part (maybe you we're already talking about those - I just want to make sure we're on the same page).

As for the stepping speed, do you have any data which shows that this is actually a bottleneck in those operations? (I'm not against doing that, I'm just curious).

include/lldb/Host/common/HardwareBreakpointList.h

24 ↗

(On Diff #87493)

What's the benefit of this class over using std::map<lldb::addr_t, HardwareBreakpoint> directly?

source/Host/common/NativeProcessProtocol.cpp

142 ↗

(On Diff #87493)

llvm::Optional<std::pair<uint32_t, uint32_t>> GetHardwareDebugSupportInfo()

145 ↗

(On Diff #87493)

This comment needs update

source/Plugins/Process/Linux/NativeProcessLinux.cpp

875 ↗

(On Diff #87493)

Please rename the wp_index variable to something more generic if you're going to use it here.

source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

367 ↗

(On Diff #87493)

Please use LLDB_LOG here.

384 ↗

(On Diff #87493)

Please use POSIX_LOG_BREAKPOINTS here (the code in the NativeProcessLinux plugin was using a combination of posix and lldb log channels, so i've standardized it on posix).

414 ↗

(On Diff #87493)

s/watchpoints/breakpoints/ ?

source/Plugins/Process/Linux/NativeThreadLinux.cpp

246 ↗

(On Diff #87493)

This doesn't appear to be setting the breakpoint on *all* threads (and it probably shouldnt)

[clayborg]

I would prefer to see NativeBreakpoint struct expanded to have more member variables instead of adding a new hardware breakpoint list. Then you just ask any breakpoint to enable/disable/remove itself and the structure contains all of the info we need. Keeping two lists means we have to check two lists. Let me know if any of my inline comments weren't clear?

include/lldb/Host/common/HardwareBreakpointList.h

24 ↗

(On Diff #87493)

There is no real error you can return from Add. Remove can just return a bool if it succeeds or not. So we can probably just use a std::map directly like Pavel suggests.

include/lldb/Host/common/NativeProcessProtocol.h

318–320 ↗

(On Diff #87493)

It would be nice to just expand the contents of NativeBreakpoint and remove the HardwareBreakpoint and HardwareBreakpointList. No need for another list to check. I would suggest just adding a "bool m_hardware;" to NativeBreakpoint. Or add a new NativeBreakpoint::Type enum in NativeBreakpoint.h that is:

NativeBreakpoint
{
  enum class Type
  {
    Software,
    Hardware
  };
  Type m_type;
};

include/lldb/Host/common/NativeRegisterContext.h

78–81 ↗

(On Diff #87493)

These would go away if we expand NativeBreakpoint to include new fields to support hardware breakpoints?

include/lldb/Host/common/NativeThreadProtocol.h

59–64 ↗

(On Diff #87493)

Would we want to pass in the NativeBreakpoint class here instead of individual arguments? Maybe each thread might want to store some extra data inside the NativeBreakpoint class (like the index of the hardware breakpoint, which means we might need to also add more fields to NativeBreakpoint).

source/Host/common/HardwareBreakpointList.cpp

1–30 ↗

(On Diff #87493)

Remove this if we just end up using the one breakpoint list and expand NativeBreakpoint to include fields to support hardware breakpoints.

source/Host/common/NativeProcessProtocol.cpp

275–276 ↗

(On Diff #87493)

Change this to take the "NativeBreakpoint" structure instead of manual arguments?

329 ↗

(On Diff #87493)

change argument to take NativeBreakpoint struct?

430–436 ↗

(On Diff #87493)

Switch to use NativeBreakpoint struct as argument? Then we won't need extra args since the NativeBreakpoint will have all the info inside of it.

source/Plugins/Process/Linux/NativeProcessLinux.cpp

1738 ↗

(On Diff #87493)

Use NativeBreakpoint struct as arg?

source/Plugins/Process/Linux/NativeProcessLinux.h

89 ↗

(On Diff #87493)

Use NativeBreakpoint struct instead of manual args?

[omjavaid]

In D29669#670896, @clayborg wrote:

I would prefer to see NativeBreakpoint struct expanded to have more member variables instead of adding a new hardware breakpoint list. Then you just ask any breakpoint to enable/disable/remove itself and the structure contains all of the info we need. Keeping two lists means we have to check two lists. Let me know if any of my inline comments weren't clear?

So I thought about it but gave up on the idea for two reasons:

1. Hardware breakpoints implementation has more similarities with hardware watchpoints than software breakpoints and I plan to consolidate both functionalities onces hardware brekapoints start working.

2. Software breakpoint are implemented with process wide scope and hardware breakpoints are thread specific which means that we add existing hw breakpoint on all new threads. On resume we ll be traversing through a breakpoint list which predominantly has only software breakpoints in most cases a overhead will be added in case we have 20 software breakpoint and just 1 hardware breakpoint installed by user.

Let me know what do you think about above two ppoints and I ll clear up all other comments in following revision.

[clayborg]

If it isn't making too much extra code I am fine with it being separate if you believe this is the right way forward. Give it some thought and if you still believe they should be separate, I won't object. It might be nice to send the HardwareBreakpoint structure down to the functions that are going to enable/disable the HW breakpoints instead of individual arguments as you may end up adding members to the HardwareBreakpoint in the future and this will keep you from having to update all of the signatures.

[omjavaid]

This patch has following updates:

1. Support for Arm hardware breakpoints
2. LLDBServer Test cases for testing Z1 z1 packets.
3. Test case to test hardware breakpoint command and multi-threaded hardware breakpoints.
4. Get rid of HardwareBreakpointList class and replaced it with simple map and struct.
5. Fix LLDB Log mismtach to POSIX_LOG
6. Fix arm hardware breakpoint register read/write function.

Kindly provide your feedback. Is this all good to go in now?

[clayborg]

LGTM, but Pavel should give the ok as well.

[labath]

I am sorry about the delay - I was busy last week and then this kinda fell off my radar.

The change looks good, but I want to make the test more stable - we are running these in CI and I've already seen some very unlikely things happen, so I don't want this to be flaky.

Also, it looks like you didn't catch all instances of using printf-style logging.

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

78 ↗

(On Diff #88505)

This is quite racy.

There is nothing that guarantees that we will stop on the breakpoint at least four times. In particular, it can happen that all 8 threads hit the breakpoint simultaneously, and then you have only one stop of the whole process. If you want to have more than one stop you need to either:

• make sure that no two threads can hit the breakpoint simultaneously (e.g., add some kind of a mutex in the inferior),
• or count the stops more diligently (after each stop, count the number of threads stopped at the location, as in e.g. TestConcurrentEvents)

However, if the purpose of this test is to make sure the breakpoint applies to newly-created threads, then I think you don't need than many threads, and one thread would suffice. Then the test could be:

• set a breakpoint
• inferior spins up a thread and hits it
• remove/disable the breakpoint
• inferior joins the first thread
• inferior spins up another thread which does *not* hit the breakpoint

This should make debugging any failures easier as the test is more deterministic.

108 ↗

(On Diff #88505)

It looks like you are missing an assertion to verify that the exit actually happened here.

source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp

362 ↗

(On Diff #88505)

LLDB_LOG (or just remove the log statement as it does not convey much information).

474 ↗

(On Diff #88505)

LLDB_LOG (and in below function as well)

[omjavaid]

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

78 ↗

(On Diff #88505)

Agreed!! I ll post an alternative then.

Thanks!

[omjavaid]

@labath

Hi I have updated diff with corrections.

Thanks!

[labath]

lgtm, thanks.

packages/Python/lldbsuite/test/functionalities/breakpoint/hardware_breakpoints/hardware_breakpoint_on_multiple_threads/main.cpp

30 ↗

(On Diff #89642)

I know it's only a test program, but you generally should never lock the mutex manually.

std::lock_guard<std::mutex> guard(mutex)

lldb/trunk/include/lldb/Host/common/NativeBreakpointList.h

 #include "lldb/lldb-private-forward.h"
 // #include "lldb/Host/NativeBreakpoint.h"
 
 #include <functional>
 #include <map>
 #include <mutex>
 
 namespace lldb_private {
+
+struct HardwareBreakpoint {
+  lldb::addr_t m_addr;
+  size_t m_size;
+};
+
+using HardwareBreakpointMap = std::map<lldb::addr_t, HardwareBreakpoint>;
+
 class NativeBreakpointList {
 public:
   typedef std::function<Error(lldb::addr_t addr, size_t size_hint,
                               bool hardware, NativeBreakpointSP &breakpoint_sp)>
       CreateBreakpointFunc;
 
   NativeBreakpointList();
 

lldb/trunk/include/lldb/Host/common/NativeProcessProtocol.h

public:
   virtual bool GetArchitecture(ArchSpec &arch) const = 0;
 
   //----------------------------------------------------------------------
   // Breakpoint functions
   //----------------------------------------------------------------------
   virtual Error SetBreakpoint(lldb::addr_t addr, uint32_t size,
                               bool hardware) = 0;
 
-  virtual Error RemoveBreakpoint(lldb::addr_t addr);
+  virtual Error RemoveBreakpoint(lldb::addr_t addr, bool hardware = false);
 
   virtual Error EnableBreakpoint(lldb::addr_t addr);
 
   virtual Error DisableBreakpoint(lldb::addr_t addr);
 
   //----------------------------------------------------------------------
+  // Hardware Breakpoint functions
+  //----------------------------------------------------------------------
+  virtual const HardwareBreakpointMap &GetHardwareBreakpointMap() const;
+
+  virtual Error SetHardwareBreakpoint(lldb::addr_t addr, size_t size);
+
+  virtual Error RemoveHardwareBreakpoint(lldb::addr_t addr);
+
+  //----------------------------------------------------------------------
   // Watchpoint functions
   //----------------------------------------------------------------------
   virtual const NativeWatchpointList::WatchpointMap &GetWatchpointMap() const;
 
-  virtual uint32_t GetMaxWatchpoints() const;
+  virtual llvm::Optional<std::pair<uint32_t, uint32_t>>
+  GetHardwareDebugSupportInfo() const;
 
   virtual Error SetWatchpoint(lldb::addr_t addr, size_t size,
                               uint32_t watch_flags, bool hardware);
 
   virtual Error RemoveWatchpoint(lldb::addr_t addr);
 
   //----------------------------------------------------------------------
   // Accessors
protected:
 
   lldb_private::ExitType m_exit_type;
   int m_exit_status;
   std::string m_exit_description;
   std::recursive_mutex m_delegates_mutex;
   std::vector<NativeDelegate *> m_delegates;
   NativeBreakpointList m_breakpoint_list;
   NativeWatchpointList m_watchpoint_list;
+  HardwareBreakpointMap m_hw_breakpoints_map;
   int m_terminal_fd;
   uint32_t m_stop_id;
 
   // Set of signal numbers that LLDB directly injects back to inferior
   // without stopping it.
   llvm::DenseSet<int> m_signals_to_ignore;
 
   // lldb_private::Host calls should be used to launch a process for debugging,

lldb/trunk/include/lldb/Host/common/NativeRegisterContext.h

public:
   // Subclasses can override these functions if desired
   //------------------------------------------------------------------
   virtual uint32_t NumSupportedHardwareBreakpoints();
 
   virtual uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size);
 
   virtual bool ClearHardwareBreakpoint(uint32_t hw_idx);
 
+  virtual Error ClearAllHardwareBreakpoints();
+
+  virtual Error GetHardwareBreakHitIndex(uint32_t &bp_index,
+                                         lldb::addr_t trap_addr);
+
   virtual uint32_t NumSupportedHardwareWatchpoints();
 
   virtual uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size,
                                          uint32_t watch_flags);
 
   virtual bool ClearHardwareWatchpoint(uint32_t hw_index);
 
   virtual Error ClearAllHardwareWatchpoints();

lldb/trunk/include/lldb/Host/common/NativeThreadProtocol.h

public:
   // ---------------------------------------------------------------------
   // Thread-specific watchpoints
   // ---------------------------------------------------------------------
   virtual Error SetWatchpoint(lldb::addr_t addr, size_t size,
                               uint32_t watch_flags, bool hardware) = 0;
 
   virtual Error RemoveWatchpoint(lldb::addr_t addr) = 0;
 
+  // ---------------------------------------------------------------------
+  // Thread-specific Hardware Breakpoint routines
+  // ---------------------------------------------------------------------
+  virtual Error SetHardwareBreakpoint(lldb::addr_t addr, size_t size) = 0;
+
+  virtual Error RemoveHardwareBreakpoint(lldb::addr_t addr) = 0;
+
 protected:
   NativeProcessProtocolWP m_process_wp;
   lldb::tid_t m_tid;
 };
 }
 
 #endif // #ifndef liblldb_NativeThreadProtocol_h_

lldb/trunk/packages/Python/lldbsuite/test/functionalities/breakpoint/hardware_breakpoints/hardware_breakpoint_on_multiple_threads/Makefile

+LEVEL = ../../../../make
+
+ENABLE_THREADS := YES
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

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

+"""
+Test hardware breakpoints for multiple threads.
+"""
+
+from __future__ import print_function
+
+
+import os
+import time
+import re
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+# Hardware breakpoints are supported only by platforms mentioned in oslist.
+@skipUnlessPlatform(oslist=['linux'])
+class HardwareBreakpointMultiThreadTestCase(TestBase):
+    NO_DEBUG_INFO_TESTCASE = True
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    # LLDB supports hardware breakpoints for arm and aarch64 architectures.
+    @skipIf(archs=no_match(['arm', 'aarch64']))
+    @expectedFailureAndroid
+    def test_hw_break_set_delete_multi_thread(self):
+        self.build()
+        self.setTearDownCleanup() 
+        self.break_multi_thread('delete')
+
+    # LLDB supports hardware breakpoints for arm and aarch64 architectures.
+    @skipIf(archs=no_match(['arm', 'aarch64']))
+    @expectedFailureAndroid
+    def test_hw_break_set_disable_multi_thread(self):
+        self.build()
+        self.setTearDownCleanup() 
+        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):
+        """Test that lldb hardware breakpoints work for multiple threads."""
+        self.runCmd(
+            "file %s" %
+            os.path.join(
+                os.getcwd(),
+                '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)
+
+        # Run the program.
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        # We should be stopped again due to the breakpoint.
+        # The stop reason of the thread should be breakpoint.
+        self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
+                    substrs=['stopped',
+                             'stop reason = breakpoint'])
+
+        # Now set a hardware breakpoint in thread function.
+        self.expect("breakpoint set -b hw_break_function --hardware",
+            substrs=[
+                'Breakpoint',
+                'hw_break_function',
+                'address = 0x'])
+
+        # We should stop in hw_break_function function for 4 threads.
+        count = 0
+
+        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 = 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")
+
+            # Now 'breakpoint delete' should just work fine without confirmation
+            # prompt from the command interpreter.
+            self.expect("breakpoint delete",
+                        startstr="All breakpoints removed")
+
+            # Restore the original setting of auto-confirm.
+            self.runCmd("settings clear auto-confirm")
+
+        elif removal_type == 'disable':
+            self.expect("breakpoint disable",
+                        startstr="All breakpoints disabled.")
+
+        # Continue. Program should exit without stopping anywhere.
+        self.runCmd("process continue")
+
+        # Process should have stopped and exited with status = 0
+        self.expect("process status", PROCESS_STOPPED,
+                    patterns=['Process .* exited with status = 0'])

lldb/trunk/packages/Python/lldbsuite/test/functionalities/breakpoint/hardware_breakpoints/hardware_breakpoint_on_multiple_threads/main.cpp

+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <chrono>
+#include <cstdio>
+#include <mutex>
+#include <random>
+#include <thread>
+
+#define NUM_OF_THREADS 4
+
+std::mutex hw_break_mutex;
+
+void
+hw_break_function (uint32_t thread_index) {
+  printf ("%s called by Thread #%u...\n", __FUNCTION__, thread_index);
+}
+
+
+void
+thread_func (uint32_t thread_index) {
+  printf ("%s (thread index = %u) starting...\n", __FUNCTION__, thread_index);
+
+  hw_break_mutex.lock();
+  
+  hw_break_function(thread_index); // Call hw_break_function
+
+  hw_break_mutex.unlock();
+}
+
+
+int main (int argc, char const *argv[])
+{
+  std::thread threads[NUM_OF_THREADS]; 
+
+  printf ("Starting thread creation with hardware breakpoint set...\n");
+
+  for (auto &thread : threads)
+    thread = std::thread{thread_func, std::distance(threads, &thread)};
+
+  for (auto &thread : threads)
+    thread.join();
+
+  return 0;
+}

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestLldbGdbServer.py

     @llgs_test
     def test_qMemoryRegionInfo_reports_heap_address_as_readable_writeable_llgs(
             self):
         self.init_llgs_test()
         self.build()
         self.set_inferior_startup_launch()
         self.qMemoryRegionInfo_reports_heap_address_as_readable_writeable()
 
-    def software_breakpoint_set_and_remove_work(self):
+    def breakpoint_set_and_remove_work(self, want_hardware=False):
         # Start up the inferior.
         procs = self.prep_debug_monitor_and_inferior(
             inferior_args=[
                 "get-code-address-hex:hello",
                 "sleep:1",
                 "call-function:hello"])
 
         # Run the process
def breakpoint_set_and_remove_work(self, want_hardware=False):
         (pc_lldb_reg_index, pc_reg_info) = self.find_pc_reg_info(reg_infos)
         self.assertIsNotNone(pc_lldb_reg_index)
         self.assertIsNotNone(pc_reg_info)
 
         # Grab the function address.
         self.assertIsNotNone(context.get("function_address"))
         function_address = int(context.get("function_address"), 16)
 
+        # Get current target architecture
+        target_arch = self.getArchitecture()
+
         # Set the breakpoint.
-        if self.getArchitecture() == "arm":
+        if (target_arch == "arm") or (target_arch == "aarch64"):
             # TODO: Handle case when setting breakpoint in thumb code
             BREAKPOINT_KIND = 4
         else:
             BREAKPOINT_KIND = 1
+
+        # Set default packet type to Z0 (software breakpoint)
+        z_packet_type = 0       
+
+        # If hardware breakpoint is requested set packet type to Z1
+        if want_hardware == True:
+            z_packet_type = 1
+
         self.reset_test_sequence()
         self.add_set_breakpoint_packets(
             function_address,
+            z_packet_type,
             do_continue=True,
             breakpoint_kind=BREAKPOINT_KIND)
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
         # Verify the stop signal reported was the breakpoint signal number.
def breakpoint_set_and_remove_work(self, want_hardware=False):
         # Convert from target endian to int.
         returned_pc = lldbgdbserverutils.unpack_register_hex_unsigned(
             endian, p_response)
         self.assertEqual(returned_pc, function_address)
 
         # Verify that a breakpoint remove and continue gets us the expected
         # output.
         self.reset_test_sequence()
+
+        # Add breakpoint remove packets
+        self.add_remove_breakpoint_packets(
+            function_address,
+            z_packet_type,
+            breakpoint_kind=BREAKPOINT_KIND)
+
         self.test_sequence.add_log_lines(
             [
-                # Remove the breakpoint.
-                "read packet: $z0,{0:x},{1}#00".format(
-                    function_address, BREAKPOINT_KIND),
-                # Verify the stub could unset it.
-                "send packet: $OK#00",
                 # Continue running.
                 "read packet: $c#63",
                 # We should now receive the output from the call.
                 {"type": "output_match", "regex": r"^hello, world\r\n$"},
                 # And wait for program completion.
                 {"direction": "send", "regex": r"^\$W00(.*)#[0-9a-fA-F]{2}$"},
             ], True)
 
         context = self.expect_gdbremote_sequence()
         self.assertIsNotNone(context)
 
     @debugserver_test
     def test_software_breakpoint_set_and_remove_work_debugserver(self):
         self.init_debugserver_test()
         if self.getArchitecture() == "arm":
             # TODO: Handle case when setting breakpoint in thumb code
             self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
         else:
             self.build()
         self.set_inferior_startup_launch()
-        self.software_breakpoint_set_and_remove_work()
+        self.breakpoint_set_and_remove_work(want_hardware=False)
 
     @llgs_test
     @expectedFlakeyLinux("llvm.org/pr25652")
     def test_software_breakpoint_set_and_remove_work_llgs(self):
         self.init_llgs_test()
         if self.getArchitecture() == "arm":
             # TODO: Handle case when setting breakpoint in thumb code
             self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
         else:
             self.build()
         self.set_inferior_startup_launch()
-        self.software_breakpoint_set_and_remove_work()
+        self.breakpoint_set_and_remove_work(want_hardware=False)
+
+    @debugserver_test
+    @skipUnlessPlatform(oslist=['linux'])
+    @expectedFailureAndroid
+    @skipIf(archs=no_match(['arm', 'aarch64']))
+    def test_hardware_breakpoint_set_and_remove_work_debugserver(self):
+        self.init_debugserver_test()
+        if self.getArchitecture() == "arm":
+            # TODO: Handle case when setting breakpoint in thumb code
+            self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
+        else:
+            self.build()
+        self.set_inferior_startup_launch()
+        self.breakpoint_set_and_remove_work(want_hardware=True)
+
+    @llgs_test
+    @skipUnlessPlatform(oslist=['linux'])
+    @expectedFailureAndroid
+    @skipIf(archs=no_match(['arm', 'aarch64']))
+    def test_hardware_breakpoint_set_and_remove_work_llgs(self):
+        self.init_llgs_test()
+        if self.getArchitecture() == "arm":
+            # TODO: Handle case when setting breakpoint in thumb code
+            self.build(dictionary={'CFLAGS_EXTRAS': '-marm'})
+        else:
+            self.build()
+        self.set_inferior_startup_launch()
+        self.breakpoint_set_and_remove_work(want_hardware=True)
 
     def qSupported_returns_known_stub_features(self):
         # Start up the stub and start/prep the inferior.
         procs = self.prep_debug_monitor_and_inferior()
         self.add_qSupported_packets()
 
         # Run the packet stream.
         context = self.expect_gdbremote_sequence()

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

def wait_for_thread_count(self, thread_count, timeout_seconds=3):
                     'timed out after {} seconds while waiting for theads: waiting for at least {} threads, found {}'.format(
                         timeout_seconds, thread_count, actual_thread_count))
 
         return threads
 
     def add_set_breakpoint_packets(
             self,
             address,
+            z_packet_type=0,
             do_continue=True,
             breakpoint_kind=1):
         self.test_sequence.add_log_lines(
             [  # Set the breakpoint.
-                "read packet: $Z0,{0:x},{1}#00".format(
-                    address, breakpoint_kind),
+                "read packet: $Z{2},{0:x},{1}#00".format(
+                    address, breakpoint_kind, z_packet_type),
                 # Verify the stub could set it.
                 "send packet: $OK#00",
             ], True)
 
         if (do_continue):
             self.test_sequence.add_log_lines(
                 [  # Continue the inferior.
                     "read packet: $c#63",
                     # Expect a breakpoint stop report.
                     {"direction": "send",
                      "regex": r"^\$T([0-9a-fA-F]{2})thread:([0-9a-fA-F]+);",
                      "capture": {1: "stop_signo",
                                  2: "stop_thread_id"}},
                 ], True)
 
-    def add_remove_breakpoint_packets(self, address, breakpoint_kind=1):
+    def add_remove_breakpoint_packets(
+            self,
+            address,
+            z_packet_type=0,
+            breakpoint_kind=1):
         self.test_sequence.add_log_lines(
             [  # Remove the breakpoint.
-                "read packet: $z0,{0:x},{1}#00".format(
-                    address, breakpoint_kind),
+                "read packet: $z{2},{0:x},{1}#00".format(
+                    address, breakpoint_kind, z_packet_type),
                 # Verify the stub could unset it.
                 "send packet: $OK#00",
             ], True)
 
     def add_qSupported_packets(self):
         self.test_sequence.add_log_lines(
             ["read packet: $qSupported#00",
              {"direction": "send", "regex": r"^\$(.*)#[0-9a-fA-F]{2}", "capture": {1: "qSupported_response"}},

lldb/trunk/source/Host/common/NativeProcessProtocol.cpp

bool NativeProcessProtocol::GetByteOrder(lldb::ByteOrder &byte_order) const {
   return true;
 }
 
 const NativeWatchpointList::WatchpointMap &
 NativeProcessProtocol::GetWatchpointMap() const {
   return m_watchpoint_list.GetWatchpointMap();
 }
 
-uint32_t NativeProcessProtocol::GetMaxWatchpoints() const {
-  // This default implementation will return the number of
-  // *hardware* breakpoints available.  MacOSX and other OS
-  // implementations that support software breakpoints will want to
-  // override this correctly for their implementation.
+llvm::Optional<std::pair<uint32_t, uint32_t>>
+NativeProcessProtocol::GetHardwareDebugSupportInfo() const {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
 
   // get any thread
   NativeThreadProtocolSP thread_sp(
       const_cast<NativeProcessProtocol *>(this)->GetThreadAtIndex(0));
   if (!thread_sp) {
     if (log)
       log->Warning("NativeProcessProtocol::%s (): failed to find a thread to "
                    "grab a NativeRegisterContext!",
                    __FUNCTION__);
-    return 0;
+    return llvm::None;
   }
 
   NativeRegisterContextSP reg_ctx_sp(thread_sp->GetRegisterContext());
   if (!reg_ctx_sp) {
     if (log)
       log->Warning("NativeProcessProtocol::%s (): failed to get a "
                    "RegisterContextNativeProcess from the first thread!",
                    __FUNCTION__);
-    return 0;
+    return llvm::None;
   }
 
-  return reg_ctx_sp->NumSupportedHardwareWatchpoints();
+  return std::make_pair(reg_ctx_sp->NumSupportedHardwareBreakpoints(),
+                        reg_ctx_sp->NumSupportedHardwareWatchpoints());
 }
 
 Error NativeProcessProtocol::SetWatchpoint(lldb::addr_t addr, size_t size,
                                            uint32_t watch_flags,
                                            bool hardware) {
   // This default implementation assumes setting the watchpoint for
   // the process will require setting the watchpoint for each of the
   // threads.  Furthermore, it will track watchpoints set for the
if (thread_error.Fail()) {
       if (!overall_error.Fail())
         overall_error = thread_error;
     }
   }
   const Error error = m_watchpoint_list.Remove(addr);
   return overall_error.Fail() ? overall_error : error;
 }
 
+const HardwareBreakpointMap &
+NativeProcessProtocol::GetHardwareBreakpointMap() const {
+  return m_hw_breakpoints_map;
+}
+
+Error NativeProcessProtocol::SetHardwareBreakpoint(lldb::addr_t addr,
+                                                   size_t size) {
+  // This default implementation assumes setting a hardware breakpoint for
+  // this process will require setting same hardware breakpoint for each
+  // of its existing threads. New thread will do the same once created.
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_PROCESS));
+
+  // Update the thread list
+  UpdateThreads();
+
+  // Exit here if target does not have required hardware breakpoint capability.
+  auto hw_debug_cap = GetHardwareDebugSupportInfo();
+
+  if (hw_debug_cap == llvm::None || hw_debug_cap->first == 0 ||
+      hw_debug_cap->first <= m_hw_breakpoints_map.size())
+    return Error("Target does not have required no of hardware breakpoints");
+
+  // Vector below stores all thread pointer for which we have we successfully
+  // set this hardware breakpoint. If any of the current process threads fails
+  // to set this hardware breakpoint then roll back and remove this breakpoint
+  // for all the threads that had already set it successfully.
+  std::vector<NativeThreadProtocolSP> breakpoint_established_threads;
+
+  // Request to set a hardware breakpoint for each of current process threads.
+  std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
+  for (auto thread_sp : m_threads) {
+    assert(thread_sp && "thread list should not have a NULL thread!");
+    if (!thread_sp)
+      continue;
+
+    Error thread_error = thread_sp->SetHardwareBreakpoint(addr, size);
+    if (thread_error.Success()) {
+      // Remember that we set this breakpoint successfully in
+      // case we need to clear it later.
+      breakpoint_established_threads.push_back(thread_sp);
+    } else {
+      // Unset the breakpoint for each thread we successfully
+      // set so that we get back to a consistent state of "not
+      // set" for this hardware breakpoint.
+      for (auto rollback_thread_sp : breakpoint_established_threads) {
+        Error remove_error = rollback_thread_sp->RemoveHardwareBreakpoint(addr);
+        if (remove_error.Fail() && log) {
+          log->Warning("NativeProcessProtocol::%s (): RemoveHardwareBreakpoint"
+                       " failed for pid=%" PRIu64 ", tid=%" PRIu64 ": %s",
+                       __FUNCTION__, GetID(), rollback_thread_sp->GetID(),
+                       remove_error.AsCString());
+        }
+      }
+
+      return thread_error;
+    }
+  }
+
+  // Register new hardware breakpoint into hardware breakpoints map of current
+  // process.
+  m_hw_breakpoints_map[addr] = {addr, size};
+
+  return Error();
+}
+
+Error NativeProcessProtocol::RemoveHardwareBreakpoint(lldb::addr_t addr) {
+  // Update the thread list
+  UpdateThreads();
+
+  Error error;
+
+  std::lock_guard<std::recursive_mutex> guard(m_threads_mutex);
+  for (auto thread_sp : m_threads) {
+    assert(thread_sp && "thread list should not have a NULL thread!");
+    if (!thread_sp)
+      continue;
+
+    error = thread_sp->RemoveHardwareBreakpoint(addr);
+  }
+
+  // Also remove from hardware breakpoint map of current process.
+  m_hw_breakpoints_map.erase(addr);
+
+  return error;
+}
+
 bool NativeProcessProtocol::RegisterNativeDelegate(
     NativeDelegate &native_delegate) {
   std::lock_guard<std::recursive_mutex> guard(m_delegates_mutex);
   if (std::find(m_delegates.begin(), m_delegates.end(), &native_delegate) !=
       m_delegates.end())
     return false;
 
   m_delegates.push_back(&native_delegate);
return m_breakpoint_list.AddRef(
       addr, size_hint, false,
       [this](lldb::addr_t addr, size_t size_hint, bool /* hardware */,
              NativeBreakpointSP &breakpoint_sp) -> Error {
         return SoftwareBreakpoint::CreateSoftwareBreakpoint(
             *this, addr, size_hint, breakpoint_sp);
       });
 }
 
-Error NativeProcessProtocol::RemoveBreakpoint(lldb::addr_t addr) {
+Error NativeProcessProtocol::RemoveBreakpoint(lldb::addr_t addr,
+                                              bool hardware) {
+  if (hardware)
+    return RemoveHardwareBreakpoint(addr);
+  else
     return m_breakpoint_list.DecRef(addr);
 }
 
 Error NativeProcessProtocol::EnableBreakpoint(lldb::addr_t addr) {
   return m_breakpoint_list.EnableBreakpoint(addr);
 }
 
 Error NativeProcessProtocol::DisableBreakpoint(lldb::addr_t addr) {
   return m_breakpoint_list.DisableBreakpoint(addr);

lldb/trunk/source/Host/common/NativeRegisterContext.cpp

 
 uint32_t NativeRegisterContext::NumSupportedHardwareBreakpoints() { return 0; }
 
 uint32_t NativeRegisterContext::SetHardwareBreakpoint(lldb::addr_t addr,
                                                       size_t size) {
   return LLDB_INVALID_INDEX32;
 }
 
+Error NativeRegisterContext::ClearAllHardwareBreakpoints() {
+  return Error("not implemented");
+}
+
 bool NativeRegisterContext::ClearHardwareBreakpoint(uint32_t hw_idx) {
   return false;
 }
 
+Error NativeRegisterContext::GetHardwareBreakHitIndex(uint32_t &bp_index,
+                                                      lldb::addr_t trap_addr) {
+  bp_index = LLDB_INVALID_INDEX32;
+  return Error("not implemented");
+}
+
 uint32_t NativeRegisterContext::NumSupportedHardwareWatchpoints() { return 0; }
 
 uint32_t NativeRegisterContext::SetHardwareWatchpoint(lldb::addr_t addr,
                                                       size_t size,
                                                       uint32_t watch_flags) {
   return LLDB_INVALID_INDEX32;
 }
 

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.h

public:
   lldb::addr_t GetSharedLibraryInfoAddress() override;
 
   size_t UpdateThreads() override;
 
   bool GetArchitecture(ArchSpec &arch) const override;
 
   Error SetBreakpoint(lldb::addr_t addr, uint32_t size, bool hardware) override;
 
+  Error RemoveBreakpoint(lldb::addr_t addr, bool hardware = false) override;
+
   void DoStopIDBumped(uint32_t newBumpId) override;
 
   Error GetLoadedModuleFileSpec(const char *module_path,
                                 FileSpec &file_spec) override;
 
   Error GetFileLoadAddress(const llvm::StringRef &file_name,
                            lldb::addr_t &load_addr) override;
 

lldb/trunk/source/Plugins/Process/Linux/NativeProcessLinux.cpp

if (error.Fail())
                "received error while checking for watchpoint hits, pid = "
                "{0}, error = {1}",
                thread.GetID(), error);
     if (wp_index != LLDB_INVALID_INDEX32) {
       MonitorWatchpoint(thread, wp_index);
       break;
     }
 
+    // If a breakpoint was hit, report it
+    uint32_t bp_index;
+    error = thread.GetRegisterContext()->GetHardwareBreakHitIndex(
+        bp_index, (uintptr_t)info.si_addr);
+    if (error.Fail())
+      LLDB_LOG(log, "received error while checking for hardware "
+                    "breakpoint hits, pid = {0}, error = {1}",
+               thread.GetID(), error);
+    if (bp_index != LLDB_INVALID_INDEX32) {
+      MonitorBreakpoint(thread);
+      break;
+    }
+
     // Otherwise, report step over
     MonitorTrace(thread);
     break;
   }
 
   case SI_KERNEL:
 #if defined __mips__
     // For mips there is no special signal for watchpoint
default:
     assert(false && "CPU type not supported!");
     return Error("CPU type not supported");
   }
 }
 
 Error NativeProcessLinux::SetBreakpoint(lldb::addr_t addr, uint32_t size,
                                         bool hardware) {
   if (hardware)
-    return Error("NativeProcessLinux does not support hardware breakpoints");
+    return SetHardwareBreakpoint(addr, size);
   else
     return SetSoftwareBreakpoint(addr, size);
 }
 
+Error NativeProcessLinux::RemoveBreakpoint(lldb::addr_t addr, bool hardware) {
+  if (hardware)
+    return RemoveHardwareBreakpoint(addr);
+  else
+    return NativeProcessProtocol::RemoveBreakpoint(addr);
+}
+
 Error NativeProcessLinux::GetSoftwareBreakpointTrapOpcode(
     size_t trap_opcode_size_hint, size_t &actual_opcode_size,
     const uint8_t *&trap_opcode_bytes) {
   // FIXME put this behind a breakpoint protocol class that can be set per
   // architecture.  Need MIPS support here.
   static const uint8_t g_aarch64_opcode[] = {0x00, 0x00, 0x20, 0xd4};
   // The ARM reference recommends the use of 0xe7fddefe and 0xdefe but the
   // linux kernel does otherwise.

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.h

public:
   Error ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
   Error WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
   //------------------------------------------------------------------
   // Hardware breakpoints/watchpoint mangement functions
   //------------------------------------------------------------------
 
+  uint32_t NumSupportedHardwareBreakpoints() override;
+
   uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
 
   bool ClearHardwareBreakpoint(uint32_t hw_idx) override;
 
+  Error ClearAllHardwareBreakpoints() override;
+
+  Error GetHardwareBreakHitIndex(uint32_t &bp_index,
+                                 lldb::addr_t trap_addr) override;
+
   uint32_t NumSupportedHardwareWatchpoints() override;
 
   uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size,
                                  uint32_t watch_flags) override;
 
   bool ClearHardwareWatchpoint(uint32_t hw_index) override;
 
   Error ClearAllHardwareWatchpoints() override;

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm.cpp

NativeRegisterContextLinux_arm::NativeRegisterContextLinux_arm(
   default:
     assert(false && "Unhandled target architecture.");
     break;
   }
 
   ::memset(&m_fpr, 0, sizeof(m_fpr));
   ::memset(&m_gpr_arm, 0, sizeof(m_gpr_arm));
   ::memset(&m_hwp_regs, 0, sizeof(m_hwp_regs));
+  ::memset(&m_hbr_regs, 0, sizeof(m_hbr_regs));
 
   // 16 is just a maximum value, query hardware for actual watchpoint count
   m_max_hwp_supported = 16;
   m_max_hbp_supported = 16;
   m_refresh_hwdebug_info = true;
 }
 
 uint32_t NativeRegisterContextLinux_arm::GetRegisterSetCount() const {

 bool NativeRegisterContextLinux_arm::IsGPR(unsigned reg) const {
   return reg <= m_reg_info.last_gpr; // GPR's come first.
 }
 
 bool NativeRegisterContextLinux_arm::IsFPR(unsigned reg) const {
   return (m_reg_info.first_fpr <= reg && reg <= m_reg_info.last_fpr);
 }
 
+uint32_t NativeRegisterContextLinux_arm::NumSupportedHardwareBreakpoints() {
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_BREAKPOINTS));
+
+  if (log)
+    log->Printf("NativeRegisterContextLinux_arm::%s()", __FUNCTION__);
+
+  Error error;
+
+  // Read hardware breakpoint and watchpoint information.
+  error = ReadHardwareDebugInfo();
+
+  if (error.Fail())
+    return 0;
+
+  LLDB_LOG(log, "{0}", m_max_hbp_supported);
+  return m_max_hbp_supported;
+}
+
 uint32_t
 NativeRegisterContextLinux_arm::SetHardwareBreakpoint(lldb::addr_t addr,
                                                       size_t size) {
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_BREAKPOINTS));
   LLDB_LOG(log, "addr: {0:x}, size: {1:x}", addr, size);
 
   // Read hardware breakpoint and watchpoint information.
   Error error = ReadHardwareDebugInfo();
 
   if (error.Fail())
     return LLDB_INVALID_INDEX32;
 
   uint32_t control_value = 0, bp_index = 0;
 
-  // Check if size has a valid hardware breakpoint length.
-  // Thumb instructions are 2-bytes but we have no way here to determine
-  // if target address is a thumb or arm instruction.
-  // TODO: Add support for setting thumb mode hardware breakpoints
-  if (size != 4 && size != 2)
+  // Setup address and control values.
+  // Use size to get a hint of arm vs thumb modes.
+  switch (size) {
+  case 2:
+    control_value = (0x3 << 5) | 7;
+    addr &= ~1;
+    break;
+  case 4:
+    control_value = (0xfu << 5) | 7;
+    addr &= ~3;
+    break;
+  default:
     return LLDB_INVALID_INDEX32;
+  }
 
-  // Setup control value
-  // Make the byte_mask into a valid Byte Address Select mask
-  control_value = 0xfu << 5;
-
-  // Enable this breakpoint and make it stop in privileged or user mode;
-  control_value |= 7;
-
-  // Make sure bits 1:0 are clear in our address
-  // This should be different once we support thumb here.
-  addr &= ~((lldb::addr_t)3);
-
-  // Iterate over stored hardware breakpoints
-  // Find a free bp_index or update reference count if duplicate.
+  // Iterate over stored breakpoints and find a free bp_index
   bp_index = LLDB_INVALID_INDEX32;
-
   for (uint32_t i = 0; i < m_max_hbp_supported; i++) {
     if ((m_hbr_regs[i].control & 1) == 0) {
       bp_index = i; // Mark last free slot
-    } else if (m_hbr_regs[i].address == addr &&
-               m_hbr_regs[i].control == control_value) {
-      bp_index = i; // Mark duplicate index
-      break;        // Stop searching here
+    } else if (m_hbr_regs[i].address == addr) {
+      return LLDB_INVALID_INDEX32; // We do not support duplicate breakpoints.
     }
   }
 
   if (bp_index == LLDB_INVALID_INDEX32)
     return LLDB_INVALID_INDEX32;
 
-  // Add new or update existing breakpoint
-  if ((m_hbr_regs[bp_index].control & 1) == 0) {
-    m_hbr_regs[bp_index].address = addr;
-    m_hbr_regs[bp_index].control = control_value;
-    m_hbr_regs[bp_index].refcount = 1;
+  // Update breakpoint in local cache
+  m_hbr_regs[bp_index].real_addr = addr;
 
-    // PTRACE call to set corresponding hardware breakpoint register.
-    error = WriteHardwareDebugRegs(eDREGTypeBREAK, bp_index);
 
-    if (error.Fail()) {
-      m_hbr_regs[bp_index].address = 0;
-      m_hbr_regs[bp_index].control &= ~1;
-      m_hbr_regs[bp_index].refcount = 0;
 
-      return LLDB_INVALID_INDEX32;
-    }
-  } else
-    m_hbr_regs[bp_index].refcount++;
 
   return bp_index;
 }
 
 bool NativeRegisterContextLinux_arm::ClearHardwareBreakpoint(uint32_t hw_idx) {
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_BREAKPOINTS));
   LLDB_LOG(log, "hw_idx: {0}", hw_idx);
 
-  Error error;
-
   // Read hardware breakpoint and watchpoint information.
-  error = ReadHardwareDebugInfo();
+  Error error = ReadHardwareDebugInfo();
 
   if (error.Fail())
     return false;
 
   if (hw_idx >= m_max_hbp_supported)
     return false;
 
-  // Update reference count if multiple references.
-  if (m_hbr_regs[hw_idx].refcount > 1) {
-    m_hbr_regs[hw_idx].refcount--;
-    return true;
-  } else if (m_hbr_regs[hw_idx].refcount == 1) {
-    // Create a backup we can revert to in case of failure.
-    lldb::addr_t tempAddr = m_hbr_regs[hw_idx].address;
-    uint32_t tempControl = m_hbr_regs[hw_idx].control;
-    uint32_t tempRefCount = m_hbr_regs[hw_idx].refcount;
 
-    m_hbr_regs[hw_idx].control &= ~1;
-    m_hbr_regs[hw_idx].address = 0;
-    m_hbr_regs[hw_idx].refcount = 0;
 
-    // PTRACE call to clear corresponding hardware breakpoint register.
-    WriteHardwareDebugRegs(eDREGTypeBREAK, hw_idx);
+  error = WriteHardwareDebugRegs(eDREGTypeBREAK, hw_idx);
 
-    if (error.Fail()) {
-      m_hbr_regs[hw_idx].control = tempControl;
-      m_hbr_regs[hw_idx].address = tempAddr;
-      m_hbr_regs[hw_idx].refcount = tempRefCount;
 
-      return false;
-    }
 
-    return true;
-  }
 
-  return false;
+Error NativeRegisterContextLinux_arm::GetHardwareBreakHitIndex(
+    uint32_t &bp_index, lldb::addr_t trap_addr) {
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_BREAKPOINTS));
+
+  if (log)
+    log->Printf("NativeRegisterContextLinux_arm64::%s()", __FUNCTION__);
+
+  lldb::addr_t break_addr;
+
+  for (bp_index = 0; bp_index < m_max_hbp_supported; ++bp_index) {
+    break_addr = m_hbr_regs[bp_index].address;
+
+    if ((m_hbr_regs[bp_index].control & 0x1) && (trap_addr == break_addr)) {
+      m_hbr_regs[bp_index].hit_addr = trap_addr;
+      return Error();
+    }
+  }
+
+  bp_index = LLDB_INVALID_INDEX32;
+  return Error();
+}
+
+Error NativeRegisterContextLinux_arm::ClearAllHardwareBreakpoints() {
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_BREAKPOINTS));
+
+  if (log)
+    log->Printf("NativeRegisterContextLinux_arm::%s()", __FUNCTION__);
+
+  Error error;
+
+  // Read hardware breakpoint and watchpoint information.
+  error = ReadHardwareDebugInfo();
+
+  if (error.Fail())
+    return error;
+
+  lldb::addr_t tempAddr = 0;
+  uint32_t tempControl = 0;
+
+  for (uint32_t i = 0; i < m_max_hbp_supported; i++) {
+    if (m_hbr_regs[i].control & 0x01) {
+      // Create a backup we can revert to in case of failure.
+      tempAddr = m_hbr_regs[i].address;
+      tempControl = m_hbr_regs[i].control;
+
+      // Clear breakpoints in local cache
+      m_hbr_regs[i].control &= ~1;
+      m_hbr_regs[i].address = 0;
+
+      // Ptrace call to update hardware debug registers
+      error = WriteHardwareDebugRegs(eDREGTypeBREAK, i);
+
+      if (error.Fail()) {
+        m_hbr_regs[i].control = tempControl;
+        m_hbr_regs[i].address = tempAddr;
+
+        return error;
+      }
+    }
+  }
+
+  return Error();
 }
 
 uint32_t NativeRegisterContextLinux_arm::NumSupportedHardwareWatchpoints() {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
 
   // Read hardware breakpoint and watchpoint information.
   Error error = ReadHardwareDebugInfo();
 
if (hwbType == eDREGTypeWATCH) {
     if (error.Fail())
       return error;
 
     error = NativeProcessLinux::PtraceWrapper(
         PTRACE_SETHBPREGS, m_thread.GetID(),
         (PTRACE_TYPE_ARG3)(intptr_t) - ((hwb_index << 1) + 2), ctrl_buf,
         sizeof(unsigned int));
   } else {
-    addr_buf = &m_hwp_regs[hwb_index].address;
-    ctrl_buf = &m_hwp_regs[hwb_index].control;
+    addr_buf = &m_hbr_regs[hwb_index].address;
+    ctrl_buf = &m_hbr_regs[hwb_index].control;
 
     error = NativeProcessLinux::PtraceWrapper(
         PTRACE_SETHBPREGS, m_thread.GetID(),
         (PTRACE_TYPE_ARG3)(intptr_t)((hwb_index << 1) + 1), addr_buf,
         sizeof(unsigned int));
 
     if (error.Fail())
       return error;

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.h

public:
   Error ReadAllRegisterValues(lldb::DataBufferSP &data_sp) override;
 
   Error WriteAllRegisterValues(const lldb::DataBufferSP &data_sp) override;
 
   //------------------------------------------------------------------
   // Hardware breakpoints/watchpoint mangement functions
   //------------------------------------------------------------------
 
+  uint32_t NumSupportedHardwareBreakpoints() override;
+
   uint32_t SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
 
   bool ClearHardwareBreakpoint(uint32_t hw_idx) override;
 
+  Error ClearAllHardwareBreakpoints() override;
+
+  Error GetHardwareBreakHitIndex(uint32_t &bp_index,
+                                 lldb::addr_t trap_addr) override;
+
   uint32_t NumSupportedHardwareWatchpoints() override;
 
   uint32_t SetHardwareWatchpoint(lldb::addr_t addr, size_t size,
                                  uint32_t watch_flags) override;
 
   bool ClearHardwareWatchpoint(uint32_t hw_index) override;
 
   Error ClearAllHardwareWatchpoints() override;

lldb/trunk/source/Plugins/Process/Linux/NativeRegisterContextLinux_arm64.cpp

NativeRegisterContextLinux_arm64::NativeRegisterContextLinux_arm64(
   default:
     llvm_unreachable("Unhandled target architecture.");
     break;
   }
 
   ::memset(&m_fpr, 0, sizeof(m_fpr));
   ::memset(&m_gpr_arm64, 0, sizeof(m_gpr_arm64));
   ::memset(&m_hwp_regs, 0, sizeof(m_hwp_regs));
+  ::memset(&m_hbr_regs, 0, sizeof(m_hbr_regs));
 
   // 16 is just a maximum value, query hardware for actual watchpoint count
   m_max_hwp_supported = 16;
   m_max_hbp_supported = 16;
   m_refresh_hwdebug_info = true;
 }
 
 uint32_t NativeRegisterContextLinux_arm64::GetRegisterSetCount() const {

 bool NativeRegisterContextLinux_arm64::IsGPR(unsigned reg) const {
   return reg <= m_reg_info.last_gpr; // GPR's come first.
 }
 
 bool NativeRegisterContextLinux_arm64::IsFPR(unsigned reg) const {
   return (m_reg_info.first_fpr <= reg && reg <= m_reg_info.last_fpr);
 }
 
+uint32_t NativeRegisterContextLinux_arm64::NumSupportedHardwareBreakpoints() {
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_BREAKPOINTS));
+
+  if (log)
+    log->Printf("NativeRegisterContextLinux_arm64::%s()", __FUNCTION__);
+
+  Error error;
+
+  // Read hardware breakpoint and watchpoint information.
+  error = ReadHardwareDebugInfo();
+
+  if (error.Fail())
+    return 0;
+
+  return m_max_hbp_supported;
+}
+
 uint32_t
 NativeRegisterContextLinux_arm64::SetHardwareBreakpoint(lldb::addr_t addr,
                                                         size_t size) {
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_BREAKPOINTS));
   LLDB_LOG(log, "addr: {0:x}, size: {1:x}", addr, size);
 
   // Read hardware breakpoint and watchpoint information.
   Error error = ReadHardwareDebugInfo();
 
   if (error.Fail())
     return LLDB_INVALID_INDEX32;
 
   uint32_t control_value = 0, bp_index = 0;
 
   // Check if size has a valid hardware breakpoint length.
   if (size != 4)
     return LLDB_INVALID_INDEX32; // Invalid size for a AArch64 hardware
                                  // breakpoint
 
   // Check 4-byte alignment for hardware breakpoint target address.
   if (addr & 0x03)
     return LLDB_INVALID_INDEX32; // Invalid address, should be 4-byte aligned.
 
   // Setup control value
   control_value = 0;
   control_value |= ((1 << size) - 1) << 5;
   control_value |= (2 << 1) | 1;
 
-  // Iterate over stored hardware breakpoints
-  // Find a free bp_index or update reference count if duplicate.
+  // Iterate over stored breakpoints and find a free bp_index
   bp_index = LLDB_INVALID_INDEX32;
   for (uint32_t i = 0; i < m_max_hbp_supported; i++) {
     if ((m_hbr_regs[i].control & 1) == 0) {
       bp_index = i; // Mark last free slot
-    } else if (m_hbr_regs[i].address == addr &&
-               m_hbr_regs[i].control == control_value) {
-      bp_index = i; // Mark duplicate index
-      break;        // Stop searching here
+    } else if (m_hbr_regs[i].address == addr) {
+      return LLDB_INVALID_INDEX32; // We do not support duplicate breakpoints.
     }
   }
 
   if (bp_index == LLDB_INVALID_INDEX32)
     return LLDB_INVALID_INDEX32;
 
-  // Add new or update existing breakpoint
-  if ((m_hbr_regs[bp_index].control & 1) == 0) {
-    m_hbr_regs[bp_index].address = addr;
-    m_hbr_regs[bp_index].control = control_value;
-    m_hbr_regs[bp_index].refcount = 1;
+  // Update breakpoint in local cache
+  m_hbr_regs[bp_index].real_addr = addr;
 
-    // PTRACE call to set corresponding hardware breakpoint register.
-    error = WriteHardwareDebugRegs(eDREGTypeBREAK);
 
-    if (error.Fail()) {
-      m_hbr_regs[bp_index].address = 0;
-      m_hbr_regs[bp_index].control &= ~1;
-      m_hbr_regs[bp_index].refcount = 0;
 
-      return LLDB_INVALID_INDEX32;
-    }
-  } else
-    m_hbr_regs[bp_index].refcount++;
 
   return bp_index;
 }
 
 bool NativeRegisterContextLinux_arm64::ClearHardwareBreakpoint(
     uint32_t hw_idx) {
-  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_BREAKPOINTS));
   LLDB_LOG(log, "hw_idx: {0}", hw_idx);
 
   // Read hardware breakpoint and watchpoint information.
   Error error = ReadHardwareDebugInfo();
 
   if (error.Fail())
     return false;
 
   if (hw_idx >= m_max_hbp_supported)
     return false;
 
-  // Update reference count if multiple references.
-  if (m_hbr_regs[hw_idx].refcount > 1) {
-    m_hbr_regs[hw_idx].refcount--;
-    return true;
-  } else if (m_hbr_regs[hw_idx].refcount == 1) {
-    // Create a backup we can revert to in case of failure.
-    lldb::addr_t tempAddr = m_hbr_regs[hw_idx].address;
-    uint32_t tempControl = m_hbr_regs[hw_idx].control;
-    uint32_t tempRefCount = m_hbr_regs[hw_idx].refcount;
 
-    m_hbr_regs[hw_idx].control &= ~1;
-    m_hbr_regs[hw_idx].address = 0;
-    m_hbr_regs[hw_idx].refcount = 0;
 
-    // PTRACE call to clear corresponding hardware breakpoint register.
-    WriteHardwareDebugRegs(eDREGTypeBREAK);
+  error = WriteHardwareDebugRegs(eDREGTypeBREAK);
 
-    if (error.Fail()) {
-      m_hbr_regs[hw_idx].control = tempControl;
-      m_hbr_regs[hw_idx].address = tempAddr;
-      m_hbr_regs[hw_idx].refcount = tempRefCount;
 
-      return false;
-    }
 
-    return true;
-  }
 
-  return false;
+Error NativeRegisterContextLinux_arm64::GetHardwareBreakHitIndex(
+    uint32_t &bp_index, lldb::addr_t trap_addr) {
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_BREAKPOINTS));
+
+  if (log)
+    log->Printf("NativeRegisterContextLinux_arm64::%s()", __FUNCTION__);
+
+  lldb::addr_t break_addr;
+
+  for (bp_index = 0; bp_index < m_max_hbp_supported; ++bp_index) {
+    break_addr = m_hbr_regs[bp_index].address;
+
+    if ((m_hbr_regs[bp_index].control & 0x1) && (trap_addr == break_addr)) {
+      m_hbr_regs[bp_index].hit_addr = trap_addr;
+      return Error();
+    }
+  }
+
+  bp_index = LLDB_INVALID_INDEX32;
+  return Error();
+}
+
+Error NativeRegisterContextLinux_arm64::ClearAllHardwareBreakpoints() {
+  Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_BREAKPOINTS));
+
+  if (log)
+    log->Printf("NativeRegisterContextLinux_arm64::%s()", __FUNCTION__);
+
+  Error error;
+
+  // Read hardware breakpoint and watchpoint information.
+  error = ReadHardwareDebugInfo();
+
+  if (error.Fail())
+    return error;
+
+  lldb::addr_t tempAddr = 0;
+  uint32_t tempControl = 0;
+
+  for (uint32_t i = 0; i < m_max_hbp_supported; i++) {
+    if (m_hbr_regs[i].control & 0x01) {
+      // Create a backup we can revert to in case of failure.
+      tempAddr = m_hbr_regs[i].address;
+      tempControl = m_hbr_regs[i].control;
+
+      // Clear watchpoints in local cache
+      m_hbr_regs[i].control &= ~1;
+      m_hbr_regs[i].address = 0;
+
+      // Ptrace call to update hardware debug registers
+      error = WriteHardwareDebugRegs(eDREGTypeBREAK);
+
+      if (error.Fail()) {
+        m_hbr_regs[i].control = tempControl;
+        m_hbr_regs[i].address = tempAddr;
+
+        return error;
+      }
+    }
+  }
+
+  return Error();
 }
 
 uint32_t NativeRegisterContextLinux_arm64::NumSupportedHardwareWatchpoints() {
   Log *log(ProcessPOSIXLog::GetLogIfAllCategoriesSet(POSIX_LOG_WATCHPOINTS));
 
   // Read hardware breakpoint and watchpoint information.
   Error error = ReadHardwareDebugInfo();
 

lldb/trunk/source/Plugins/Process/Linux/NativeThreadLinux.h

public:
 
   NativeRegisterContextSP GetRegisterContext() override;
 
   Error SetWatchpoint(lldb::addr_t addr, size_t size, uint32_t watch_flags,
                       bool hardware) override;
 
   Error RemoveWatchpoint(lldb::addr_t addr) override;
 
+  Error SetHardwareBreakpoint(lldb::addr_t addr, size_t size) override;
+
+  Error RemoveHardwareBreakpoint(lldb::addr_t addr) override;
+
 private:
   // ---------------------------------------------------------------------
   // Interface for friend classes
   // ---------------------------------------------------------------------
 
   /// Resumes the thread.  If @p signo is anything but
   /// LLDB_INVALID_SIGNAL_NUMBER, deliver that signal to the thread.
   Error Resume(uint32_t signo);
private:
   // Member Variables
   // ---------------------------------------------------------------------
   lldb::StateType m_state;
   ThreadStopInfo m_stop_info;
   NativeRegisterContextSP m_reg_context_sp;
   std::string m_stop_description;
   using WatchpointIndexMap = std::map<lldb::addr_t, uint32_t>;
   WatchpointIndexMap m_watchpoint_index_map;
+  WatchpointIndexMap m_hw_break_index_map;
   std::unique_ptr<SingleStepWorkaround> m_step_workaround;
 };
 
 typedef std::shared_ptr<NativeThreadLinux> NativeThreadLinuxSP;
 } // namespace process_linux
 } // namespace lldb_private
 
 #endif // #ifndef liblldb_NativeThreadLinux_H_

lldb/trunk/source/Plugins/Process/Linux/NativeThreadLinux.cpp

if (wp == m_watchpoint_index_map.end())
     return Error();
   uint32_t wp_index = wp->second;
   m_watchpoint_index_map.erase(wp);
   if (GetRegisterContext()->ClearHardwareWatchpoint(wp_index))
     return Error();
   return Error("Clearing hardware watchpoint failed.");
 }
 
+Error NativeThreadLinux::SetHardwareBreakpoint(lldb::addr_t addr, size_t size) {
+  if (m_state == eStateLaunching)
+    return Error();
+
+  Error error = RemoveHardwareBreakpoint(addr);
+  if (error.Fail())
+    return error;
+
+  NativeRegisterContextSP reg_ctx = GetRegisterContext();
+  uint32_t bp_index = reg_ctx->SetHardwareBreakpoint(addr, size);
+
+  if (bp_index == LLDB_INVALID_INDEX32)
+    return Error("Setting hardware breakpoint failed.");
+
+  m_hw_break_index_map.insert({addr, bp_index});
+  return Error();
+}
+
+Error NativeThreadLinux::RemoveHardwareBreakpoint(lldb::addr_t addr) {
+  auto bp = m_hw_break_index_map.find(addr);
+  if (bp == m_hw_break_index_map.end())
+    return Error();
+
+  uint32_t bp_index = bp->second;
+  if (GetRegisterContext()->ClearHardwareBreakpoint(bp_index)) {
+    m_hw_break_index_map.erase(bp);
+    return Error();
+  }
+
+  return Error("Clearing hardware breakpoint failed.");
+}
+
 Error NativeThreadLinux::Resume(uint32_t signo) {
   const StateType new_state = StateType::eStateRunning;
   MaybeLogStateChange(new_state);
   m_state = new_state;
 
   m_stop_info.reason = StopReason::eStopReasonNone;
   m_stop_description.clear();
 
   // If watchpoints have been set, but none on this thread,
   // then this is a new thread. So set all existing watchpoints.
   if (m_watchpoint_index_map.empty()) {
     NativeProcessLinux &process = GetProcess();
 
     const auto &watchpoint_map = process.GetWatchpointMap();
     GetRegisterContext()->ClearAllHardwareWatchpoints();
     for (const auto &pair : watchpoint_map) {
       const auto &wp = pair.second;
       SetWatchpoint(wp.m_addr, wp.m_size, wp.m_watch_flags, wp.m_hardware);
     }
   }
 
+  // Set all active hardware breakpoint on all threads.
+  if (m_hw_break_index_map.empty()) {
+    NativeProcessLinux &process = GetProcess();
+
+    const auto &hw_breakpoint_map = process.GetHardwareBreakpointMap();
+    GetRegisterContext()->ClearAllHardwareBreakpoints();
+    for (const auto &pair : hw_breakpoint_map) {
+      const auto &bp = pair.second;
+      SetHardwareBreakpoint(bp.m_addr, bp.m_size);
+    }
+  }
+
   intptr_t data = 0;
 
   if (signo != LLDB_INVALID_SIGNAL_NUMBER)
     data = signo;
 
   return NativeProcessLinux::PtraceWrapper(PTRACE_CONT, GetID(), nullptr,
                                            reinterpret_cast<void *>(data));
 }

lldb/trunk/source/Plugins/Process/gdb-remote/GDBRemoteCommunicationServerLLGS.cpp

GDBRemoteCommunicationServerLLGS::Handle_z(StringExtractorGDBRemote &packet) {
 
   // Parse out software or hardware breakpoint or watchpoint requested.
   packet.SetFilePos(strlen("z"));
   if (packet.GetBytesLeft() < 1)
     return SendIllFormedResponse(
         packet, "Too short z packet, missing software/hardware specifier");
 
   bool want_breakpoint = true;
+  bool want_hardware = false;
 
   const GDBStoppointType stoppoint_type =
       GDBStoppointType(packet.GetS32(eStoppointInvalid));
   switch (stoppoint_type) {
   case eBreakpointHardware:
     want_breakpoint = true;
+    want_hardware = true;
     break;
   case eBreakpointSoftware:
     want_breakpoint = true;
     break;
   case eWatchpointWrite:
     want_breakpoint = false;
     break;
   case eWatchpointRead:
GDBRemoteCommunicationServerLLGS::Handle_z(StringExtractorGDBRemote &packet) {
   std::numeric_limits<uint32_t>::max ());
   if (size == std::numeric_limits<uint32_t>::max ())
       return SendIllFormedResponse(packet, "Malformed z packet, failed to parse
   size argument");
   */
 
   if (want_breakpoint) {
     // Try to clear the breakpoint.
-    const Error error = m_debugged_process_sp->RemoveBreakpoint(addr);
+    const Error error =
+        m_debugged_process_sp->RemoveBreakpoint(addr, want_hardware);
     if (error.Success())
       return SendOKResponse();
     Log *log(GetLogIfAnyCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
     if (log)
       log->Printf("GDBRemoteCommunicationServerLLGS::%s pid %" PRIu64
                   " failed to remove breakpoint: %s",
                   __FUNCTION__, m_debugged_process_sp->GetID(),
                   error.AsCString());
if (!m_debugged_process_sp ||
     return SendErrorResponse(68);
 
   packet.SetFilePos(strlen("qWatchpointSupportInfo"));
   if (packet.GetBytesLeft() == 0)
     return SendOKResponse();
   if (packet.GetChar() != ':')
     return SendErrorResponse(67);
 
-  uint32_t num = m_debugged_process_sp->GetMaxWatchpoints();
+  auto hw_debug_cap = m_debugged_process_sp->GetHardwareDebugSupportInfo();
+
   StreamGDBRemote response;
-  response.Printf("num:%d;", num);
+  if (hw_debug_cap == llvm::None)
+    response.Printf("num:0;");
+  else
+    response.Printf("num:%d;", hw_debug_cap->second);
+
   return SendPacketNoLock(response.GetString());
 }
 
 GDBRemoteCommunication::PacketResult
 GDBRemoteCommunicationServerLLGS::Handle_qFileLoadAddress(
     StringExtractorGDBRemote &packet) {
   // Fail if we don't have a current process.
   if (!m_debugged_process_sp ||