replace multimap with map of vectors

Author: dlav-sc

lldb/source/Plugins/Instruction/RISCV/EmulateInstructionRISCV.cpp

@@ -1809,7 +1809,7 @@ RISCVSingleStepBreakpointLocationsPredictor::GetBreakpointLocations(
               "RISCVSingleStepBreakpointLocationsPredictor::%s: can't find "
               "corresponding load reserve insturuction",
               __FUNCTION__);
-    return {*pc + inst->is_rvc ? 2u : 4u};
+    return {*pc + (inst->is_rvc ? 2u : 4u)};
   }
 
   return SingleStepBreakpointLocationsPredictor::GetBreakpointLocations(status);
@@ -1874,7 +1874,7 @@ RISCVSingleStepBreakpointLocationsPredictor::HandleAtomicSequence(
               "RISCVSingleStepBreakpointLocationsPredictor::%s: can't find "
               "corresponding store conditional insturuction",
               __FUNCTION__);
-    return {entry_pc + lr_inst->is_rvc ? 2u : 4u};
+    return {entry_pc + (lr_inst->is_rvc ? 2u : 4u)};
   }
 
   lldb::addr_t exit_pc = pc;

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

@@ -324,17 +324,15 @@ void NativeProcessFreeBSD::MonitorSIGTRAP(lldb::pid_t pid) {
         auto thread_info =
             m_threads_stepping_with_breakpoint.find(thread->GetID());
         if (thread_info != m_threads_stepping_with_breakpoint.end() &&
-            thread_info->second == regctx.GetPC()) {
+            llvm::is_contained(thread_info->second, regctx.GetPC())) {
           thread->SetStoppedByTrace();
-          while (thread_info != m_threads_stepping_with_breakpoint.end() {
-            Status brkpt_error = RemoveBreakpoint(thread_info->second);
+          for (auto &&bp_addr : thread_info->second) {
+            Status brkpt_error = RemoveBreakpoint(bp_addr);
             if (brkpt_error.Fail())
               LLDB_LOG(log, "pid = {0} remove stepping breakpoint: {1}",
                        thread_info->first, brkpt_error);
-            m_threads_stepping_with_breakpoint.erase(thread_info);
-            thread_info =
-                m_threads_stepping_with_breakpoint.find(thread->GetID());
           }
+          m_threads_stepping_with_breakpoint.erase(thread_info);
         } else
           thread->SetStoppedByBreakpoint();
         FixupBreakpointPCAsNeeded(*thread);

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

@@ -833,7 +833,7 @@ void NativeProcessLinux::MonitorBreakpoint(NativeThreadLinux &thread) {
   auto stepping_with_bp_it =
       m_threads_stepping_with_breakpoint.find(thread.GetID());
   if (stepping_with_bp_it != m_threads_stepping_with_breakpoint.end() &&
-      stepping_with_bp_it->second == reg_ctx.GetPC())
+      llvm::is_contained(stepping_with_bp_it->second, reg_ctx.GetPC()))
     thread.SetStoppedByTrace();
 
   StopRunningThreads(thread.GetID());
@@ -1960,10 +1960,12 @@ void NativeProcessLinux::SignalIfAllThreadsStopped() {
   // Clear any temporary breakpoints we used to implement software single
   // stepping.
   for (const auto &thread_info : m_threads_stepping_with_breakpoint) {
-    Status error = RemoveBreakpoint(thread_info.second);
-    if (error.Fail())
-      LLDB_LOG(log, "pid = {0} remove stepping breakpoint: {1}",
-               thread_info.first, error);
+    for (auto &&bp_addr : thread_info.second) {
+      Status error = RemoveBreakpoint(bp_addr);
+      if (error.Fail())
+        LLDB_LOG(log, "pid = {0} remove stepping breakpoint: {1}",
+                 thread_info.first, error);
+    }
   }
   m_threads_stepping_with_breakpoint.clear();
 

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

@@ -138,8 +138,8 @@ Status NativeProcessSoftwareSingleStep::SetupSoftwareSingleStepping(
     error = SetSoftwareBreakpoint(bp_addr, *bp_size, process);
     if (error.Fail())
       return error;
-
-    m_threads_stepping_with_breakpoint.insert({thread.GetID(), bp_addr});
   }
+
+  m_threads_stepping_with_breakpoint.insert({thread.GetID(), bp_locations});
   return error;
 }

lldb/source/Plugins/Process/Utility/NativeProcessSoftwareSingleStep.h

@@ -23,7 +23,7 @@ class NativeProcessSoftwareSingleStep {
 protected:
   // List of thread ids stepping with a breakpoint with the address of
   // the relevan breakpoint
-  std::multimap<lldb::tid_t, lldb::addr_t> m_threads_stepping_with_breakpoint;
+  std::map<lldb::tid_t, std::vector<lldb::addr_t>> m_threads_stepping_with_breakpoint;
 };
 
 } // namespace lldb_private

lldb/test/API/riscv/step/TestSoftwareStep.py

@@ -10,7 +10,7 @@
 
 
 class TestSoftwareStep(TestBase):
-    def do_sequence_test(filename, bkpt_name):
+    def do_sequence_test(self, filename, bkpt_name):
         source_file = filename + ".c"
         exe_file = filename + ".x"
 
@@ -30,15 +30,15 @@ def do_sequence_test(filename, bkpt_name):
 
         return pc - entry_pc
 
-    @skipIf(archs=no_match(re.compile("rv*")))
+    @skipIf(archs=no_match("rv*"))
     def test_cas(self):
         """
         This test verifies LLDB instruction step handling of a proper lr/sc pair.
         """
-        difference = do_sequence_test("main", "cas")
-        self.assertTrue(difference > 0x10)
+        difference = self.do_sequence_test("main", "cas")
+        self.assertEqual(difference, 0x1a)
 
-    @skipIf(archs=no_match(re.compile("rv*")))
+    @skipIf(archs=no_match("rv*"))
     def test_branch_cas(self):
         """
         LLDB cannot predict the actual state of registers within a critical section (i.e., inside an atomic
@@ -51,25 +51,25 @@ def test_branch_cas(self):
         test is nearly identical to the previous one, except for the branch condition, which is inverted and
         will result in a taken jump.
         """
-        difference = do_sequence_test("branch", "branch_cas")
-        self.assertTrue(difference > 0x10)
+        difference = self.do_sequence_test("branch", "branch_cas")
+        self.assertEqual(difference, 0x1a)
 
-    @skipIf(archs=no_match(re.compile("rv*")))
+    @skipIf(archs=no_match("rv*"))
     def test_incomplete_sequence_without_lr(self):
         """
         This test verifies the behavior of a standalone sc instruction without a preceding lr. Since the sc
         lacks the required lr pairing, LLDB should treat it as a non-atomic store rather than part of an
         atomic sequence.
         """
-        difference = do_sequence_test("incomplete_sequence_without_lr", "incomplete_cas")
-        self.assertTrue(difference == 0x4)
+        difference = self.do_sequence_test("incomplete_sequence_without_lr", "incomplete_cas")
+        self.assertEqual(difference, 0x4)
 
-    @skipIf(archs=no_match(re.compile("rv*")))
+    @skipIf(archs=no_match("rv*"))
     def test_incomplete_sequence_without_sc(self):
         """
         This test checks the behavior of a standalone lr instruction without a subsequent sc. Since the lr
         lacks its required sc counterpart, LLDB should treat it as a non-atomic load rather than part of an
         atomic sequence.
         """
-        difference = do_sequence_test("incomplete_sequence_without_sc", "incomplete_cas")
-        self.assertTrue(difference == 0x4)
+        difference = self.do_sequence_test("incomplete_sequence_without_sc", "incomplete_cas")
+        self.assertEqual(difference, 0x4)