Set correct ThreadStopInfo in case of trace event

[abhishek.aggarwal]

Summary

• The patch solves Bug 23478 and Bug 19311. Resolving Bug 23478 also resolves Bug 23039. Correct ThreadStopInfo is set for Linux and FreeBSD platforms.
• Summary: When a trace event is reported, we need to check whether the trace event lands at a breakpoint site.
  
  If it lands at a breakpoint site then set the thread's StopInfo with the reason 'breakpoint'. Else, set the reason to be 'Trace'.

Change-Id: I0af9765e782fd74bc0cead41548486009f8abb87
Signed-off-by: Abhishek Aggarwal <[e-mail]>

[clayborg]

Looks good.

[ovyalov]

LGTM

packages/Python/lldbsuite/test/functionalities/breakpoint/consecutive_breakpoints/TestConsecutiveBreakpoints.py

 import lldb
 import lldbsuite.test.lldbutil as lldbutil
 from lldbsuite.test.lldbtest import *
 
 class ConsecutiveBreakpointsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @expectedFailureAll("llvm.org/pr23478", oslist = not_in(["macosx"]))
     def test (self):
         self.build ()
         self.consecutive_breakpoints_tests()
 
     def consecutive_breakpoints_tests(self):
         exe = os.path.join (os.getcwd(), "a.out")
 
         # Create a target by the debugger.

packages/Python/lldbsuite/test/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py

def setUp(self):
                                                        '// Break here and check b has 0 children')
         self.main_fourth_call_line = line_number('pass-to-base.cpp',
                                                        '// Break here and check b still has 0 children')
         self.main_fifth_call_line = line_number('pass-to-base.cpp',
                                                        '// Break here and check b has one child now')
         self.main_sixth_call_line = line_number('pass-to-base.cpp',
                                                        '// Break here and check b has 0 children again')
 
-    @expectedFailureLinux("llvm.org/pr23039")
-    @expectedFailureFreeBSD("llvm.org/pr19311") # continue at a breakpoint does not work
     @expectedFailureWindows("llvm.org/pr24663")
-    @expectedFailurei386("to be figured out")
     @add_test_categories(['pyapi'])
     def test_get_dynamic_vals(self):
         """Test fetching C++ dynamic values from pointers & references."""
         """Get argument vals for the call stack when stopped on a breakpoint."""
         self.build(dictionary=self.getBuildFlags())
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target from the debugger.

source/Plugins/Process/FreeBSD/FreeBSDThread.cpp

if (reg_ctx)
         SetStopInfo (StopInfo::CreateStopReasonWithWatchpointID(*this,
                                                                 wp_sp->GetID()));
     }
 }
 
 void
 FreeBSDThread::TraceNotify(const ProcessMessage &message)
 {
+    Log *log (ProcessPOSIXLog::GetLogIfAllCategoriesSet (POSIX_LOG_THREAD));
+
+    // Try to resolve the breakpoint object corresponding to the current PC.
+    assert(GetRegisterContext());
+    lldb::addr_t pc = GetRegisterContext()->GetPC();
+    if (log)
+        log->Printf ("FreeBSDThread::%s () PC=0x%8.8" PRIx64, __FUNCTION__, pc);
+    lldb::BreakpointSiteSP bp_site(GetProcess()->GetBreakpointSiteList().FindByAddress(pc));
+
+    // If the current pc is a breakpoint site then set the StopInfo to Breakpoint.
+    // Otherwise, set the StopInfo to Watchpoint or Trace.
+    if (bp_site)
+    {
+        lldb::break_id_t bp_id = bp_site->GetID();
+        // If we have an operating system plug-in, we might have set a thread specific breakpoint using the
+        // operating system thread ID, so we can't make any assumptions about the thread ID so we must always
+        // report the breakpoint regardless of the thread.
+        if (bp_site->ValidForThisThread(this) || GetProcess()->GetOperatingSystem () != NULL)
+            SetStopInfo (StopInfo::CreateStopReasonWithBreakpointSiteID(*this, bp_id));
+        else
+        {
+            const bool should_stop = false;
+            SetStopInfo (StopInfo::CreateStopReasonWithBreakpointSiteID(*this, bp_id, should_stop));
+        }
+    }
+    else
+    {
         POSIXBreakpointProtocol* reg_ctx = GetPOSIXBreakpointProtocol();
         if (reg_ctx)
         {
             uint32_t num_hw_wps = reg_ctx->NumSupportedHardwareWatchpoints();
             uint32_t wp_idx;
             for (wp_idx = 0; wp_idx < num_hw_wps; wp_idx++)
             {
                 if (reg_ctx->IsWatchpointHit(wp_idx))
                 {
                     WatchNotify(message);
                     return;
                 }
             }
         }
-
         SetStopInfo (StopInfo::CreateStopReasonToTrace(*this));
     }
+}
 
 void
 FreeBSDThread::LimboNotify(const ProcessMessage &message)
 {
     SetStopInfo (lldb::StopInfoSP(new POSIXLimboStopInfo(*this)));
 }
 
 void

source/Plugins/Process/gdb-remote/ProcessGDBRemote.cpp

if (tid != LLDB_INVALID_THREAD_ID)
                 else
                 {
                     bool handled = false;
                     bool did_exec = false;
                     if (!reason.empty())
                     {
                         if (reason.compare("trace") == 0)
                         {
+                            addr_t pc = thread_sp->GetRegisterContext()->GetPC();
+                            lldb::BreakpointSiteSP bp_site_sp = thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(pc);
+
+                            // If the current pc is a breakpoint site then the StopInfo should be set to Breakpoint
+                            // Otherwise, it will be set to Trace.
+                            if (bp_site_sp)
+                            {
+                                // If the breakpoint is for this thread, then we'll report the hit, but if it is for another thread,
+                                // we can just report no reason.
+                                if (bp_site_sp->ValidForThisThread (thread_sp.get()))
+                                {
+                                    thread_sp->SetStopInfo (StopInfo::CreateStopReasonWithBreakpointSiteID (*thread_sp, bp_site_sp->GetID()));
+                                }
+                                else
+                                {
+                                    StopInfoSP invalid_stop_info_sp;
+                                    thread_sp->SetStopInfo (invalid_stop_info_sp);
+                                }
+                            }
+                            else
                               thread_sp->SetStopInfo (StopInfo::CreateStopReasonToTrace (*thread_sp));
                             handled = true;
                         }
                         else if (reason.compare("breakpoint") == 0)
                         {
                             addr_t pc = thread_sp->GetRegisterContext()->GetPC();
                             lldb::BreakpointSiteSP bp_site_sp = thread_sp->GetProcess()->GetBreakpointSiteList().FindByAddress(pc);
                             if (bp_site_sp)
                             {