Thanks guys. I tried our IDE against a sample multithreading program on Mac, it correctly switches selected thread to the worker thread that triggers breakpoint, while on Linux(CentOS release 6.7) it failed to do that. Repro code:
=========================Output**=========================**
Launch result: success
Listening Thread ID: 139749072582400
running_signal wait
stopped_signal wait
Target event: ModulesLoaded
Target event: ModulesLoaded
Target event: ModulesLoaded
Target event: ModulesLoaded
Target event: ModulesLoaded
Target event: ModulesLoaded
Target event: ModulesLoaded
Target event: ModulesLoaded
Non stopping event: <lldb.SBEvent; proxy of <Swig Object of type ‘lldb::SBEvent *’ at 0x7f19e0975990> >
Process event: StateChanged, Running
Stop reason: 1
Process event: Stdout, Running
Stop reason: 1
Stdout:
main() : creating thread, 0
Process event: StateChanged, Stopped
after wait_for_process_run_then_stop
frame #0: 0x00007fcb7259ceb0 ld-linux-x86-64.so.2__GI__dl_debug_state frame #1: 0x00007fcb725a0c53 ld-linux-x86-64.so.2dl_open_worker + 499
frame #2: 0x00007fcb7259c286 ld-linux-x86-64.so.2_dl_catch_error + 102 frame #3: 0x00007fcb725a063a ld-linux-x86-64.so.2_dl_open + 186
frame #4: 0x00007fcb71963c60 libc.so.6do_dlopen + 64 frame #5: 0x00007fcb7259c286 ld-linux-x86-64.so.2_dl_catch_error + 102
frame #6: 0x00007fcb71963db7 libc.so.6__GI___libc_dlopen_mode + 71 frame #7: 0x00007fcb71be0eec libpthread.so.0pthread_cancel_init + 76
frame #8: 0x00007fcb71be104c libpthread.so.0_Unwind_ForcedUnwind + 60 frame #9: 0x00007fcb71bdef60 libpthread.so.0__GI___pthread_unwind + 64
frame #10: 0x00007fcb71bd9175 libpthread.so.0__pthread_exit + 37 frame #11: 0x0000000000400ac0 threadsmain + 195 at threads.cpp:31
frame #12: 0x00007fcb7185bd5d libc.so.6`__libc_start_main + 253
frame #13: 0x00000000004008f9 threads
Exiting listener thread
=========================Inferior**=========================**
#include
#include
#include <pthread.h>
using namespace std;
#define NUM_THREADS 1
void *PrintHello(void *threadid)
{
long tid;
tid = (long)threadid;
cout << "Hello World! Thread ID, " << tid << endl;
pthread_exit(NULL);
}
int main ()
{
pthread_t threads[NUM_THREADS];
int rc;
int i;
for( i=0; i < NUM_THREADS; i++ ){
cout << "main() : creating thread, " << i << endl;
rc = pthread_create(&threads[i], NULL,
PrintHello, (void *)i);
if (rc){
cout << “Error:unable to create thread,” << rc << endl;
exit(-1);
}
}
pthread_exit(NULL);
}
=========================LLDB python automation code=========================
main.py
Should be first for LLDB package to be added to search path.
from find_lldb import lldb
import sys
import os
import time
from sys import stdin, stdout
from event_thread import LLDBListenerThread
import threading
def wait_for_process_run_then_stop(running_signal, stopped_signal):
print ‘running_signal wait’
running_signal.wait()
running_signal.clear()
print ‘stopped_signal wait’
stopped_signal.wait()
stopped_signal.clear()
def do_test():
debugger = lldb.SBDebugger.Create()
debugger.SetAsync(True)
executable_path = ‘~/personal/cpp/temp/threads’
target = debugger.CreateTargetWithFileAndArch(executable_path, lldb.LLDB_ARCH_DEFAULT)
target.BreakpointCreateByName(‘PrintHello’)
listener = lldb.SBListener(‘Event Listener’)
error = lldb.SBError()
process = target.Launch (listener,
None, # argv
None, # envp
None, # stdin_path
None, # stdout_path
None, # stderr_path
None, # working directory
0, # launch flags
False, # Stop at entry
error) # error
print ‘Launch result: %s’ % str(error)
running_signal = threading.Event()
stopped_signal = threading.Event()
running_signal.set()
event_thread = LLDBListenerThread(debugger, running_signal, stopped_signal)
event_thread.start()
wait_for_process_run_then_stop(running_signal, stopped_signal)
print ‘after wait_for_process_run_then_stop’
activeThread = process.GetSelectedThread()
for frame in activeThread.frames:
print frame
event_thread.should_quit = True
event_thread.join()
lldb.SBDebugger.Destroy(debugger)
return debugger
def main():
debugger = do_test()
if name == ‘main’:
main()
===========event_thread.py============
import lldb
from threading import Thread
from sys import stdout
import thread
import threading
target_event_type_to_name_map = {
lldb.SBTarget.eBroadcastBitBreakpointChanged: ‘BreakpointChanged’,
lldb.SBTarget.eBroadcastBitWatchpointChanged: ‘WatchpointChanged’,
lldb.SBTarget.eBroadcastBitModulesLoaded: ‘ModulesLoaded’,
lldb.SBTarget.eBroadcastBitModulesUnloaded: ‘ModulesUnloaded’,
lldb.SBTarget.eBroadcastBitSymbolsLoaded: ‘SymbolsLoaded’,
}
process_event_type_to_name_map = {
lldb.SBProcess.eBroadcastBitStateChanged: ‘StateChanged’,
lldb.SBProcess.eBroadcastBitSTDOUT: ‘Stdout’,
lldb.SBProcess.eBroadcastBitSTDERR: ‘Stderr’,
lldb.SBProcess.eBroadcastBitInterrupt: ‘Interupt’,
}
breakpoint_event_type_to_name_map = {
lldb.eBreakpointEventTypeAdded: ‘Added’,
lldb.eBreakpointEventTypeCommandChanged: ‘Command Changed’,
lldb.eBreakpointEventTypeConditionChanged: ‘Condition Changed’,
lldb.eBreakpointEventTypeDisabled: ‘Disabled’,
lldb.eBreakpointEventTypeEnabled: ‘Enabled’,
lldb.eBreakpointEventTypeIgnoreChanged: ‘Ignore Changed’,
lldb.eBreakpointEventTypeInvalidType: ‘Invalid Type’,
lldb.eBreakpointEventTypeLocationsAdded: ‘Location Added’,
lldb.eBreakpointEventTypeLocationsRemoved: ‘Location Removed’,
lldb.eBreakpointEventTypeLocationsResolved: ‘Location Resolved’,
lldb.eBreakpointEventTypeRemoved: ‘Removed’,
lldb.eBreakpointEventTypeThreadChanged: ‘Thread Changed’,
}
process_state_name_map = {
lldb.eStateRunning: ‘Running’,
lldb.eStateStepping: ‘Stepping’,
lldb.eStateAttaching: ‘Attaching’,
lldb.eStateConnected: ‘Connected’,
lldb.eStateCrashed: ‘Crashed’,
lldb.eStateDetached: ‘Detached’,
lldb.eStateExited: ‘Exited’,
lldb.eStateInvalid: ‘Invalid’,
lldb.eStateLaunching: ‘Launching’,
lldb.eStateStopped: ‘Stopped’,
lldb.eStateSuspended: ‘Suspended’,
lldb.eStateUnloaded: ‘Unloaded’,
}
class LLDBListenerThread(Thread):
should_quit = False
def init(self, debugger, running_signal=None, stopped_sigal=None):
Thread.init(self)
self._running_signal = running_signal
self._stopped_sigal = stopped_sigal
process = debugger.GetSelectedTarget().process
self.listener = debugger.GetListener()
self._add_listener_to_process(process)
self._add_listener_to_target(process.target)
‘’‘self.listener.StartListeningForEventClass(debugger, lldb.SBTarget.GetBroadcasterClassName(),
lldb.SBTarget.eBroadcastBitBreakpointChanged |
lldb.SBTarget.eBroadcastBitWatchpointChanged |
lldb.SBTarget.eBroadcastBitModulesLoaded |
lldb.SBTarget.eBroadcastBitModulesUnloaded |
lldb.SBTarget.eBroadcastBitSymbolsLoaded)
self.listener.StartListeningForEventClass(debugger, lldb.SBProcess.GetBroadcasterClassName(),
lldb.SBProcess.eBroadcastBitStateChanged |
lldb.SBProcess.eBroadcastBitSTDOUT |
lldb.SBProcess.eBroadcastBitSTDERR |
lldb.SBProcess.eBroadcastBitInterrupt)’‘’
‘’‘self.listener.StartListeningForEventClass(debugger, lldb.SBThread.GetBroadcasterClassName(),
lldb.SBThread.eBroadcastBitStackChanged | lldb.SBThread.eBroadcastBitThreadSuspended |
lldb.SBThread.eBroadcastBitThreadResumed | lldb.SBThread.eBroadcastBitSelectedFrameChanged | lldb.SBThread.eBroadcastBitThreadSelected)’‘’
def _add_listener_to_target(self, target):
Listen for breakpoint/watchpoint events (Added/Removed/Disabled/etc).
broadcaster = target.GetBroadcaster()
mask = lldb.SBTarget.eBroadcastBitBreakpointChanged | lldb.SBTarget.eBroadcastBitWatchpointChanged | lldb.SBTarget.eBroadcastBitModulesLoaded
broadcaster.AddListener(self.listener, mask)
def _add_listener_to_process(self, process):
Listen for process events (Start/Stop/Interrupt/etc).
broadcaster = process.GetBroadcaster()
mask = lldb.SBProcess.eBroadcastBitStateChanged | lldb.SBProcess.eBroadcastBitSTDOUT | lldb.SBProcess.eBroadcastBitSTDERR | lldb.SBProcess.eBroadcastBitInterrupt
broadcaster.AddListener(self.listener, mask)
def run(self):
print ‘ Listening Thread ID: %d’ % thread.get_ident()
while not self.should_quit:
event = lldb.SBEvent()
if self.listener.WaitForEvent(1, event):
if lldb.SBTarget.EventIsTargetEvent(event):
self._handle_target_event(event)
elif lldb.SBProcess.EventIsProcessEvent(event):
self._handle_process_event(event)
elif lldb.SBBreakpoint.EventIsBreakpointEvent(event):
self._handle_breakpoint_event(event)
elif lldb.SBThread.EventIsThreadEvent(event):
self._handle_thread_event(event)
else:
self._handle_unknown_event(event)
print ‘ Exiting listener thread’
def _handle_target_event(self, event):
event_type = event.GetType()
print ‘Target event: %s’ % target_event_type_to_name_map[event_type]
def _handle_process_event(self, event):
if lldb.SBProcess.GetRestartedFromEvent(event):
print ‘Non stopping event: %s’ % str(event)
return
process = lldb.SBProcess.GetProcessFromEvent(event)
event_type = event.GetType()
print ‘Process event: %s, %s’ % (process_event_type_to_name_map[event_type], process_state_name_map[process.state])
if process.state == lldb.eStateExited:
self.should_quit = True
elif process.state == lldb.eStateStopped:
if self._stopped_sigal:
self._stopped_sigal.set()
else:
if self._running_signal:
self._running_signal.set()
thread = process.selected_thread
print ‘Stop reason: %d’ % thread.GetStopReason()
if event_type == lldb.SBProcess.eBroadcastBitSTDOUT:
print ‘Stdout:’
while True:
output = process.GetSTDOUT(1024)
if output is None or len(output) == 0:
break
stdout.write(output)
def _handle_breakpoint_event(self, event):
breakpoint = lldb.SBBreakpoint.GetBreakpointFromEvent(event)
event_type = lldb.SBBreakpoint.GetBreakpointEventTypeFromEvent(event)
print 'Breakpoint event: [%s] %s ’ % (
breakpoint_event_type_to_name_map[event_type],
self._get_description_from_object(breakpoint))
def _handle_unknown_event(self, event):
print(‘Unknown event: %d %s %s’ % (
event.GetType(),
lldb.SBEvent.GetCStringFromEvent(event),
self._get_description_from_object(event)))
def _get_description_from_object(self, lldb_object):
description_stream = lldb.SBStream()
lldb_object.GetDescription(description_stream)
return description_stream.GetData()