maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Initial checkin of curses-based LLDB UI (lui) 

LLDB (Terminal) User Interface
==============================
This directory contains the curses user interface for LLDB. To use it, ensure Python can find your lldb module. You may have to modify PYTHONPATH for that purpose:

$ export PYTHONPATH=/path/to/lldb/module

Then, run the lui.py. To load a core file:
$ ./lui.py --core core

To create a target from an executable:
$ ./lui.py /bin/echo "hello world"

To attach to a running process:
$ ./lui.py --attach <pid>


Known Issues
============
1. Resizing the terminal will most likely cause lui to crash.
2. Missing paging in command-window
3. Only minimal testing (on Ubuntu Linux x86_64)

Missing Features
================
- stdin/stdout/stderr windows
- memory window
- backtrace window
- threads window
- tab-completion
- syntax-highlighting (via pygments library)
- (local) variables window
- registers window
- disassembly window
- custom layout

llvm-svn: 192326
This commit is contained in:
Daniel Malea 2013-10-09 22:11:30 +00:00
parent 0354b92992
commit 4c3261d1b3
11 changed files with 1867 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
lldb/utils/lui/Readme Normal file
View File

@ -0,0 +1,36 @@
LLDB (Terminal) User Interface
------------------------------
This directory contains the curses user interface for LLDB. To use it, ensure Python can find your lldb module. You may have to modify PYTHONPATH for that purpose:
$ export PYTHONPATH=/path/to/lldb/module
Then, run the lui.py. To load a core file:
$ ./lui.py --core core
To create a target from an executable:
$ ./lui.py /bin/echo "hello world"
To attach to a running process:
$ ./lui.py --attach <pid>
Known Issues
------------
1. Resizing the terminal will most likely cause lui to crash.
2. Missing paging in command-window
3. Only minimal testing (on Ubuntu Linux x86_64)
Missing Features
----------------
- stdin/stdout/stderr windows
- memory window
- backtrace window
- threads window
- tab-completion
- syntax-highlighting (via pygments library)
- (local) variables window
- registers window
- disassembly window
- custom layout

28
lldb/utils/lui/breakwin.py Normal file
View File

@ -0,0 +1,28 @@
import cui
import curses
import lldb, lldbutil
class BreakWin(cui.TitledWin):
def __init__(self, driver, x, y, w, h):
super(BreakWin, self).__init__(x, y, w, h, 'Breakpoints')
self.win.scrollok(1)
super(BreakWin, self).draw()
self.driver = driver
def handleEvent(self, event):
if isinstance(event, lldb.SBEvent):
if lldb.SBBreakpoint.EventIsBreakpointEvent(event):
self.update()
def update(self):
target = self.driver.getTarget()
if not target.IsValid():
return
self.win.addstr(0, 0, '')
for i in range(0, target.GetNumBreakpoints()):
bp = target.GetBreakpointAtIndex(i)
if bp.IsInternal():
continue
text = lldbutil.get_description(bp)
self.win.addstr(text)
self.win.addstr('\n')

93
lldb/utils/lui/commandwin.py Normal file
View File

@ -0,0 +1,93 @@
import cui
import curses
import lldb
class History(object):
def __init__(self):
self.data = {}
self.pos = 0
self.tempEntry = ''
def previous(self, curr):
if self.pos == len(self.data):
self.tempEntry = curr
if self.pos < 0:
return ''
if self.pos == 0:
self.pos -= 1
return ''
if self.pos > 0:
self.pos -= 1
return self.data[self.pos]
def next(self):
if self.pos < len(self.data):
self.pos += 1
if self.pos < len(self.data):
return self.data[self.pos]
elif self.tempEntry != '':
return self.tempEntry
else:
return ''
def add(self, c):
self.tempEntry = ''
self.pos = len(self.data)
if self.pos == 0 or self.data[self.pos-1] != c:
self.data[self.pos] = c
self.pos += 1
class CommandWin(cui.TitledWin):
def __init__(self, driver, x, y, w, h):
super(CommandWin, self).__init__(x, y, w, h, "Commands")
self.command = ""
driver.setSize(w, h)
self.win.scrollok(1)
self.driver = driver
self.history = History()
def enterCallback(content):
self.handleCommand(content)
def tabCompleteCallback(content):
pass # TODO: implement
self.startline = self.win.getmaxyx()[0]-2
self.el = cui.CursesEditLine(self.win, self.history, enterCallback, tabCompleteCallback)
self.el.prompt = self.driver.getPrompt()
self.el.showPrompt(self.startline, 0)
def handleCommand(self, cmd):
# enter!
self.win.scroll(1) # TODO: scroll more for longer commands
if cmd == '':
cmd = self.history.previous('')
elif cmd in ('q', 'quit'):
self.driver.terminate()
return
self.history.add(cmd)
ret = self.driver.handleCommand(cmd)
if ret.Succeeded():
out = ret.GetOutput()
attr = curses.A_NORMAL
else:
out = ret.GetError()
attr = curses.color_pair(3) # red on black
self.win.addstr(self.startline, 0, out + '\n', attr)
self.win.scroll(1)
self.el.showPrompt(self.startline, 0)
def handleEvent(self, event):
if isinstance(event, int):
if event == curses.ascii.EOT and self.el.content == '':
# When the command is empty, treat CTRL-D as EOF.
self.driver.terminate()
return
self.el.handleEvent(event)

225
lldb/utils/lui/cui.py Executable file
View File

@ -0,0 +1,225 @@
import curses
import curses.ascii
import threading
class CursesWin(object):
def __init__(self, x, y, w, h):
self.win = curses.newwin(h, w, y, x)
self.focus = False
def setFocus(self, focus):
self.focus = focus
def getFocus(self):
return self.focus
def canFocus(self):
return True
def handleEvent(self, event):
return
def draw(self):
return
class TextWin(CursesWin):
def __init__(self, x, y, w):
super(TextWin, self).__init__(x, y, w, 1)
self.win.bkgd(curses.color_pair(1))
self.text = ''
self.reverse = False
def canFocus(self):
return False
def draw(self):
w = self.win.getmaxyx()[1]
text = self.text
if len(text) > w:
#trunc_length = len(text) - w
text = text[-w+1:]
if self.reverse:
self.win.addstr(0, 0, text, curses.A_REVERSE)
else:
self.win.addstr(0, 0, text)
self.win.noutrefresh()
def setReverse(self, reverse):
self.reverse = reverse
def setText(self, text):
self.text = text
class TitledWin(CursesWin):
def __init__(self, x, y, w, h, title):
super(TitledWin, self).__init__(x, y+1, w, h-1)
self.title = title
self.title_win = TextWin(x, y, w)
self.title_win.setText(title)
self.draw()
def setTitle(self, title):
self.title_win.setText(title)
def draw(self):
self.title_win.setReverse(self.getFocus())
self.title_win.draw()
self.win.noutrefresh()
class InputHandler(threading.Thread):
def __init__(self, screen, queue):
super(InputHandler, self).__init__()
self.screen = screen
self.queue = queue
def run(self):
while True:
c = self.screen.getch()
self.queue.put(c)
class CursesUI(object):
""" Responsible for updating the console UI with curses. """
def __init__(self, screen, event_queue):
self.screen = screen
self.event_queue = event_queue
curses.start_color()
curses.init_pair(1, curses.COLOR_GREEN, curses.COLOR_BLUE)
curses.init_pair(2, curses.COLOR_YELLOW, curses.COLOR_BLACK)
curses.init_pair(3, curses.COLOR_RED, curses.COLOR_BLACK)
self.screen.bkgd(curses.color_pair(1))
self.screen.clear()
self.input_handler = InputHandler(self.screen, self.event_queue)
self.input_handler.daemon = True
self.focus = 0
self.screen.refresh()
def focusNext(self):
self.wins[self.focus].setFocus(False)
old = self.focus
while True:
self.focus += 1
if self.focus >= len(self.wins):
self.focus = 0
if self.wins[self.focus].canFocus():
break
self.wins[self.focus].setFocus(True)
def handleEvent(self, event):
if isinstance(event, int):
if event == curses.KEY_F3:
self.focusNext()
def eventLoop(self):
self.input_handler.start()
self.wins[self.focus].setFocus(True)
while True:
self.screen.noutrefresh()
for i, win in enumerate(self.wins):
if i != self.focus:
win.draw()
# Draw the focused window last so that the cursor shows up.
if self.wins:
self.wins[self.focus].draw()
curses.doupdate() # redraw the physical screen
event = self.event_queue.get()
for win in self.wins:
if isinstance(event, int):
if win.getFocus() or not win.canFocus():
win.handleEvent(event)
else:
win.handleEvent(event)
self.handleEvent(event)
class CursesEditLine(object):
""" Embed an 'editline'-compatible prompt inside a CursesWin. """
def __init__(self, win, history, enterCallback, tabCompleteCallback):
self.win = win
self.history = history
self.enterCallback = enterCallback
self.tabCompleteCallback = tabCompleteCallback
self.prompt = ''
self.content = ''
self.index = 0
self.startx = -1
self.starty = -1
def draw(self, prompt=None):
if not prompt:
prompt = self.prompt
(h, w) = self.win.getmaxyx()
if (len(prompt) + len(self.content)) / w + self.starty >= h-1:
self.win.scroll(1)
self.starty -= 1
if self.starty < 0:
raise RuntimeError('Input too long; aborting')
(y, x) = (self.starty, self.startx)
self.win.move(y, x)
self.win.clrtobot()
self.win.addstr(y, x, prompt)
remain = self.content
self.win.addstr(remain[:w-len(prompt)])
remain = remain[w-len(prompt):]
while remain != '':
y += 1
self.win.addstr(y, 0, remain[:w])
remain = remain[w:]
length = self.index + len(prompt)
self.win.move(self.starty + length / w, length % w)
def showPrompt(self, y, x, prompt=None):
self.content = ''
self.index = 0
self.startx = x
self.starty = y
self.draw(prompt)
def handleEvent(self, event):
if not isinstance(event, int):
return # not handled
key = event
if self.startx == -1:
raise RuntimeError('Trying to handle input without prompt')
if key == curses.ascii.NL:
self.enterCallback(self.content)
elif key == curses.ascii.TAB:
self.tabCompleteCallback(self.content)
elif curses.ascii.isprint(key):
self.content = self.content[:self.index] + chr(key) + self.content[self.index:]
self.index += 1
elif key == curses.KEY_BACKSPACE or key == curses.ascii.BS:
if self.index > 0:
self.index -= 1
self.content = self.content[:self.index] + self.content[self.index+1:]
elif key == curses.KEY_DC or key == curses.ascii.DEL or key == curses.ascii.EOT:
self.content = self.content[:self.index] + self.content[self.index+1:]
elif key == curses.ascii.VT: # CTRL-K
self.content = self.content[:self.index]
elif key == curses.KEY_LEFT or key == curses.ascii.STX: # left or CTRL-B
if self.index > 0:
self.index -= 1
elif key == curses.KEY_RIGHT or key == curses.ascii.ACK: # right or CTRL-F
if self.index < len(self.content):
self.index += 1
elif key == curses.ascii.SOH: # CTRL-A
self.index = 0
elif key == curses.ascii.ENQ: # CTRL-E
self.index = len(self.content)
elif key == curses.KEY_UP or key == curses.ascii.DLE: # up or CTRL-P
self.content = self.history.previous(self.content)
self.index = len(self.content)
elif key == curses.KEY_DOWN or key == curses.ascii.SO: # down or CTRL-N
self.content = self.history.next()
self.index = len(self.content)
self.draw()

129
lldb/utils/lui/debuggerdriver.py Normal file
View File

@ -0,0 +1,129 @@
import lldb
import lldbutil
import sys
from threading import Thread
class DebuggerDriver(Thread):
""" Drives the debugger and responds to events. """
def __init__(self, debugger, event_queue):
Thread.__init__(self)
self.event_queue = event_queue
# This is probably not great because it does not give liblldb a chance to clean up
self.daemon = True
self.initialize(debugger)
def initialize(self, debugger):
self.done = False
self.debugger = debugger
self.listener = debugger.GetListener()
if not self.listener.IsValid():
raise "Invalid listener"
self.listener.StartListeningForEventClass(self.debugger,
lldb.SBTarget.GetBroadcasterClassName(),
lldb.SBTarget.eBroadcastBitBreakpointChanged
#| lldb.SBTarget.eBroadcastBitModuleLoaded
#| lldb.SBTarget.eBroadcastBitModuleUnloaded
| lldb.SBTarget.eBroadcastBitWatchpointChanged
#| lldb.SBTarget.eBroadcastBitSymbolLoaded
)
self.listener.StartListeningForEventClass(self.debugger,
lldb.SBThread.GetBroadcasterClassName(),
lldb.SBThread.eBroadcastBitStackChanged
# lldb.SBThread.eBroadcastBitBreakpointChanged
| lldb.SBThread.eBroadcastBitThreadSuspended
| lldb.SBThread.eBroadcastBitThreadResumed
| lldb.SBThread.eBroadcastBitSelectedFrameChanged
| lldb.SBThread.eBroadcastBitThreadSelected
)
self.listener.StartListeningForEventClass(self.debugger,
lldb.SBProcess.GetBroadcasterClassName(),
lldb.SBProcess.eBroadcastBitStateChanged
| lldb.SBProcess.eBroadcastBitInterrupt
| lldb.SBProcess.eBroadcastBitSTDOUT
| lldb.SBProcess.eBroadcastBitSTDERR
| lldb.SBProcess.eBroadcastBitProfileData
)
self.listener.StartListeningForEventClass(self.debugger,
lldb.SBCommandInterpreter.GetBroadcasterClass(),
lldb.SBCommandInterpreter.eBroadcastBitThreadShouldExit
| lldb.SBCommandInterpreter.eBroadcastBitResetPrompt
| lldb.SBCommandInterpreter.eBroadcastBitQuitCommandReceived
| lldb.SBCommandInterpreter.eBroadcastBitAsynchronousOutputData
| lldb.SBCommandInterpreter.eBroadcastBitAsynchronousErrorData
)
def createTarget(self, target_image, args=None):
self.handleCommand("target create %s" % target_image)
if args is not None:
self.handleCommand("settings set target.run-args %s" % args)
def attachProcess(self, pid):
self.handleCommand("process attach -p %d" % pid)
pass
def loadCore(self, corefile):
self.handleCommand("target create -c %s" % corefile)
pass
def setDone(self):
self.done = True
def isDone(self):
return self.done
def getPrompt(self):
return self.debugger.GetPrompt()
def getCommandInterpreter(self):
return self.debugger.GetCommandInterpreter()
def getSourceManager(self):
return self.debugger.GetSourceManager()
def setSize(self, width, height):
# FIXME: respect height
self.debugger.SetTerminalWidth(width)
def getTarget(self):
return self.debugger.GetTargetAtIndex(0)
def handleCommand(self, cmd):
ret = lldb.SBCommandReturnObject()
self.getCommandInterpreter().HandleCommand(cmd, ret)
return ret
def eventLoop(self):
while not self.isDone():
event = lldb.SBEvent()
got_event = self.listener.WaitForEvent(lldb.UINT32_MAX, event)
if got_event and not event.IsValid():
self.winAddStr("Warning: Invalid or no event...")
continue
elif not event.GetBroadcaster().IsValid():
continue
self.event_queue.put(event)
def run(self):
self.eventLoop()
def terminate(self):
lldb.SBDebugger.Terminate()
sys.exit(0)
def createDriver(debugger, event_queue):
driver = DebuggerDriver(debugger, event_queue)
#driver.start()
# if pid specified:
# - attach to pid
# else if core file specified
# - create target from corefile
# else
# - create target from file
# - settings append target.run-args <args-from-cmdline>
# source .lldbinit file
return driver

16
lldb/utils/lui/eventwin.py Normal file
View File

@ -0,0 +1,16 @@
import cui
import lldb, lldbutil
class EventWin(cui.TitledWin):
def __init__(self, x, y, w, h):
super(EventWin, self).__init__(x, y, w, h, 'LLDB Event Log')
self.win.scrollok(1)
super(EventWin, self).draw()
def handleEvent(self, event):
if isinstance(event, lldb.SBEvent):
self.win.scroll()
h = self.win.getmaxyx()[0]
self.win.addstr(h-1, 0, lldbutil.get_description(event))
return

890
lldb/utils/lui/lldbutil.py Normal file
View File

@ -0,0 +1,890 @@
"""
This LLDB module contains miscellaneous utilities.
Some of the test suite takes advantage of the utility functions defined here.
They can also be useful for general purpose lldb scripting.
"""
import lldb
import os, sys
import StringIO
# ===================================================
# Utilities for locating/checking executable programs
# ===================================================
def is_exe(fpath):
"""Returns True if fpath is an executable."""
return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
def which(program):
"""Returns the full path to a program; None otherwise."""
fpath, fname = os.path.split(program)
if fpath:
if is_exe(program):
return program
else:
for path in os.environ["PATH"].split(os.pathsep):
exe_file = os.path.join(path, program)
if is_exe(exe_file):
return exe_file
return None
# ===================================================
# Disassembly for an SBFunction or an SBSymbol object
# ===================================================
def disassemble(target, function_or_symbol):
"""Disassemble the function or symbol given a target.
It returns the disassembly content in a string object.
"""
buf = StringIO.StringIO()
insts = function_or_symbol.GetInstructions(target)
for i in insts:
print >> buf, i
return buf.getvalue()
# ==========================================================
# Integer (byte size 1, 2, 4, and 8) to bytearray conversion
# ==========================================================
def int_to_bytearray(val, bytesize):
"""Utility function to convert an integer into a bytearray.
It returns the bytearray in the little endian format. It is easy to get the
big endian format, just do ba.reverse() on the returned object.
"""
import struct
if bytesize == 1:
return bytearray([val])
# Little endian followed by a format character.
template = "<%c"
if bytesize == 2:
fmt = template % 'h'
elif bytesize == 4:
fmt = template % 'i'
elif bytesize == 4:
fmt = template % 'q'
else:
return None
packed = struct.pack(fmt, val)
return bytearray(map(ord, packed))
def bytearray_to_int(bytes, bytesize):
"""Utility function to convert a bytearray into an integer.
It interprets the bytearray in the little endian format. For a big endian
bytearray, just do ba.reverse() on the object before passing it in.
"""
import struct
if bytesize == 1:
return bytes[0]
# Little endian followed by a format character.
template = "<%c"
if bytesize == 2:
fmt = template % 'h'
elif bytesize == 4:
fmt = template % 'i'
elif bytesize == 4:
fmt = template % 'q'
else:
return None
unpacked = struct.unpack(fmt, str(bytes))
return unpacked[0]
# ==============================================================
# Get the description of an lldb object or None if not available
# ==============================================================
def get_description(obj, option=None):
"""Calls lldb_obj.GetDescription() and returns a string, or None.
For SBTarget, SBBreakpointLocation, and SBWatchpoint lldb objects, an extra
option can be passed in to describe the detailed level of description
desired:
o lldb.eDescriptionLevelBrief
o lldb.eDescriptionLevelFull
o lldb.eDescriptionLevelVerbose
"""
method = getattr(obj, 'GetDescription')
if not method:
return None
tuple = (lldb.SBTarget, lldb.SBBreakpointLocation, lldb.SBWatchpoint)
if isinstance(obj, tuple):
if option is None:
option = lldb.eDescriptionLevelBrief
stream = lldb.SBStream()
if option is None:
success = method(stream)
else:
success = method(stream, option)
if not success:
return None
return stream.GetData()
# =================================================
# Convert some enum value to its string counterpart
# =================================================
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")
def stop_reason_to_str(enum):
"""Returns the stopReason string given an enum."""
if enum == lldb.eStopReasonInvalid:
return "invalid"
elif enum == lldb.eStopReasonNone:
return "none"
elif enum == lldb.eStopReasonTrace:
return "trace"
elif enum == lldb.eStopReasonBreakpoint:
return "breakpoint"
elif enum == lldb.eStopReasonWatchpoint:
return "watchpoint"
elif enum == lldb.eStopReasonSignal:
return "signal"
elif enum == lldb.eStopReasonException:
return "exception"
elif enum == lldb.eStopReasonPlanComplete:
return "plancomplete"
elif enum == lldb.eStopReasonThreadExiting:
return "threadexiting"
else:
raise Exception("Unknown StopReason enum")
def symbol_type_to_str(enum):
"""Returns the symbolType string given an enum."""
if enum == lldb.eSymbolTypeInvalid:
return "invalid"
elif enum == lldb.eSymbolTypeAbsolute:
return "absolute"
elif enum == lldb.eSymbolTypeCode:
return "code"
elif enum == lldb.eSymbolTypeData:
return "data"
elif enum == lldb.eSymbolTypeTrampoline:
return "trampoline"
elif enum == lldb.eSymbolTypeRuntime:
return "runtime"
elif enum == lldb.eSymbolTypeException:
return "exception"
elif enum == lldb.eSymbolTypeSourceFile:
return "sourcefile"
elif enum == lldb.eSymbolTypeHeaderFile:
return "headerfile"
elif enum == lldb.eSymbolTypeObjectFile:
return "objectfile"
elif enum == lldb.eSymbolTypeCommonBlock:
return "commonblock"
elif enum == lldb.eSymbolTypeBlock:
return "block"
elif enum == lldb.eSymbolTypeLocal:
return "local"
elif enum == lldb.eSymbolTypeParam:
return "param"
elif enum == lldb.eSymbolTypeVariable:
return "variable"
elif enum == lldb.eSymbolTypeVariableType:
return "variabletype"
elif enum == lldb.eSymbolTypeLineEntry:
return "lineentry"
elif enum == lldb.eSymbolTypeLineHeader:
return "lineheader"
elif enum == lldb.eSymbolTypeScopeBegin:
return "scopebegin"
elif enum == lldb.eSymbolTypeScopeEnd:
return "scopeend"
elif enum == lldb.eSymbolTypeAdditional:
return "additional"
elif enum == lldb.eSymbolTypeCompiler:
return "compiler"
elif enum == lldb.eSymbolTypeInstrumentation:
return "instrumentation"
elif enum == lldb.eSymbolTypeUndefined:
return "undefined"
def value_type_to_str(enum):
"""Returns the valueType string given an enum."""
if enum == lldb.eValueTypeInvalid:
return "invalid"
elif enum == lldb.eValueTypeVariableGlobal:
return "global_variable"
elif enum == lldb.eValueTypeVariableStatic:
return "static_variable"
elif enum == lldb.eValueTypeVariableArgument:
return "argument_variable"
elif enum == lldb.eValueTypeVariableLocal:
return "local_variable"
elif enum == lldb.eValueTypeRegister:
return "register"
elif enum == lldb.eValueTypeRegisterSet:
return "register_set"
elif enum == lldb.eValueTypeConstResult:
return "constant_result"
else:
raise Exception("Unknown ValueType enum")
# ==================================================
# Get stopped threads due to each stop reason.
# ==================================================
def sort_stopped_threads(process,
breakpoint_threads = None,
crashed_threads = None,
watchpoint_threads = None,
signal_threads = None,
exiting_threads = None,
other_threads = None):
""" Fills array *_threads with threads stopped for the corresponding stop
reason.
"""
for lst in [breakpoint_threads,
watchpoint_threads,
signal_threads,
exiting_threads,
other_threads]:
if lst is not None:
lst[:] = []
for thread in process:
dispatched = False
for (reason, list) in [(lldb.eStopReasonBreakpoint, breakpoint_threads),
(lldb.eStopReasonException, crashed_threads),
(lldb.eStopReasonWatchpoint, watchpoint_threads),
(lldb.eStopReasonSignal, signal_threads),
(lldb.eStopReasonThreadExiting, exiting_threads),
(None, other_threads)]:
if not dispatched and list is not None:
if thread.GetStopReason() == reason or reason is None:
list.append(thread)
dispatched = True
# ==================================================
# Utility functions for setting breakpoints
# ==================================================
def run_break_set_by_file_and_line (test, file_name, line_number, extra_options = None, num_expected_locations = 1, loc_exact=False, module_name=None):
"""Set a breakpoint by file and line, returning the breakpoint number.
If extra_options is not None, then we append it to the breakpoint set command.
If num_expected_locations is -1 we check that we got AT LEAST one location, otherwise we check that num_expected_locations equals the number of locations.
If loc_exact is true, we check that there is one location, and that location must be at the input file and line number."""
if file_name == None:
command = 'breakpoint set -l %d'%(line_number)
else:
command = 'breakpoint set -f "%s" -l %d'%(file_name, line_number)
if module_name:
command += " --shlib '%s'" % (module_name)
if extra_options:
command += " " + extra_options
break_results = run_break_set_command (test, command)
if num_expected_locations == 1 and loc_exact:
check_breakpoint_result (test, break_results, num_locations=num_expected_locations, file_name = file_name, line_number = line_number, module_name=module_name)
else:
check_breakpoint_result (test, break_results, num_locations = num_expected_locations)
return get_bpno_from_match (break_results)
def run_break_set_by_symbol (test, symbol, extra_options = None, num_expected_locations = -1, sym_exact = False, module_name=None):
"""Set a breakpoint by symbol name. Common options are the same as run_break_set_by_file_and_line.
If sym_exact is true, then the output symbol must match the input exactly, otherwise we do a substring match."""
command = 'breakpoint set -n "%s"'%(symbol)
if module_name:
command += " --shlib '%s'" % (module_name)
if extra_options:
command += " " + extra_options
break_results = run_break_set_command (test, command)
if num_expected_locations == 1 and sym_exact:
check_breakpoint_result (test, break_results, num_locations = num_expected_locations, symbol_name = symbol, module_name=module_name)
else:
check_breakpoint_result (test, break_results, num_locations = num_expected_locations)
return get_bpno_from_match (break_results)
def run_break_set_by_selector (test, selector, extra_options = None, num_expected_locations = -1, module_name=None):
"""Set a breakpoint by selector. Common options are the same as run_break_set_by_file_and_line."""
command = 'breakpoint set -S "%s"' % (selector)
if module_name:
command += ' --shlib "%s"' % (module_name)
if extra_options:
command += " " + extra_options
break_results = run_break_set_command (test, command)
if num_expected_locations == 1:
check_breakpoint_result (test, break_results, num_locations = num_expected_locations, symbol_name = selector, symbol_match_exact=False, module_name=module_name)
else:
check_breakpoint_result (test, break_results, num_locations = num_expected_locations)
return get_bpno_from_match (break_results)
def run_break_set_by_regexp (test, regexp, extra_options=None, num_expected_locations=-1):
"""Set a breakpoint by regular expression match on symbol name. Common options are the same as run_break_set_by_file_and_line."""
command = 'breakpoint set -r "%s"'%(regexp)
if extra_options:
command += " " + extra_options
break_results = run_break_set_command (test, command)
check_breakpoint_result (test, break_results, num_locations=num_expected_locations)
return get_bpno_from_match (break_results)
def run_break_set_by_source_regexp (test, regexp, extra_options=None, num_expected_locations=-1):
"""Set a breakpoint by source regular expression. Common options are the same as run_break_set_by_file_and_line."""
command = 'breakpoint set -p "%s"'%(regexp)
if extra_options:
command += " " + extra_options
break_results = run_break_set_command (test, command)
check_breakpoint_result (test, break_results, num_locations=num_expected_locations)
return get_bpno_from_match (break_results)
def run_break_set_command (test, command):
"""Run the command passed in - it must be some break set variant - and analyze the result.
Returns a dictionary of information gleaned from the command-line results.
Will assert if the breakpoint setting fails altogether.
Dictionary will contain:
bpno - breakpoint of the newly created breakpoint, -1 on error.
num_locations - number of locations set for the breakpoint.
If there is only one location, the dictionary MAY contain:
file - source file name
line_no - source line number
symbol - symbol name
inline_symbol - inlined symbol name
offset - offset from the original symbol
module - module
address - address at which the breakpoint was set."""
patterns = [r"^Breakpoint (?P<bpno>[0-9]+): (?P<num_locations>[0-9]+) locations\.$",
r"^Breakpoint (?P<bpno>[0-9]+): (?P<num_locations>no) locations \(pending\)\.",
r"^Breakpoint (?P<bpno>[0-9]+): where = (?P<module>.*)`(?P<symbol>[+\-]{0,1}[^+]+)( \+ (?P<offset>[0-9]+)){0,1}( \[inlined\] (?P<inline_symbol>.*)){0,1} at (?P<file>[^:]+):(?P<line_no>[0-9]+), address = (?P<address>0x[0-9a-fA-F]+)$",
r"^Breakpoint (?P<bpno>[0-9]+): where = (?P<module>.*)`(?P<symbol>.*)( \+ (?P<offset>[0-9]+)){0,1}, address = (?P<address>0x[0-9a-fA-F]+)$"]
match_object = test.match (command, patterns)
break_results = match_object.groupdict()
# We always insert the breakpoint number, setting it to -1 if we couldn't find it
# Also, make sure it gets stored as an integer.
if not 'bpno' in break_results:
break_results['bpno'] = -1
else:
break_results['bpno'] = int(break_results['bpno'])
# We always insert the number of locations
# If ONE location is set for the breakpoint, then the output doesn't mention locations, but it has to be 1...
# We also make sure it is an integer.
if not 'num_locations' in break_results:
num_locations = 1
else:
num_locations = break_results['num_locations']
if num_locations == 'no':
num_locations = 0
else:
num_locations = int(break_results['num_locations'])
break_results['num_locations'] = num_locations
if 'line_no' in break_results:
break_results['line_no'] = int(break_results['line_no'])
return break_results
def get_bpno_from_match (break_results):
return int (break_results['bpno'])
def check_breakpoint_result (test, break_results, file_name=None, line_number=-1, symbol_name=None, symbol_match_exact=True, module_name=None, offset=-1, num_locations=-1):
out_num_locations = break_results['num_locations']
if num_locations == -1:
test.assertTrue (out_num_locations > 0, "Expecting one or more locations, got none.")
else:
test.assertTrue (num_locations == out_num_locations, "Expecting %d locations, got %d."%(num_locations, out_num_locations))
if file_name:
out_file_name = ""
if 'file' in break_results:
out_file_name = break_results['file']
test.assertTrue (file_name == out_file_name, "Breakpoint file name '%s' doesn't match resultant name '%s'."%(file_name, out_file_name))
if line_number != -1:
out_file_line = -1
if 'line_no' in break_results:
out_line_number = break_results['line_no']
test.assertTrue (line_number == out_line_number, "Breakpoint line number %s doesn't match resultant line %s."%(line_number, out_line_number))
if symbol_name:
out_symbol_name = ""
# Look first for the inlined symbol name, otherwise use the symbol name:
if 'inline_symbol' in break_results and break_results['inline_symbol']:
out_symbol_name = break_results['inline_symbol']
elif 'symbol' in break_results:
out_symbol_name = break_results['symbol']
if symbol_match_exact:
test.assertTrue(symbol_name == out_symbol_name, "Symbol name '%s' doesn't match resultant symbol '%s'."%(symbol_name, out_symbol_name))
else:
test.assertTrue(out_symbol_name.find(symbol_name) != -1, "Symbol name '%s' isn't in resultant symbol '%s'."%(symbol_name, out_symbol_name))
if module_name:
out_nodule_name = None
if 'module' in break_results:
out_module_name = break_results['module']
test.assertTrue (module_name.find(out_module_name) != -1, "Symbol module name '%s' isn't in expected module name '%s'."%(out_module_name, module_name))
# ==================================================
# Utility functions related to Threads and Processes
# ==================================================
def get_stopped_threads(process, reason):
"""Returns the thread(s) with the specified stop reason in a list.
The list can be empty if no such thread exists.
"""
threads = []
for t in process:
if t.GetStopReason() == reason:
threads.append(t)
return threads
def get_stopped_thread(process, reason):
"""A convenience function which returns the first thread with the given stop
reason or None.
Example usages:
1. Get the stopped thread due to a breakpoint condition
...
from lldbutil import get_stopped_thread
thread = get_stopped_thread(process, lldb.eStopReasonPlanComplete)
self.assertTrue(thread.IsValid(), "There should be a thread stopped due to breakpoint condition")
...
2. Get the thread stopped due to a breakpoint
...
from lldbutil import get_stopped_thread
thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
self.assertTrue(thread.IsValid(), "There should be a thread stopped due to breakpoint")
...
"""
threads = get_stopped_threads(process, reason)
if len(threads) == 0:
return None
return threads[0]
def get_threads_stopped_at_breakpoint (process, bkpt):
""" For a stopped process returns the thread stopped at the breakpoint passed in bkpt"""
stopped_threads = []
threads = []
stopped_threads = get_stopped_threads (process, lldb.eStopReasonBreakpoint)
if len(stopped_threads) == 0:
return threads
for thread in stopped_threads:
# Make sure we've hit our breakpoint...
break_id = thread.GetStopReasonDataAtIndex (0)
if break_id == bkpt.GetID():
threads.append(thread)
return threads
def continue_to_breakpoint (process, bkpt):
""" Continues the process, if it stops, returns the threads stopped at bkpt; otherwise, returns None"""
process.Continue()
if process.GetState() != lldb.eStateStopped:
return None
else:
return get_threads_stopped_at_breakpoint (process, bkpt)
def get_caller_symbol(thread):
"""
Returns the symbol name for the call site of the leaf function.
"""
depth = thread.GetNumFrames()
if depth <= 1:
return None
caller = thread.GetFrameAtIndex(1).GetSymbol()
if caller:
return caller.GetName()
else:
return None
def get_function_names(thread):
"""
Returns a sequence of function names from the stack frames of this thread.
"""
def GetFuncName(i):
return thread.GetFrameAtIndex(i).GetFunctionName()
return map(GetFuncName, range(thread.GetNumFrames()))
def get_symbol_names(thread):
"""
Returns a sequence of symbols for this thread.
"""
def GetSymbol(i):
return thread.GetFrameAtIndex(i).GetSymbol().GetName()
return map(GetSymbol, range(thread.GetNumFrames()))
def get_pc_addresses(thread):
"""
Returns a sequence of pc addresses for this thread.
"""
def GetPCAddress(i):
return thread.GetFrameAtIndex(i).GetPCAddress()
return map(GetPCAddress, range(thread.GetNumFrames()))
def get_filenames(thread):
"""
Returns a sequence of file names from the stack frames of this thread.
"""
def GetFilename(i):
return thread.GetFrameAtIndex(i).GetLineEntry().GetFileSpec().GetFilename()
return map(GetFilename, range(thread.GetNumFrames()))
def get_line_numbers(thread):
"""
Returns a sequence of line numbers from the stack frames of this thread.
"""
def GetLineNumber(i):
return thread.GetFrameAtIndex(i).GetLineEntry().GetLine()
return map(GetLineNumber, range(thread.GetNumFrames()))
def get_module_names(thread):
"""
Returns a sequence of module names from the stack frames of this thread.
"""
def GetModuleName(i):
return thread.GetFrameAtIndex(i).GetModule().GetFileSpec().GetFilename()
return map(GetModuleName, range(thread.GetNumFrames()))
def get_stack_frames(thread):
"""
Returns a sequence of stack frames for this thread.
"""
def GetStackFrame(i):
return thread.GetFrameAtIndex(i)
return map(GetStackFrame, range(thread.GetNumFrames()))
def print_stacktrace(thread, string_buffer = False):
"""Prints a simple stack trace of this thread."""
output = StringIO.StringIO() if string_buffer else sys.stdout
target = thread.GetProcess().GetTarget()
depth = thread.GetNumFrames()
mods = get_module_names(thread)
funcs = get_function_names(thread)
symbols = get_symbol_names(thread)
files = get_filenames(thread)
lines = get_line_numbers(thread)
addrs = get_pc_addresses(thread)
if thread.GetStopReason() != lldb.eStopReasonInvalid:
desc = "stop reason=" + stop_reason_to_str(thread.GetStopReason())
else:
desc = ""
print >> output, "Stack trace for thread id={0:#x} name={1} queue={2} ".format(
thread.GetThreadID(), thread.GetName(), thread.GetQueueName()) + desc
for i in range(depth):
frame = thread.GetFrameAtIndex(i)
function = frame.GetFunction()
load_addr = addrs[i].GetLoadAddress(target)
if not function:
file_addr = addrs[i].GetFileAddress()
start_addr = frame.GetSymbol().GetStartAddress().GetFileAddress()
symbol_offset = file_addr - start_addr
print >> output, " frame #{num}: {addr:#016x} {mod}`{symbol} + {offset}".format(
num=i, addr=load_addr, mod=mods[i], symbol=symbols[i], offset=symbol_offset)
else:
print >> output, " frame #{num}: {addr:#016x} {mod}`{func} at {file}:{line} {args}".format(
num=i, addr=load_addr, mod=mods[i],
func='%s [inlined]' % funcs[i] if frame.IsInlined() else funcs[i],
file=files[i], line=lines[i],
args=get_args_as_string(frame, showFuncName=False) if not frame.IsInlined() else '()')
if string_buffer:
return output.getvalue()
def print_stacktraces(process, string_buffer = False):
"""Prints the stack traces of all the threads."""
output = StringIO.StringIO() if string_buffer else sys.stdout
print >> output, "Stack traces for " + str(process)
for thread in process:
print >> output, print_stacktrace(thread, string_buffer=True)
if string_buffer:
return output.getvalue()
# ===================================
# Utility functions related to Frames
# ===================================
def get_parent_frame(frame):
"""
Returns the parent frame of the input frame object; None if not available.
"""
thread = frame.GetThread()
parent_found = False
for f in thread:
if parent_found:
return f
if f.GetFrameID() == frame.GetFrameID():
parent_found = True
# If we reach here, no parent has been found, return None.
return None
def get_args_as_string(frame, showFuncName=True):
"""
Returns the args of the input frame object as a string.
"""
# arguments => True
# locals => False
# statics => False
# in_scope_only => True
vars = frame.GetVariables(True, False, False, True) # type of SBValueList
args = [] # list of strings
for var in vars:
args.append("(%s)%s=%s" % (var.GetTypeName(),
var.GetName(),
var.GetValue()))
if frame.GetFunction():
name = frame.GetFunction().GetName()
elif frame.GetSymbol():
name = frame.GetSymbol().GetName()
else:
name = ""
if showFuncName:
return "%s(%s)" % (name, ", ".join(args))
else:
return "(%s)" % (", ".join(args))
def print_registers(frame, string_buffer = False):
"""Prints all the register sets of the frame."""
output = StringIO.StringIO() if string_buffer else sys.stdout
print >> output, "Register sets for " + str(frame)
registerSet = frame.GetRegisters() # Return type of SBValueList.
print >> output, "Frame registers (size of register set = %d):" % registerSet.GetSize()
for value in registerSet:
#print >> output, value
print >> output, "%s (number of children = %d):" % (value.GetName(), value.GetNumChildren())
for child in value:
print >> output, "Name: %s, Value: %s" % (child.GetName(), child.GetValue())
if string_buffer:
return output.getvalue()
def get_registers(frame, kind):
"""Returns the registers given the frame and the kind of registers desired.
Returns None if there's no such kind.
"""
registerSet = frame.GetRegisters() # Return type of SBValueList.
for value in registerSet:
if kind.lower() in value.GetName().lower():
return value
return None
def get_GPRs(frame):
"""Returns the general purpose registers of the frame as an SBValue.
The returned SBValue object is iterable. An example:
...
from lldbutil import get_GPRs
regs = get_GPRs(frame)
for reg in regs:
print "%s => %s" % (reg.GetName(), reg.GetValue())
...
"""
return get_registers(frame, "general purpose")
def get_FPRs(frame):
"""Returns the floating point registers of the frame as an SBValue.
The returned SBValue object is iterable. An example:
...
from lldbutil import get_FPRs
regs = get_FPRs(frame)
for reg in regs:
print "%s => %s" % (reg.GetName(), reg.GetValue())
...
"""
return get_registers(frame, "floating point")
def get_ESRs(frame):
"""Returns the exception state registers of the frame as an SBValue.
The returned SBValue object is iterable. An example:
...
from lldbutil import get_ESRs
regs = get_ESRs(frame)
for reg in regs:
print "%s => %s" % (reg.GetName(), reg.GetValue())
...
"""
return get_registers(frame, "exception state")
# ======================================
# Utility classes/functions for SBValues
# ======================================
class BasicFormatter(object):
"""The basic formatter inspects the value object and prints the value."""
def format(self, value, buffer=None, indent=0):
if not buffer:
output = StringIO.StringIO()
else:
output = buffer
# If there is a summary, it suffices.
val = value.GetSummary()
# Otherwise, get the value.
if val == None:
val = value.GetValue()
if val == None and value.GetNumChildren() > 0:
val = "%s (location)" % value.GetLocation()
print >> output, "{indentation}({type}) {name} = {value}".format(
indentation = ' ' * indent,
type = value.GetTypeName(),
name = value.GetName(),
value = val)
return output.getvalue()
class ChildVisitingFormatter(BasicFormatter):
"""The child visiting formatter prints the value and its immediate children.
The constructor takes a keyword arg: indent_child, which defaults to 2.
"""
def __init__(self, indent_child=2):
"""Default indentation of 2 SPC's for the children."""
self.cindent = indent_child
def format(self, value, buffer=None):
if not buffer:
output = StringIO.StringIO()
else:
output = buffer
BasicFormatter.format(self, value, buffer=output)
for child in value:
BasicFormatter.format(self, child, buffer=output, indent=self.cindent)
return output.getvalue()
class RecursiveDecentFormatter(BasicFormatter):
"""The recursive decent formatter prints the value and the decendents.
The constructor takes two keyword args: indent_level, which defaults to 0,
and indent_child, which defaults to 2. The current indentation level is
determined by indent_level, while the immediate children has an additional
indentation by inden_child.
"""
def __init__(self, indent_level=0, indent_child=2):
self.lindent = indent_level
self.cindent = indent_child
def format(self, value, buffer=None):
if not buffer:
output = StringIO.StringIO()
else:
output = buffer
BasicFormatter.format(self, value, buffer=output, indent=self.lindent)
new_indent = self.lindent + self.cindent
for child in value:
if child.GetSummary() != None:
BasicFormatter.format(self, child, buffer=output, indent=new_indent)
else:
if child.GetNumChildren() > 0:
rdf = RecursiveDecentFormatter(indent_level=new_indent)
rdf.format(child, buffer=output)
else:
BasicFormatter.format(self, child, buffer=output, indent=new_indent)
return output.getvalue()

125
lldb/utils/lui/lui.py Executable file
View File

@ -0,0 +1,125 @@
#!/usr/bin/env python
import curses
import lldb
import lldbutil
from optparse import OptionParser
import os
import signal
import sys
import Queue
import debuggerdriver
import cui
import breakwin
import commandwin
import eventwin
import sourcewin
import statuswin
event_queue = None
def handle_args(driver, argv):
parser = OptionParser()
parser.add_option("-p", "--attach", dest="pid", help="Attach to specified Process ID", type="int")
parser.add_option("-c", "--core", dest="core", help="Load specified core file", type="string")
(options, args) = parser.parse_args(argv)
if options.pid is not None:
try:
pid = int(options.pid)
driver.attachProcess(ui, pid)
except ValueError:
print "Error: expecting integer PID, got '%s'" % options.pid
elif options.core is not None:
if not os.path.exists(options.core):
raise Exception("Specified core file '%s' does not exist." % options.core)
driver.loadCore(options.core)
elif len(args) == 2:
if not os.path.isfile(args[1]):
raise Exception("Specified target '%s' does not exist" % args[1])
driver.createTarget(args[1])
elif len(args) > 2:
if not os.path.isfile(args[1]):
raise Exception("Specified target '%s' does not exist" % args[1])
driver.createTarget(args[1], args[2:])
def sigint_handler(signal, frame):
global debugger
debugger.terminate()
class LLDBUI(cui.CursesUI):
def __init__(self, screen, event_queue, driver):
super(LLDBUI, self).__init__(screen, event_queue)
self.driver = driver
h, w = self.screen.getmaxyx()
command_win_height = 20
break_win_width = 60
self.status_win = statuswin.StatusWin(0, h-1, w, 1)
h -= 1
self.command_win = commandwin.CommandWin(driver, 0, h - command_win_height,
w, command_win_height)
h -= command_win_height
self.source_win = sourcewin.SourceWin(driver, 0, 0,
w - break_win_width - 1, h)
self.break_win = breakwin.BreakWin(driver, w - break_win_width, 0,
break_win_width, h)
self.wins = [self.status_win,
#self.event_win,
self.source_win,
self.break_win,
self.command_win,
]
self.focus = len(self.wins) - 1 # index of command window;
def handleEvent(self, event):
# hack
if isinstance(event, int):
if event == curses.KEY_F10:
self.driver.terminate()
if event == 20: # ctrl-T
def foo(cmd):
ret = lldb.SBCommandReturnObject()
self.driver.getCommandInterpreter().HandleCommand(cmd, ret)
foo('target create a.out')
foo('b main')
foo('run')
super(LLDBUI, self).handleEvent(event)
def main(screen):
signal.signal(signal.SIGINT, sigint_handler)
global event_queue
event_queue = Queue.Queue()
global debugger
debugger = lldb.SBDebugger.Create()
driver = debuggerdriver.createDriver(debugger, event_queue)
view = LLDBUI(screen, event_queue, driver)
driver.start()
# hack to avoid hanging waiting for prompts!
driver.handleCommand("settings set auto-confirm true")
handle_args(driver, sys.argv)
view.eventLoop()
if __name__ == "__main__":
try:
curses.wrapper(main)
except KeyboardInterrupt:
exit()

58
lldb/utils/lui/sandbox.py Executable file
View File

@ -0,0 +1,58 @@
#!/usr/bin/env python
import curses
import os
import signal
import sys
import Queue
import cui
event_queue = None
class SandboxUI(cui.CursesUI):
def __init__(self, screen, event_queue):
super(SandboxUI, self).__init__(screen, event_queue)
height, width = self.screen.getmaxyx()
w2 = width / 2
h2 = height / 2
self.wins = []
self.wins.append(cui.TitledWin( 0, 0, w2, h2, "Test Window 1"))
self.wins.append(cui.TitledWin(w2, 0, w2, h2, "Test Window 2"))
self.wins.append(cui.TitledWin( 0, h2, w2, h2, "Test Window 3"))
self.wins.append(cui.TitledWin(w2, h2, w2, h2, "Test Window 4"))
def callback(s, content):
self.wins[0].win.scroll(1)
self.wins[0].win.addstr(10, 0, '%s: %s' % (s, content))
self.wins[0].win.scroll(1)
self.el.showPrompt(10, 0)
self.wins[0].win.scrollok(1)
self.el = cui.CursesEditLine(self.wins[0].win, None,
lambda c: callback('got', c), lambda c: callback('tab', c))
self.el.prompt = '>>> '
self.el.showPrompt(10, 0)
def handleEvent(self, event):
if isinstance(event, int):
if event == ord('q'):
sys.exit(0)
self.el.handleEvent(event)
def main(screen):
global event_queue
event_queue = Queue.Queue()
sandbox = SandboxUI(screen, event_queue)
sandbox.eventLoop()
if __name__ == "__main__":
try:
curses.wrapper(main)
except KeyboardInterrupt:
exit()

239
lldb/utils/lui/sourcewin.py Normal file
View File

@ -0,0 +1,239 @@
import cui
import curses
import lldb, lldbutil
import re
import os
class SourceWin(cui.TitledWin):
def __init__(self, driver, x, y, w, h):
super(SourceWin, self).__init__(x, y, w, h, "Source")
self.sourceman = driver.getSourceManager()
self.sources = {}
self.filename= None
self.pc_line = None
self.viewline = 0
self.breakpoints = { }
self.win.scrollok(1)
self.markerPC = ":) "
self.markerBP = "B> "
self.markerNone = " "
try:
from pygments.formatters import TerminalFormatter
self.formatter = TerminalFormatter()
except ImportError:
#self.win.addstr("\nWarning: no 'pygments' library found. Syntax highlighting is disabled.")
self.lexer = None
self.formatter = None
pass
# FIXME: syntax highlight broken
self.formatter = None
self.lexer = None
def handleEvent(self, event):
if isinstance(event, int):
self.handleKey(event)
return
if isinstance(event, lldb.SBEvent):
if lldb.SBBreakpoint.EventIsBreakpointEvent(event):
self.handleBPEvent(event)
if lldb.SBProcess.EventIsProcessEvent(event) and \
not lldb.SBProcess.GetRestartedFromEvent(event):
process = lldb.SBProcess.GetProcessFromEvent(event)
if not process.IsValid():
return
if process.GetState() == lldb.eStateStopped:
self.refreshSource(process)
elif process.GetState() == lldb.eStateExited:
self.notifyExited(process)
def notifyExited(self, process):
self.win.erase()
target = lldbutil.get_description(process.GetTarget())
pid = process.GetProcessID()
ec = process.GetExitStatus()
self.win.addstr("\nProcess %s [%d] has exited with exit-code %d" % (target, pid, ec))
def pageUp(self):
if self.viewline > 0:
self.viewline = self.viewline - 1
self.refreshSource()
def pageDown(self):
if self.viewline < len(self.content) - self.height + 1:
self.viewline = self.viewline + 1
self.refreshSource()
pass
def handleKey(self, key):
if key == curses.KEY_DOWN:
self.pageDown()
elif key == curses.KEY_UP:
self.pageUp()
def updateViewline(self, total_lines):
half = self.height / 2
if total_lines == 0:
self.viewline = 0
else:
lines_before_pc = self.pc_line
lines_after_pc = total_lines - self.pc_line
if lines_before_pc < half:
self.viewline = 0
elif lines_after_pc < half:
self.viewline = total_lines - self.height + 1
else:
self.viewline = self.pc_line - half + 1
if self.viewline < 0:
raise Exception("negative viewline: pc=%d viewline=%d" % (self.pc_line, self.viewline))
if self.viewline + self.height > len(self.content) + 1:
raise Exception("viewline too large: PC=%d viewline=%d (to %d of %d)" % (self.pc_line,
self.viewline,
self.viewline + self.height - 1,
total_lines))
def refreshSource(self, process = None):
(self.height, self.width) = self.win.getmaxyx()
if process is not None:
loc = process.GetSelectedThread().GetSelectedFrame().GetLineEntry()
f = loc.GetFileSpec()
self.pc_line = loc.GetLine()
if not f.IsValid():
self.win.addstr(0, 0, "Invalid source file")
return
self.filename = f.GetFilename()
path = os.path.join(f.GetDirectory(), self.filename)
self.setTitle(path)
self.content = self.getContent(path)
self.updateViewline(len(self.content))
if self.filename is None:
return
if self.formatter is not None:
from pygments.lexers import get_lexer_for_filename
self.lexer = get_lexer_for_filename(self.filename)
bps = [] if not self.filename in self.breakpoints else self.breakpoints[self.filename]
self.win.erase()
if self.content:
self.formatContent(self.content, self.pc_line, bps)
def getContent(self, path):
content = []
if path in self.sources:
content = self.sources[path]
else:
if os.path.exists(path):
with open(path) as x:
content = x.readlines()
self.sources[path] = content
return content
def formatContent(self, content, pc_line, breakpoints):
source = ""
count = 1
self.win.erase()
for i in range(self.viewline, self.viewline + self.height - 1):
if i > len(content) - 1:
raise Exception("Out of range content (%d-%d of %d)" % (self.viewline,
self.viewline + self.height - 1,
len(content)))
line_num = i + 1
marker = self.markerNone
attr = curses.A_NORMAL
if line_num == pc_line:
attr = curses.A_REVERSE
if line_num in breakpoints:
marker = self.markerBP
line = "%s%3d %s" % (marker, line_num, self.highlight(content[i]))
if len(line) >= self.width:
line = line[0:self.width-1] + "\n"
self.win.addstr(line, attr)
source += line
count = count + 1
return source
def highlight(self, source):
if self.lexer and self.formatter:
from pygments import highlight
return highlight(source, self.lexer, self.formatter)
else:
return source
def addBPLocations(self, locations):
for path in locations:
lines = locations[path]
if path in self.breakpoints:
self.breakpoints[path].update(lines)
else:
self.breakpoints[path] = lines
def removeBPLocations(self, locations):
for path in locations:
lines = locations[path]
if path in self.breakpoints:
self.breakpoints[path].difference_update(lines)
else:
raise "Removing locations that were never added...no good"
def handleBPEvent(self, event):
def getLocations(event):
locs = {}
bp = lldb.SBBreakpoint.GetBreakpointFromEvent(event)
if bp.IsInternal():
# don't show anything for internal breakpoints
return
for location in bp:
# hack! getting the LineEntry via SBBreakpointLocation.GetAddress.GetLineEntry does not work good for
# inlined frames, so we get the description (which does take into account inlined functions) and parse it.
desc = lldbutil.get_description(location, lldb.eDescriptionLevelFull)
match = re.search('at\ ([^:]+):([\d]+)', desc)
try:
path = match.group(1)
line = int(match.group(2).strip())
except ValueError as e:
# bp loc unparsable
continue
if path in locs:
locs[path].add(line)
else:
locs[path] = set([line])
return locs
event_type = lldb.SBBreakpoint.GetBreakpointEventTypeFromEvent(event)
if event_type == lldb.eBreakpointEventTypeEnabled \
or event_type == lldb.eBreakpointEventTypeAdded \
or event_type == lldb.eBreakpointEventTypeLocationsResolved \
or event_type == lldb.eBreakpointEventTypeLocationsAdded:
self.addBPLocations(getLocations(event))
elif event_type == lldb.eBreakpointEventTypeRemoved \
or event_type == lldb.eBreakpointEventTypeLocationsRemoved \
or event_type == lldb.eBreakpointEventTypeDisabled:
self.removeBPLocations(getLocations(event))
elif event_type == lldb.eBreakpointEventTypeCommandChanged \
or event_type == lldb.eBreakpointEventTypeConditionChanged \
or event_type == lldb.eBreakpointEventTypeIgnoreChanged \
or event_type == lldb.eBreakpointEventTypeThreadChanged \
or event_type == lldb.eBreakpointEventTypeInvalidType:
# no-op
pass
self.refreshSource()

28
lldb/utils/lui/statuswin.py Normal file
View File

@ -0,0 +1,28 @@
import lldb, lldbutil
import cui
import curses
class StatusWin(cui.TextWin):
def __init__(self, x, y, w, h):
super(StatusWin, self).__init__(x, y, w)
self.keys = [#('F1', 'Help', curses.KEY_F1),
('F3', 'Cycle-focus', curses.KEY_F3),
('F10', 'Quit', curses.KEY_F10)]
text = ''
for key in self.keys:
text = text + '{0} {1} '.format(key[0], key[1])
self.setText(text)
def handleEvent(self, event):
if isinstance(event, int):
pass
elif isinstance(event, lldb.SBEvent):
if lldb.SBProcess.EventIsProcessEvent(event):
state = lldb.SBProcess.GetStateFromEvent(event)
status = lldbutil.state_type_to_str(state)
self.win.erase()
x = self.win.getmaxyx()[1] - len(status) - 1
self.win.addstr(0, x, status)
return