| # | |
| # This file defines the layer that talks to lldb | |
| # | |
| import os | |
| import re | |
| import sys | |
| import lldb | |
| import vim | |
| from vim_ui import UI | |
| # ================================================= | |
| # Convert some enum value to its string counterpart | |
| # ================================================= | |
| # Shamelessly copy/pasted from lldbutil.py in the test suite | |
| def state_type_to_str(enum): | |
| """Returns the stateType string given an enum.""" | |
| if enum == lldb.eStateInvalid: | |
| return "invalid" | |
| elif enum == lldb.eStateUnloaded: | |
| return "unloaded" | |
| elif enum == lldb.eStateConnected: | |
| return "connected" | |
| elif enum == lldb.eStateAttaching: | |
| return "attaching" | |
| elif enum == lldb.eStateLaunching: | |
| return "launching" | |
| elif enum == lldb.eStateStopped: | |
| return "stopped" | |
| elif enum == lldb.eStateRunning: | |
| return "running" | |
| elif enum == lldb.eStateStepping: | |
| return "stepping" | |
| elif enum == lldb.eStateCrashed: | |
| return "crashed" | |
| elif enum == lldb.eStateDetached: | |
| return "detached" | |
| elif enum == lldb.eStateExited: | |
| return "exited" | |
| elif enum == lldb.eStateSuspended: | |
| return "suspended" | |
| else: | |
| raise Exception("Unknown StateType enum") | |
| class StepType: | |
| INSTRUCTION = 1 | |
| INSTRUCTION_OVER = 2 | |
| INTO = 3 | |
| OVER = 4 | |
| OUT = 5 | |
| class LLDBController(object): | |
| """ Handles Vim and LLDB events such as commands and lldb events. """ | |
| # Timeouts (sec) for waiting on new events. Because vim is not multi-threaded, we are restricted to | |
| # servicing LLDB events from the main UI thread. Usually, we only process events that are already | |
| # sitting on the queue. But in some situations (when we are expecting an event as a result of some | |
| # user interaction) we want to wait for it. The constants below set these wait period in which the | |
| # Vim UI is "blocked". Lower numbers will make Vim more responsive, but LLDB will be delayed and higher | |
| # numbers will mean that LLDB events are processed faster, but the Vim UI may appear less responsive at | |
| # times. | |
| eventDelayStep = 2 | |
| eventDelayLaunch = 1 | |
| eventDelayContinue = 1 | |
| def __init__(self): | |
| """ Creates the LLDB SBDebugger object and initializes the UI class. """ | |
| self.target = None | |
| self.process = None | |
| self.load_dependent_modules = True | |
| self.dbg = lldb.SBDebugger.Create() | |
| self.commandInterpreter = self.dbg.GetCommandInterpreter() | |
| self.ui = UI() | |
| def completeCommand(self, a, l, p): | |
| """ Returns a list of viable completions for command a with length l and cursor at p """ | |
| assert l[0] == 'L' | |
| # Remove first 'L' character that all commands start with | |
| l = l[1:] | |
| # Adjust length as string has 1 less character | |
| p = int(p) - 1 | |
| result = lldb.SBStringList() | |
| num = self.commandInterpreter.HandleCompletion(l, p, 1, -1, result) | |
| if num == -1: | |
| # FIXME: insert completion character... what's a completion | |
| # character? | |
| pass | |
| elif num == -2: | |
| # FIXME: replace line with result.GetStringAtIndex(0) | |
| pass | |
| if result.GetSize() > 0: | |
| results = filter(None, [result.GetStringAtIndex(x) | |
| for x in range(result.GetSize())]) | |
| return results | |
| else: | |
| return [] | |
| def doStep(self, stepType): | |
| """ Perform a step command and block the UI for eventDelayStep seconds in order to process | |
| events on lldb's event queue. | |
| FIXME: if the step does not complete in eventDelayStep seconds, we relinquish control to | |
| the main thread to avoid the appearance of a "hang". If this happens, the UI will | |
| update whenever; usually when the user moves the cursor. This is somewhat annoying. | |
| """ | |
| if not self.process: | |
| sys.stderr.write("No process to step") | |
| return | |
| t = self.process.GetSelectedThread() | |
| if stepType == StepType.INSTRUCTION: | |
| t.StepInstruction(False) | |
| if stepType == StepType.INSTRUCTION_OVER: | |
| t.StepInstruction(True) | |
| elif stepType == StepType.INTO: | |
| t.StepInto() | |
| elif stepType == StepType.OVER: | |
| t.StepOver() | |
| elif stepType == StepType.OUT: | |
| t.StepOut() | |
| self.processPendingEvents(self.eventDelayStep, True) | |
| def doSelect(self, command, args): | |
| """ Like doCommand, but suppress output when "select" is the first argument.""" | |
| a = args.split(' ') | |
| return self.doCommand(command, args, "select" != a[0], True) | |
| def doProcess(self, args): | |
| """ Handle 'process' command. If 'launch' is requested, use doLaunch() instead | |
| of the command interpreter to start the inferior process. | |
| """ | |
| a = args.split(' ') | |
| if len(args) == 0 or (len(a) > 0 and a[0] != 'launch'): | |
| self.doCommand("process", args) | |
| #self.ui.update(self.target, "", self) | |
| else: | |
| self.doLaunch('-s' not in args, "") | |
| def doAttach(self, process_name): | |
| """ Handle process attach. """ | |
| error = lldb.SBError() | |
| self.processListener = lldb.SBListener("process_event_listener") | |
| self.target = self.dbg.CreateTarget('') | |
| self.process = self.target.AttachToProcessWithName( | |
| self.processListener, process_name, False, error) | |
| if not error.Success(): | |
| sys.stderr.write("Error during attach: " + str(error)) | |
| return | |
| self.ui.activate() | |
| self.pid = self.process.GetProcessID() | |
| print "Attached to %s (pid=%d)" % (process_name, self.pid) | |
| def doDetach(self): | |
| if self.process is not None and self.process.IsValid(): | |
| pid = self.process.GetProcessID() | |
| state = state_type_to_str(self.process.GetState()) | |
| self.process.Detach() | |
| self.processPendingEvents(self.eventDelayLaunch) | |
| def doLaunch(self, stop_at_entry, args): | |
| """ Handle process launch. """ | |
| error = lldb.SBError() | |
| fs = self.target.GetExecutable() | |
| exe = os.path.join(fs.GetDirectory(), fs.GetFilename()) | |
| if self.process is not None and self.process.IsValid(): | |
| pid = self.process.GetProcessID() | |
| state = state_type_to_str(self.process.GetState()) | |
| self.process.Destroy() | |
| launchInfo = lldb.SBLaunchInfo(args.split(' ')) | |
| self.process = self.target.Launch(launchInfo, error) | |
| if not error.Success(): | |
| sys.stderr.write("Error during launch: " + str(error)) | |
| return | |
| # launch succeeded, store pid and add some event listeners | |
| self.pid = self.process.GetProcessID() | |
| self.processListener = lldb.SBListener("process_event_listener") | |
| self.process.GetBroadcaster().AddListener( | |
| self.processListener, lldb.SBProcess.eBroadcastBitStateChanged) | |
| print "Launched %s %s (pid=%d)" % (exe, args, self.pid) | |
| if not stop_at_entry: | |
| self.doContinue() | |
| else: | |
| self.processPendingEvents(self.eventDelayLaunch) | |
| def doTarget(self, args): | |
| """ Pass target command to interpreter, except if argument is not one of the valid options, or | |
| is create, in which case try to create a target with the argument as the executable. For example: | |
| target list ==> handled by interpreter | |
| target create blah ==> custom creation of target 'blah' | |
| target blah ==> also creates target blah | |
| """ | |
| target_args = [ # "create", | |
| "delete", | |
| "list", | |
| "modules", | |
| "select", | |
| "stop-hook", | |
| "symbols", | |
| "variable"] | |
| a = args.split(' ') | |
| if len(args) == 0 or (len(a) > 0 and a[0] in target_args): | |
| self.doCommand("target", args) | |
| return | |
| elif len(a) > 1 and a[0] == "create": | |
| exe = a[1] | |
| elif len(a) == 1 and a[0] not in target_args: | |
| exe = a[0] | |
| err = lldb.SBError() | |
| self.target = self.dbg.CreateTarget( | |
| exe, None, None, self.load_dependent_modules, err) | |
| if not self.target: | |
| sys.stderr.write( | |
| "Error creating target %s. %s" % | |
| (str(exe), str(err))) | |
| return | |
| self.ui.activate() | |
| self.ui.update(self.target, "created target %s" % str(exe), self) | |
| def doContinue(self): | |
| """ Handle 'contiue' command. | |
| FIXME: switch to doCommand("continue", ...) to handle -i ignore-count param. | |
| """ | |
| if not self.process or not self.process.IsValid(): | |
| sys.stderr.write("No process to continue") | |
| return | |
| self.process.Continue() | |
| self.processPendingEvents(self.eventDelayContinue) | |
| def doBreakpoint(self, args): | |
| """ Handle breakpoint command with command interpreter, except if the user calls | |
| "breakpoint" with no other args, in which case add a breakpoint at the line | |
| under the cursor. | |
| """ | |
| a = args.split(' ') | |
| if len(args) == 0: | |
| show_output = False | |
| # User called us with no args, so toggle the bp under cursor | |
| cw = vim.current.window | |
| cb = vim.current.buffer | |
| name = cb.name | |
| line = cw.cursor[0] | |
| # Since the UI is responsbile for placing signs at bp locations, we have to | |
| # ask it if there already is one or more breakpoints at (file, | |
| # line)... | |
| if self.ui.haveBreakpoint(name, line): | |
| bps = self.ui.getBreakpoints(name, line) | |
| args = "delete %s" % " ".join([str(b.GetID()) for b in bps]) | |
| self.ui.deleteBreakpoints(name, line) | |
| else: | |
| args = "set -f %s -l %d" % (name, line) | |
| else: | |
| show_output = True | |
| self.doCommand("breakpoint", args, show_output) | |
| return | |
| def doRefresh(self): | |
| """ process pending events and update UI on request """ | |
| status = self.processPendingEvents() | |
| def doShow(self, name): | |
| """ handle :Lshow <name> """ | |
| if not name: | |
| self.ui.activate() | |
| return | |
| if self.ui.showWindow(name): | |
| self.ui.update(self.target, "", self) | |
| def doHide(self, name): | |
| """ handle :Lhide <name> """ | |
| if self.ui.hideWindow(name): | |
| self.ui.update(self.target, "", self) | |
| def doExit(self): | |
| self.dbg.Terminate() | |
| self.dbg = None | |
| def getCommandResult(self, command, command_args): | |
| """ Run cmd in the command interpreter and returns (success, output) """ | |
| result = lldb.SBCommandReturnObject() | |
| cmd = "%s %s" % (command, command_args) | |
| self.commandInterpreter.HandleCommand(cmd, result) | |
| return (result.Succeeded(), result.GetOutput() | |
| if result.Succeeded() else result.GetError()) | |
| def doCommand( | |
| self, | |
| command, | |
| command_args, | |
| print_on_success=True, | |
| goto_file=False): | |
| """ Run cmd in interpreter and print result (success or failure) on the vim status line. """ | |
| (success, output) = self.getCommandResult(command, command_args) | |
| if success: | |
| self.ui.update(self.target, "", self, goto_file) | |
| if len(output) > 0 and print_on_success: | |
| print output | |
| else: | |
| sys.stderr.write(output) | |
| def getCommandOutput(self, command, command_args=""): | |
| """ runs cmd in the command interpreter andreturns (status, result) """ | |
| result = lldb.SBCommandReturnObject() | |
| cmd = "%s %s" % (command, command_args) | |
| self.commandInterpreter.HandleCommand(cmd, result) | |
| return (result.Succeeded(), result.GetOutput() | |
| if result.Succeeded() else result.GetError()) | |
| def processPendingEvents(self, wait_seconds=0, goto_file=True): | |
| """ Handle any events that are queued from the inferior. | |
| Blocks for at most wait_seconds, or if wait_seconds == 0, | |
| process only events that are already queued. | |
| """ | |
| status = None | |
| num_events_handled = 0 | |
| if self.process is not None: | |
| event = lldb.SBEvent() | |
| old_state = self.process.GetState() | |
| new_state = None | |
| done = False | |
| if old_state == lldb.eStateInvalid or old_state == lldb.eStateExited: | |
| # Early-exit if we are in 'boring' states | |
| pass | |
| else: | |
| while not done and self.processListener is not None: | |
| if not self.processListener.PeekAtNextEvent(event): | |
| if wait_seconds > 0: | |
| # No events on the queue, but we are allowed to wait for wait_seconds | |
| # for any events to show up. | |
| self.processListener.WaitForEvent( | |
| wait_seconds, event) | |
| new_state = lldb.SBProcess.GetStateFromEvent(event) | |
| num_events_handled += 1 | |
| done = not self.processListener.PeekAtNextEvent(event) | |
| else: | |
| # An event is on the queue, process it here. | |
| self.processListener.GetNextEvent(event) | |
| new_state = lldb.SBProcess.GetStateFromEvent(event) | |
| # continue if stopped after attaching | |
| if old_state == lldb.eStateAttaching and new_state == lldb.eStateStopped: | |
| self.process.Continue() | |
| # If needed, perform any event-specific behaviour here | |
| num_events_handled += 1 | |
| if num_events_handled == 0: | |
| pass | |
| else: | |
| if old_state == new_state: | |
| status = "" | |
| self.ui.update(self.target, status, self, goto_file) | |
| def returnCompleteCommand(a, l, p): | |
| """ Returns a "\n"-separated string with possible completion results | |
| for command a with length l and cursor at p. | |
| """ | |
| separator = "\n" | |
| results = ctrl.completeCommand(a, l, p) | |
| vim.command('return "%s%s"' % (separator.join(results), separator)) | |
| def returnCompleteWindow(a, l, p): | |
| """ Returns a "\n"-separated string with possible completion results | |
| for commands that expect a window name parameter (like hide/show). | |
| FIXME: connect to ctrl.ui instead of hardcoding the list here | |
| """ | |
| separator = "\n" | |
| results = [ | |
| 'breakpoints', | |
| 'backtrace', | |
| 'disassembly', | |
| 'locals', | |
| 'threads', | |
| 'registers'] | |
| vim.command('return "%s%s"' % (separator.join(results), separator)) | |
| global ctrl | |
| ctrl = LLDBController() |