def enable(self, params):
process = self.debugger.GetSelectedTarget().process
self.event_thread = LLDBListenerThread(
server=self.socket,
location_serializer=self.locationSerializer,
remote_object_manager=self.remoteObjectManager,
module_source_path_updater=self.moduleSourcePathUpdater,
thread_manager = self.thread_manager,
process=process)
self.moduleSourcePathUpdater.modules_updated()
self.event_thread.start()
return {}
def main():
arguments = parse_args()
lldb_python_path = getattr(arguments, 'lldb_python_path', None)
if lldb_python_path is not None:
set_custom_lldb_path(os.path.expanduser(lldb_python_path))
lldb = get_lldb()
debugger = lldb.SBDebugger.Create()
is_attach = (getattr(arguments, 'executable_path', None) == None)
is_interactive = getattr(arguments, 'interactive', False)
ipc_channel = IpcChannel(is_interactive)
start_debugging(debugger, arguments, ipc_channel, is_attach)
register_signal_handler(debugger)
chrome_channel = ChromeChannel()
debugger_store = DebuggerStore(
debugger,
chrome_channel,
ipc_channel,
is_attach,
str(getattr(arguments, 'basepath', '.')))
try:
app = ChromeDevToolsDebuggerApp(debugger_store, getattr(arguments, 'port', 0))
# Tell IDE server is ready.
log_debug('Port: %s' % app.debug_server.server_port)
event_thread = LLDBListenerThread(debugger_store, app)
event_thread.start()
if is_interactive:
app.start_nonblocking()
interactive_loop(debugger)
else:
app.start_blocking()
except KeyboardInterrupt: # Force app to exit on Ctrl-C.
os._exit(1)
event_thread.join()
lldb.SBDebugger.Destroy(debugger)
lldb.SBDebugger.Terminate()
# TODO: investigate why we need os._exit() to terminate python process.
os._exit(0)
def main():
arguments = parseArgs()
debugger = lldb.SBDebugger.Create()
is_attach = startDebugging(debugger, arguments)
channel = NotificationChannel()
debugger_store = DebuggerStore(channel, debugger, arguments.basepath)
event_thread = LLDBListenerThread(debugger_store, is_attach=is_attach)
event_thread.start()
try:
app = ChromeDevToolsDebuggerApp(debugger_store, arguments.port)
log_debug('Port: %s' % app.debug_server.server_port)
if arguments.interactive:
app.start_nonblocking()
interactive_loop(debugger)
else:
app.start_blocking()
except KeyboardInterrupt: # Force app to exit on Ctrl-C.
os._exit(1)
def main():
arguments = parse_args()
debugger = lldb.SBDebugger.Create()
is_interactive = getattr(arguments, 'interactive', False)
ipc_channel = IpcChannel(is_interactive)
is_attach = start_debugging(debugger, arguments, ipc_channel)
chrome_channel = ChromeChannel()
debugger_store = DebuggerStore(
debugger,
chrome_channel,
ipc_channel,
is_attach,
str(getattr(arguments, 'basepath', '.')))
try:
app = ChromeDevToolsDebuggerApp(debugger_store, getattr(arguments, 'port', 0))
log_debug('Port: %s' % app.debug_server.server_port)
event_thread = LLDBListenerThread(debugger_store, app)
event_thread.start()
if is_interactive:
app.start_nonblocking()
interactive_loop(debugger)
else:
app.start_blocking()
except KeyboardInterrupt: # Force app to exit on Ctrl-C.
os._exit(1)
event_thread.join()
lldb.SBDebugger.Destroy(debugger)
lldb.SBDebugger.Terminate()
# TODO: investigate why we need os._exit() to terminate python process.
os._exit(0)
def main():
arguments = parse_args()
lldb_python_path = getattr(arguments, 'lldb_python_path', None)
if lldb_python_path is not None:
set_custom_lldb_path(os.path.expanduser(lldb_python_path))
lldb = get_lldb()
debugger = lldb.SBDebugger.Create()
is_attach = (getattr(arguments, 'executable_path', None) == None)
is_interactive = getattr(arguments, 'interactive', False)
ipc_channel = IpcChannel(is_interactive)
start_debugging(debugger, arguments, ipc_channel, is_attach)
register_signal_handler(debugger)
chrome_channel = ChromeChannel()
debugger_store = DebuggerStore(
debugger,
chrome_channel,
ipc_channel,
is_attach,
str(getattr(arguments, 'basepath', '.')))
try:
app = ChromeDevToolsDebuggerApp(debugger_store, getattr(arguments, 'port', 0))
# Tell IDE server is ready.
log_debug('Port: %s' % app.debug_server.server_port)
event_thread = LLDBListenerThread(debugger_store, app)
event_thread.start()
if is_interactive:
app.start_nonblocking()
interactive_loop(debugger)
else:
app.start_blocking()
except KeyboardInterrupt: # Force app to exit on Ctrl-C.
os._exit(1)
event_thread.join()
lldb.SBDebugger.Destroy(debugger)
lldb.SBDebugger.Terminate()
# TODO: investigate why we need os._exit() to terminate python process.
os._exit(0)
class DebuggerDomain(HandlerDomain):
'''Implement Chrome debugger domain protocol and
convert into lldb python API.
'''
def __init__(self, runtimeDomain, fileManager, remoteObjectManager,
basepath='.', **kwargs):
HandlerDomain.__init__(self, **kwargs)
self.runtimeDomain = runtimeDomain
self.fileManager = fileManager
self.remoteObjectManager = remoteObjectManager
self.locationSerializer = serialize.LocationSerializer(
fileManager, basepath)
self.moduleSourcePathUpdater = ModuleSourcePathUpdater(
self.debugger.GetSelectedTarget(), fileManager, basepath)
self.thread_manager = ThreadManager(self.socket, self.locationSerializer, self.remoteObjectManager)
@property
def name(self):
return 'Debugger'
@handler()
def canSetScriptSource(self, params):
# Return False, becuase we don't support
# changing source at runtime.
return {"result": False}
@handler()
def continueToLocation(self, params):
# TODO(williamsc) - This is probably setting a one off breakpoint and continuing.
raise UndefinedHandlerError('continueToLocation not implemented')
@handler()
def disable(self, params):
# Not exactly the same as disable. Detach() might be closer to
# what Chrome Dev Tools is trying to do.
self.debugger.GetSelectedTarget().DisableAllBreakpoints()
return {}
@handler()
def enable(self, params):
process = self.debugger.GetSelectedTarget().process
self.event_thread = LLDBListenerThread(
server=self.socket,
location_serializer=self.locationSerializer,
remote_object_manager=self.remoteObjectManager,
module_source_path_updater=self.moduleSourcePathUpdater,
thread_manager = self.thread_manager,
process=process)
self.moduleSourcePathUpdater.modules_updated()
self.event_thread.start()
return {}
@handler()
def evaluateOnCallFrame(self, params):
frameId = params['callFrameId']
thread, frame = frameId.split('.')
# TODO: These return booleans to indicate success. Throw something if False.
self.debugger.GetSelectedTarget().process.SetSelectedThreadByIndexID(int(thread))
self.debugger.GetSelectedTarget().process.GetSelectedThread().SetSelectedFrame(int(frame))
return self.runtimeDomain.evaluate(params)
@handler()
def getScriptSource(self, params):
filelike = self.fileManager.get_by_script_id(params['scriptId'])
if filelike:
return {'scriptSource': filelike.script_source}
else:
return {'scriptSource': '<Failed to fetch source.>'}
@handler()
def pause(self, params):
self.debugger.GetSelectedTarget().process.Stop()
return {}
@handler()
def removeBreakpoint(self, params):
self.debugger.GetSelectedTarget().BreakpointDelete(int(params['breakpointId']))
return {}
@handler()
def resume(self, params):
self.debugger.GetSelectedTarget().process.Continue()
return {}
@handler()
def selectThread(self, params):
threadId = params['threadId']
self.debugger.GetSelectedTarget().process.SetSelectedThreadByID(threadId)
return {}
@handler()
def getThreadStack(self, params):
threadId = params['threadId']
thread = self.debugger.GetSelectedTarget().process.GetThreadByID(threadId)
params = { "callFrames": [] }
if not thread == None:
params["callFrames"] = self.thread_manager.get_thread_stack(thread)
return params
@handler()
def searchInContent(self, params):
raise UndefinedHandlerError('searchInContent not implemented')
@handler()
def setBreakpoint(self, params):
filelike = self.fileManager.get_by_script_id(params['location']['scriptId'])
if not filelike or not isinstance(filelike, file_manager.File):
# Only support setting breakpoints in real files.
return {}
return self._set_breakpoint_by_filespec(
filelike.server_obj,
int(params['location']['lineNumber']) + 1)
@handler()
def setBreakpointByUrl(self, params):
filelike = self.fileManager.get_by_client_url(params['url'])
if not filelike or not isinstance(filelike, file_manager.File):
raise RuntimeError('Cannot find file for breakpoint.')
return self._set_breakpoint_by_filespec(
filelike.server_obj,
int(params['lineNumber']) + 1)
@handler()
def setBreakpointsActive(self, params):
if params['active']:
self.debugger.GetSelectedTarget().EnableAllBreakpoints()
else:
self.debugger.GetSelectedTarget().DisableAllBreakpoints()
return {}
@handler()
def setPauseOnExceptions(self, params):
# TODO(williamsc) - Support add support for pausing on exceptions
raise UndefinedHandlerError('setPauseOnExceptions not implemented')
@handler()
def setScriptSource(self, params):
raise UndefinedHandlerError('setScriptSource not supported for LLDB')
@handler()
def stepInto(self, params):
self.debugger.GetSelectedTarget().GetProcess().GetSelectedThread().StepInto()
return {}
@handler()
def stepOut(self, params):
self.debugger.GetSelectedTarget().GetProcess().GetSelectedThread().StepOut()
return {}
@handler()
def stepOver(self, params):
self.debugger.GetSelectedTarget().GetProcess().GetSelectedThread().StepOver()
return {}
def _set_breakpoint_by_filespec(self, filespec, line):
breakpoint = self.debugger.GetSelectedTarget().BreakpointCreateByLocation(filespec, line)
return {
'breakpointId': str(breakpoint.id),
'locations':
self.locationSerializer.get_breakpoint_locations(breakpoint),
}
