b9c1b51e45
*** to conform to clang-format’s LLVM style. This kind of mass change has
*** two obvious implications:
Firstly, merging this particular commit into a downstream fork may be a huge
effort. Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit. The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):
find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;
The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.
Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit. There are alternatives available that will attempt
to look through this change and find the appropriate prior commit. YMMV.
llvm-svn: 280751
414 lines
15 KiB
Python
414 lines
15 KiB
Python
|
|
#
|
|
# 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()
|