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
256 lines
9.1 KiB
Python
256 lines
9.1 KiB
Python
|
|
# LLDB UI state in the Vim user interface.
|
|
|
|
import os
|
|
import re
|
|
import sys
|
|
import lldb
|
|
import vim
|
|
from vim_panes import *
|
|
from vim_signs import *
|
|
|
|
|
|
def is_same_file(a, b):
|
|
""" returns true if paths a and b are the same file """
|
|
a = os.path.realpath(a)
|
|
b = os.path.realpath(b)
|
|
return a in b or b in a
|
|
|
|
|
|
class UI:
|
|
|
|
def __init__(self):
|
|
""" Declare UI state variables """
|
|
|
|
# Default panes to display
|
|
self.defaultPanes = [
|
|
'breakpoints',
|
|
'backtrace',
|
|
'locals',
|
|
'threads',
|
|
'registers',
|
|
'disassembly']
|
|
|
|
# map of tuples (filename, line) --> SBBreakpoint
|
|
self.markedBreakpoints = {}
|
|
|
|
# Currently shown signs
|
|
self.breakpointSigns = {}
|
|
self.pcSigns = []
|
|
|
|
# Container for panes
|
|
self.paneCol = PaneLayout()
|
|
|
|
# All possible LLDB panes
|
|
self.backtracePane = BacktracePane(self.paneCol)
|
|
self.threadPane = ThreadPane(self.paneCol)
|
|
self.disassemblyPane = DisassemblyPane(self.paneCol)
|
|
self.localsPane = LocalsPane(self.paneCol)
|
|
self.registersPane = RegistersPane(self.paneCol)
|
|
self.breakPane = BreakpointsPane(self.paneCol)
|
|
|
|
def activate(self):
|
|
""" Activate UI: display default set of panes """
|
|
self.paneCol.prepare(self.defaultPanes)
|
|
|
|
def get_user_buffers(self, filter_name=None):
|
|
""" Returns a list of buffers that are not a part of the LLDB UI. That is, they
|
|
are not contained in the PaneLayout object self.paneCol.
|
|
"""
|
|
ret = []
|
|
for w in vim.windows:
|
|
b = w.buffer
|
|
if not self.paneCol.contains(b.name):
|
|
if filter_name is None or filter_name in b.name:
|
|
ret.append(b)
|
|
return ret
|
|
|
|
def update_pc(self, process, buffers, goto_file):
|
|
""" Place the PC sign on the PC location of each thread's selected frame """
|
|
|
|
def GetPCSourceLocation(thread):
|
|
""" Returns a tuple (thread_index, file, line, column) that represents where
|
|
the PC sign should be placed for a thread.
|
|
"""
|
|
|
|
frame = thread.GetSelectedFrame()
|
|
frame_num = frame.GetFrameID()
|
|
le = frame.GetLineEntry()
|
|
while not le.IsValid() and frame_num < thread.GetNumFrames():
|
|
frame_num += 1
|
|
le = thread.GetFrameAtIndex(frame_num).GetLineEntry()
|
|
|
|
if le.IsValid():
|
|
path = os.path.join(
|
|
le.GetFileSpec().GetDirectory(),
|
|
le.GetFileSpec().GetFilename())
|
|
return (
|
|
thread.GetIndexID(),
|
|
path,
|
|
le.GetLine(),
|
|
le.GetColumn())
|
|
return None
|
|
|
|
# Clear all existing PC signs
|
|
del_list = []
|
|
for sign in self.pcSigns:
|
|
sign.hide()
|
|
del_list.append(sign)
|
|
for sign in del_list:
|
|
self.pcSigns.remove(sign)
|
|
del sign
|
|
|
|
# Select a user (non-lldb) window
|
|
if not self.paneCol.selectWindow(False):
|
|
# No user window found; avoid clobbering by splitting
|
|
vim.command(":vsp")
|
|
|
|
# Show a PC marker for each thread
|
|
for thread in process:
|
|
loc = GetPCSourceLocation(thread)
|
|
if not loc:
|
|
# no valid source locations for PCs. hide all existing PC
|
|
# markers
|
|
continue
|
|
|
|
buf = None
|
|
(tid, fname, line, col) = loc
|
|
buffers = self.get_user_buffers(fname)
|
|
is_selected = thread.GetIndexID() == process.GetSelectedThread().GetIndexID()
|
|
if len(buffers) == 1:
|
|
buf = buffers[0]
|
|
if buf != vim.current.buffer:
|
|
# Vim has an open buffer to the required file: select it
|
|
vim.command('execute ":%db"' % buf.number)
|
|
elif is_selected and vim.current.buffer.name not in fname and os.path.exists(fname) and goto_file:
|
|
# FIXME: If current buffer is modified, vim will complain when we try to switch away.
|
|
# Find a way to detect if the current buffer is modified,
|
|
# and...warn instead?
|
|
vim.command('execute ":e %s"' % fname)
|
|
buf = vim.current.buffer
|
|
elif len(buffers) > 1 and goto_file:
|
|
# FIXME: multiple open buffers match PC location
|
|
continue
|
|
else:
|
|
continue
|
|
|
|
self.pcSigns.append(PCSign(buf, line, is_selected))
|
|
|
|
if is_selected and goto_file:
|
|
# if the selected file has a PC marker, move the cursor there
|
|
# too
|
|
curname = vim.current.buffer.name
|
|
if curname is not None and is_same_file(curname, fname):
|
|
move_cursor(line, 0)
|
|
elif move_cursor:
|
|
print "FIXME: not sure where to move cursor because %s != %s " % (vim.current.buffer.name, fname)
|
|
|
|
def update_breakpoints(self, target, buffers):
|
|
""" Decorates buffer with signs corresponding to breakpoints in target. """
|
|
|
|
def GetBreakpointLocations(bp):
|
|
""" Returns a list of tuples (resolved, filename, line) where a breakpoint was resolved. """
|
|
if not bp.IsValid():
|
|
sys.stderr.write("breakpoint is invalid, no locations")
|
|
return []
|
|
|
|
ret = []
|
|
numLocs = bp.GetNumLocations()
|
|
for i in range(numLocs):
|
|
loc = bp.GetLocationAtIndex(i)
|
|
desc = get_description(loc, lldb.eDescriptionLevelFull)
|
|
match = re.search('at\ ([^:]+):([\d]+)', desc)
|
|
try:
|
|
lineNum = int(match.group(2).strip())
|
|
ret.append((loc.IsResolved(), match.group(1), lineNum))
|
|
except ValueError as e:
|
|
sys.stderr.write(
|
|
"unable to parse breakpoint location line number: '%s'" %
|
|
match.group(2))
|
|
sys.stderr.write(str(e))
|
|
|
|
return ret
|
|
|
|
if target is None or not target.IsValid():
|
|
return
|
|
|
|
needed_bps = {}
|
|
for bp_index in range(target.GetNumBreakpoints()):
|
|
bp = target.GetBreakpointAtIndex(bp_index)
|
|
locations = GetBreakpointLocations(bp)
|
|
for (is_resolved, file, line) in GetBreakpointLocations(bp):
|
|
for buf in buffers:
|
|
if file in buf.name:
|
|
needed_bps[(buf, line, is_resolved)] = bp
|
|
|
|
# Hide any signs that correspond with disabled breakpoints
|
|
del_list = []
|
|
for (b, l, r) in self.breakpointSigns:
|
|
if (b, l, r) not in needed_bps:
|
|
self.breakpointSigns[(b, l, r)].hide()
|
|
del_list.append((b, l, r))
|
|
for d in del_list:
|
|
del self.breakpointSigns[d]
|
|
|
|
# Show any signs for new breakpoints
|
|
for (b, l, r) in needed_bps:
|
|
bp = needed_bps[(b, l, r)]
|
|
if self.haveBreakpoint(b.name, l):
|
|
self.markedBreakpoints[(b.name, l)].append(bp)
|
|
else:
|
|
self.markedBreakpoints[(b.name, l)] = [bp]
|
|
|
|
if (b, l, r) not in self.breakpointSigns:
|
|
s = BreakpointSign(b, l, r)
|
|
self.breakpointSigns[(b, l, r)] = s
|
|
|
|
def update(self, target, status, controller, goto_file=False):
|
|
""" Updates debugger info panels and breakpoint/pc marks and prints
|
|
status to the vim status line. If goto_file is True, the user's
|
|
cursor is moved to the source PC location in the selected frame.
|
|
"""
|
|
|
|
self.paneCol.update(target, controller)
|
|
self.update_breakpoints(target, self.get_user_buffers())
|
|
|
|
if target is not None and target.IsValid():
|
|
process = target.GetProcess()
|
|
if process is not None and process.IsValid():
|
|
self.update_pc(process, self.get_user_buffers, goto_file)
|
|
|
|
if status is not None and len(status) > 0:
|
|
print status
|
|
|
|
def haveBreakpoint(self, file, line):
|
|
""" Returns True if we have a breakpoint at file:line, False otherwise """
|
|
return (file, line) in self.markedBreakpoints
|
|
|
|
def getBreakpoints(self, fname, line):
|
|
""" Returns the LLDB SBBreakpoint object at fname:line """
|
|
if self.haveBreakpoint(fname, line):
|
|
return self.markedBreakpoints[(fname, line)]
|
|
else:
|
|
return None
|
|
|
|
def deleteBreakpoints(self, name, line):
|
|
del self.markedBreakpoints[(name, line)]
|
|
|
|
def showWindow(self, name):
|
|
""" Shows (un-hides) window pane specified by name """
|
|
if not self.paneCol.havePane(name):
|
|
sys.stderr.write("unknown window: %s" % name)
|
|
return False
|
|
self.paneCol.prepare([name])
|
|
return True
|
|
|
|
def hideWindow(self, name):
|
|
""" Hides window pane specified by name """
|
|
if not self.paneCol.havePane(name):
|
|
sys.stderr.write("unknown window: %s" % name)
|
|
return False
|
|
self.paneCol.hide([name])
|
|
return True
|
|
|
|
global ui
|
|
ui = UI()
|