#!/usr/bin/env python3
"""
A gdb-compatible frontend for lldb that implements just enough
commands to run the tests in the debuginfo-tests repository with lldb.
"""
# ----------------------------------------------------------------------
# Auto-detect lldb python module.
import subprocess, platform, os, sys
try:
# Just try for LLDB in case PYTHONPATH is already correctly setup.
import lldb
except ImportError:
# Ask the command line driver for the path to the lldb module. Copy over
# the environment so that SDKROOT is propagated to xcrun.
command = (
["xcrun", "lldb", "-P"] if platform.system() == "Darwin" else ["lldb", "-P"]
)
# Extend the PYTHONPATH if the path exists and isn't already there.
lldb_python_path = subprocess.check_output(command).decode("utf-8").strip()
if os.path.exists(lldb_python_path) and not sys.path.__contains__(lldb_python_path):
sys.path.append(lldb_python_path)
# Try importing LLDB again.
try:
import lldb
print('imported lldb from: "%s"' % lldb_python_path)
except ImportError:
print(
"error: couldn't locate the 'lldb' module, please set PYTHONPATH correctly"
)
sys.exit(1)
# ----------------------------------------------------------------------
# Command line option handling.
import argparse
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--quiet", "-q", action="store_true", help="ignored")
parser.add_argument(
"-batch", action="store_true", help="exit after processing comand line"
)
parser.add_argument("-n", action="store_true", help="ignore .lldb file")
parser.add_argument(
"-x", dest="script", type=argparse.FileType("r"), help="execute commands from file"
)
parser.add_argument("target", help="the program to debug")
args = parser.parse_args()
# Create a new debugger instance.
debugger = lldb.SBDebugger.Create()
debugger.SkipLLDBInitFiles(args.n)
# Make sure to clean up the debugger on exit.
import atexit
def on_exit():
debugger.Terminate()
atexit.register(on_exit)
# Don't return from lldb function calls until the process stops.
debugger.SetAsync(False)
# Create a target from a file and arch.
arch = os.popen("file " + args.target).read().split()[-1]
target = debugger.CreateTargetWithFileAndArch(args.target, arch)
if not target:
print("Could not create target %s" % args.target)
sys.exit(1)
if not args.script:
print("Interactive mode is not implemented.")
sys.exit(1)
import re
for command in args.script:
# Strip newline and whitespaces and split into words.
cmd = command[:-1].strip().split()
if not cmd:
continue
print("> %s" % command[:-1])
try:
if re.match("^r|(run)$", cmd[0]):
error = lldb.SBError()
launchinfo = lldb.SBLaunchInfo([])
launchinfo.SetWorkingDirectory(os.getcwd())
process = target.Launch(launchinfo, error)
print(error)
if not process or error.fail:
state = process.GetState()
print("State = %d" % state)
print(
"""
ERROR: Could not launch process.
NOTE: There are several reasons why this may happen:
* Root needs to run "DevToolsSecurity --enable".
* Older versions of lldb cannot launch more than one process simultaneously.
"""
)
sys.exit(1)
elif re.match("^b|(break)$", cmd[0]) and len(cmd) == 2:
if re.match("[0-9]+", cmd[1]):
# b line
mainfile = target.FindFunctions("main")[0].compile_unit.file
print(target.BreakpointCreateByLocation(mainfile, int(cmd[1])))
else:
# b file:line
file, line = cmd[1].split(":")
print(target.BreakpointCreateByLocation(file, int(line)))
elif re.match("^ptype$", cmd[0]) and len(cmd) == 2:
# GDB's ptype has multiple incarnations depending on its
# argument (global variable, function, type). The definition
# here is for looking up the signature of a function and only
# if that fails it looks for a type with that name.
# Type lookup in LLDB would be "image lookup --type".
for elem in target.FindFunctions(cmd[1]):
print(elem.function.type)
continue
print(target.FindFirstType(cmd[1]))
elif re.match("^po$", cmd[0]) and len(cmd) > 1:
try:
opts = lldb.SBExpressionOptions()
opts.SetFetchDynamicValue(True)
opts.SetCoerceResultToId(True)
print(target.EvaluateExpression(" ".join(cmd[1:]), opts))
except:
# FIXME: This is a fallback path for the lab.llvm.org
# buildbot running OS X 10.7; it should be removed.
thread = process.GetThreadAtIndex(0)
frame = thread.GetFrameAtIndex(0)
print(frame.EvaluateExpression(" ".join(cmd[1:])))
elif re.match("^p|(print)$", cmd[0]) and len(cmd) > 1:
thread = process.GetThreadAtIndex(0)
frame = thread.GetFrameAtIndex(0)
print(frame.EvaluateExpression(" ".join(cmd[1:])))
elif re.match("^n|(next)$", cmd[0]):
thread = process.GetThreadAtIndex(0)
thread.StepOver()
elif re.match("^q|(quit)$", cmd[0]):
sys.exit(0)
else:
print(debugger.HandleCommand(" ".join(cmd)))
except SystemExit:
raise
except:
print('Could not handle the command "%s"' % " ".join(cmd))
Codebase Browser
llvm