Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OS));
- // First thing we have to do is get the API lock, and the run lock. We're going to change the thread
- // content of the process, and we're going to use python, which requires the API lock to do it.
- // So get & hold that. This is a recursive lock so we can grant it to any Python code called on the stack below us.
+ // First thing we have to do is to try to get the API lock, and the run lock.
+ // We're going to change the thread content of the process, and we're going
+ // to use python, which requires the API lock to do it.
+ //
+ // If someone already has the API lock, that is ok, we just want to avoid
+ // external code from making new API calls while this call is happening.
+ //
+ // This is a recursive lock so we can grant it to any Python code called on
+ // the stack below us.
Target &target = m_process->GetTarget();
- Mutex::Locker api_locker (target.GetAPIMutex());
+ Mutex::Locker api_locker;
+ api_locker.TryLock(target.GetAPIMutex());
if (log)
log->Printf ("OperatingSystemPython::UpdateThreadList() fetching thread data from python for pid %" PRIu64, m_process->GetID());
// 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. We don't need to worry about stepping over the breakpoint here, that
// will be taken care of when the thread resumes and notices that there's a breakpoint under the pc.
- if (bp_site_sp->ValidForThisThread (&thread))
+ // 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_sp->ValidForThisThread (&thread) || thread.GetProcess()->GetOperatingSystem () != NULL)
return StopInfo::CreateStopReasonWithBreakpointSiteID (thread, bp_site_sp->GetID());
else
return StopInfoSP();
}
-
+
// Don't call this a trace if we weren't single stepping this thread.
if (is_trace_if_actual_breakpoint_missing && thread.GetTemporaryResumeState() == eStateStepping)
{
self.buildDwarf()
self.run_python_os_funcionality()
+ @skipUnlessDarwin
+ @dsym_test
+ def test_python_os_step_dsym(self):
+ """Test that the Python operating system plugin works correctly when single stepping a virtual thread"""
+ self.buildDsym()
+ self.run_python_os_step()
+
+ @dwarf_test
+ def run_python_os_step_dwarf(self):
+ """Test that the Python operating system plugin works correctly when single stepping a virtual thread"""
+ self.buildDwarf()
+ self.run_python_os_step()
+
def verify_os_thread_registers(self, thread):
frame = thread.GetFrameAtIndex(0)
registers = frame.GetRegisters().GetValueAtIndex(0)
thread = process.GetThreadByID(0x333333333);
self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x333333333 after we unload the python OS plug-in");
+ def run_python_os_step(self):
+ """Test that the Python operating system plugin works correctly and allows single stepping of a virtual thread that is backed by a real thread"""
+
+ # Set debugger into synchronous mode
+ self.dbg.SetAsync(False)
+
+ # Create a target by the debugger.
+ cwd = os.getcwd()
+ exe = os.path.join(cwd, "a.out")
+ python_os_plugin_path = os.path.join(cwd, "operating_system2.py")
+ target = self.dbg.CreateTarget(exe)
+ self.assertTrue(target, VALID_TARGET)
+
+ # Set breakpoints inside and outside methods that take pointers to the containing struct.
+ lldbutil.run_break_set_by_source_regexp (self, "// Set breakpoint here")
+
+ # Register our shared libraries for remote targets so they get automatically uploaded
+ arguments = None
+ environment = None
+
+ # Now launch the process, and do not stop at entry point.
+ process = target.LaunchSimple (arguments, environment, self.get_process_working_directory())
+ self.assertTrue(process, PROCESS_IS_VALID)
+
+ # Make sure there are no OS plug-in created thread when we first stop at our breakpoint in main
+ thread = process.GetThreadByID(0x111111111);
+ self.assertFalse (thread.IsValid(), "Make sure there is no thread 0x111111111 before we load the python OS plug-in");
+
+
+ # Now load the python OS plug-in which should update the thread list and we should have
+ # OS plug-in created threads with the IDs: 0x111111111, 0x222222222, 0x333333333
+ command = "settings set target.process.python-os-plugin-path '%s'" % python_os_plugin_path
+ self.dbg.HandleCommand(command)
+
+ # Verify our OS plug-in threads showed up
+ thread = process.GetThreadByID(0x111111111);
+ self.assertTrue (thread.IsValid(), "Make sure there is a thread 0x111111111 after we load the python OS plug-in");
+
+ frame = thread.GetFrameAtIndex(0)
+ self.assertTrue(frame.IsValid(), "Make sure we get a frame from thread 0x111111111")
+ line_entry = frame.GetLineEntry()
+
+ self.assertTrue(line_entry.GetFileSpec().GetFilename() == 'main.c', "Make sure we stopped on line 5 in main.c")
+ self.assertTrue(line_entry.GetLine() == 5, "Make sure we stopped on line 5 in main.c")
+
+ # Now single step thread 0x111111111 and make sure it does what we need it to
+ thread.StepOver()
+
+ frame = thread.GetFrameAtIndex(0)
+ self.assertTrue(frame.IsValid(), "Make sure we get a frame from thread 0x111111111")
+ line_entry = frame.GetLineEntry()
+
+ self.assertTrue(line_entry.GetFileSpec().GetFilename() == 'main.c', "Make sure we stepped from line 5 to line 6 in main.c")
+ self.assertTrue(line_entry.GetLine() == 6, "Make sure we stepped from line 5 to line 6 in main.c")
+
+
if __name__ == '__main__':
import atexit
lldb.SBDebugger.Initialize()
projects / platform / upstream / llvm.git / commitdiff