[lldb] Make process plugins check whether a hardware breakpoint is required

[tatyana-krasnukha]

Un-skip TestRequireHWBreakpoints.py on Windows, now it works as expected.

lldb/source/Plugins/Process/FreeBSD/ProcessFreeBSD.cpp

case llvm::Triple::x86_64:
     break;
   }
 
   bp_site->SetTrapOpcode(opcode, opcode_size);
   return opcode_size;
 }
 
 Status ProcessFreeBSD::EnableBreakpointSite(BreakpointSite *bp_site) {
+  if (bp_site->HardwareRequired())
+    return Status("Hardware breakpoints are not supported.");
+
   return EnableSoftwareBreakpoint(bp_site);
 }
 
 Status ProcessFreeBSD::DisableBreakpointSite(BreakpointSite *bp_site) {
   return DisableSoftwareBreakpoint(bp_site);
 }
 
 Status ProcessFreeBSD::EnableWatchpoint(Watchpoint *wp, bool notify) {

lldb/source/Plugins/Process/MacOSX-Kernel/ProcessKDP.cpp

 Status ProcessKDP::DoDeallocateMemory(lldb::addr_t addr) {
   Status error;
   error.SetErrorString(
       "memory deallocation not supported in kdp remote debugging");
   return error;
 }
 
 Status ProcessKDP::EnableBreakpointSite(BreakpointSite *bp_site) {
+  if (bp_site->HardwareRequired())
+    return Status("Hardware breakpoints are not supported.");
+
   if (m_comm.LocalBreakpointsAreSupported()) {
     Status error;
     if (!bp_site->IsEnabled()) {
       if (m_comm.SendRequestBreakpoint(true, bp_site->GetLoadAddress())) {
         bp_site->SetEnabled(true);
         bp_site->SetType(BreakpointSite::eExternal);
       } else {
         error.SetErrorString("KDP set breakpoint failed");

lldb/source/Plugins/Process/Windows/Common/ProcessWindows.cpp

 
 lldb_private::ConstString ProcessWindows::GetPluginName() {
   return GetPluginNameStatic();
 }
 
 uint32_t ProcessWindows::GetPluginVersion() { return 1; }
 
 Status ProcessWindows::EnableBreakpointSite(BreakpointSite *bp_site) {
+  if (bp_site->HardwareRequired())
+    return Status("Hardware breakpoints are not supported.");
+
   Log *log = ProcessWindowsLog::GetLogIfAny(WINDOWS_LOG_BREAKPOINTS);
   LLDB_LOG(log, "bp_site = {0:x}, id={1}, addr={2:x}", bp_site,
            bp_site->GetID(), bp_site->GetLoadAddress());
 
   Status error = EnableSoftwareBreakpoint(bp_site);
   if (!error.Success())
     LLDB_LOG(log, "error: {0}", error);
   return error;

lldb/test/API/functionalities/breakpoint/hardware_breakpoints/require_hw_breakpoints/TestRequireHWBreakpoints.py

def test_breakpoint(self):
         exe = self.getBuildArtifact("a.out")
         target = self.dbg.CreateTarget(exe)
 
         self.runCmd("settings set target.require-hardware-breakpoint true")
 
         breakpoint = target.BreakpointCreateByLocation("main.c", 1)
         self.assertTrue(breakpoint.IsHardware())
 
-    @skipIfWindows
     @expectedFailure(supports_hw_breakpoints)
     def test_step_range(self):
         """Test stepping when hardware breakpoints are required."""
         self.build()
 
         _, _, thread, _ = lldbutil.run_to_line_breakpoint(
             self, lldb.SBFileSpec("main.c"), 1)
 
         self.runCmd("settings set target.require-hardware-breakpoint true")
 
         # Ensure we fail in the interpreter.
         self.expect("thread step-in")
         self.expect("thread step-in", error=True)
 
         # Ensure we fail when stepping through the API.
         error = lldb.SBError()
         thread.StepInto('', 4, error)
         self.assertTrue(error.Fail())
         self.assertTrue("Could not create hardware breakpoint for thread plan"
                         in error.GetCString())
 
-    @skipIfWindows
     @expectedFailure(supports_hw_breakpoints)
     def test_step_out(self):
         """Test stepping out when hardware breakpoints are required."""
         self.build()
 
         _, _, thread, _ = lldbutil.run_to_line_breakpoint(
             self, lldb.SBFileSpec("main.c"), 1)
 
         self.runCmd("settings set target.require-hardware-breakpoint true")
 
         # Ensure this fails in the command interpreter.
         self.expect("thread step-out", error=True)
 
         # Ensure we fail when stepping through the API.
         error = lldb.SBError()
         thread.StepOut(error)
         self.assertTrue(error.Fail())
         self.assertTrue("Could not create hardware breakpoint for thread plan"
                         in error.GetCString())
 
-    @skipIfWindows
     @expectedFailure(supports_hw_breakpoints)
     def test_step_over(self):
         """Test stepping over when hardware breakpoints are required."""
         self.build()
 
         _, _, thread, _ = lldbutil.run_to_line_breakpoint(
             self, lldb.SBFileSpec("main.c"), 7)
 
         self.runCmd("settings set target.require-hardware-breakpoint true")
 
         # Step over doesn't fail immediately but fails later on.
         self.expect(
             "thread step-over",
             error=True,
             substrs=[
                 'error: Could not create hardware breakpoint for thread plan.'
             ])
 
-    @skipIfWindows
     @expectedFailure(supports_hw_breakpoints)
     def test_step_until(self):
         """Test stepping until when hardware breakpoints are required."""
         self.build()
 
         _, _, thread, _ = lldbutil.run_to_line_breakpoint(
             self, lldb.SBFileSpec("main.c"), 7)