Makes sense, will file a bug for it.
Sent from my iPad
> On Feb 23, 2016, at 5:10 PM, Jim Ingham <jing...@apple.com> wrote:
>
> That also is a bug. If it is going to do a public stop, it has to send a
> stop event.
>
> Jim
>
>> On Feb 23, 2016, at 2:52 PM, Jeffrey Tan <jeffrey.fu...@gmail.com> wrote:
>>
>> I am not sure. From the output, it seems lldb does stop at the entry
>> point(because you can issue "bt" command to dump the stack) in both
>> platforms; the problem seems to be that it did not emit the stopped event
>> for its stop on linux.
>>
>> On Tue, Feb 23, 2016 at 2:03 PM, Jim Ingham <jing...@apple.com> wrote:
>> If the linux side is not obeying "stop_at_entry" then that is a bug.
>>
>> Jim
>>
>>
>>> On Feb 23, 2016, at 1:49 PM, Jeffrey Tan via lldb-dev
>>> <lldb-dev@lists.llvm.org> wrote:
>>>
>>> Hi,
>>>
>>> I have got lldb launch working fine on my macbook for sometime. But when I
>>> try the same code on Linux, it failed to emit any stopping events during
>>> initial launch.
>>>
>>> When I run the reproduce code(listed at the end), I got the following
>>> different results:
>>>
>>> The key difference is that Macbook will emit a stopped event which caused
>>> our IDE UI to enter break mode, while Linux violates this assumption. Is
>>> this a bug?
>>>
>>> ======================Mac======================
>>> lldb_pythonpath:
>>> /Applications/Xcode.app/Contents/Developer/../SharedFrameworks/LLDB.framework/Resources/Python
>>> Launch result: success
>>> <Listener> Listening Thread ID: 4610625536
>>> dbg> Target event: ModulesLoaded
>>> Process event: StateChanged, Stopped
>>> Stop reason: 5
>>> dbg> bt
>>> * thread #1: tid = 0x101f01d, 0x00007fff6401a000 dyld`_dyld_start, stop
>>> reason = signal SIGSTOP
>>> * frame #0: 0x00007fff6401a000 dyld`_dyld_start
>>> ======================Mac======================
>>>
>>> ======================Linux======================
>>> python linux_launch.py
>>> find_lldb: <module 'lldb' from
>>> '/home/jeffreytan/project/llvm-bin/Debug+Asserts/lib/python2.7/site-packages/lldb/__init__.pyc'>
>>> Launch result: success
>>> <Listener> Listening Thread ID: 140316621375232
>>> dbg> bt
>>> * thread #1: tid = 2794520, 0x00007f6165b7bb00, name = 'foo', stop reason =
>>> signal SIGSTOP
>>> * frame #0: 0x00007f6165b7bb00
>>> ======================Linux======================
>>>
>>> ============================Repro 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 interctive_loop(debugger):
>>> while (True):
>>> stdout.write('dbg> ')
>>> command = stdin.readline().rstrip()
>>> if len(command) == 0:
>>> continue
>>> if command == 'q':
>>> return
>>> debugger.HandleCommand(command)
>>>
>>> def do_test():
>>> debugger = lldb.SBDebugger.Create()
>>> debugger.SetAsync(True)
>>> executable_path =
>>> '~/Personal/compiler/CompilerConstruction/code/compiler'
>>> target = debugger.CreateTargetWithFileAndArch(executable_path,
>>> lldb.LLDB_ARCH_DEFAULT)
>>>
>>> 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
>>> True, # Stop at entry
>>> error) # error
>>> print 'Launch result: %s' % str(error)
>>>
>>> running_signal = threading.Event()
>>> stopped_signal = threading.Event()
>>> event_thread = LLDBListenerThread(debugger, running_signal,
>>> stopped_signal)
>>> event_thread.start()
>>>
>>> interctive_loop(debugger)
>>>
>>> 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============================
>>> 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)
>>>
>>>
>>> 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 '<Listener> 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 '<Listener> 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 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], str(breakpoint))
>>>
>>> def _handle_unknown_event(self, event):
>>> print 'Unknown event'
>>>
>>> _______________________________________________
>>> lldb-dev mailing list
>>> lldb-dev@lists.llvm.org
>>> http://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-dev
>
_______________________________________________
lldb-dev mailing list
lldb-dev@lists.llvm.org
http://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-dev
