diff --git a/Ghidra/Debug/Debugger-agent-gdb/src/main/py/src/ghidragdb/commands.py b/Ghidra/Debug/Debugger-agent-gdb/src/main/py/src/ghidragdb/commands.py index da22814244..21db9c8f19 100644 --- a/Ghidra/Debug/Debugger-agent-gdb/src/main/py/src/ghidragdb/commands.py +++ b/Ghidra/Debug/Debugger-agent-gdb/src/main/py/src/ghidragdb/commands.py @@ -1506,7 +1506,7 @@ def ghidra_trace_sync_disable(*, is_mi, **kwargs): """ Cease synchronizing the current inferior with the Ghidra trace. - This is the opposite of 'ghidra trace sync-disable', except it will not + This is the opposite of 'ghidra trace sync-enable', except it will not automatically remove hooks. """ diff --git a/Ghidra/Debug/Debugger-agent-lldb/data/debugger-launchers/local-lldb.sh b/Ghidra/Debug/Debugger-agent-lldb/data/debugger-launchers/local-lldb.sh index 8f8a0e123c..3b6f364c57 100755 --- a/Ghidra/Debug/Debugger-agent-lldb/data/debugger-launchers/local-lldb.sh +++ b/Ghidra/Debug/Debugger-agent-lldb/data/debugger-launchers/local-lldb.sh @@ -24,7 +24,7 @@ #@menu-group local #@icon icon.debugger #@help TraceRmiLauncherServicePlugin#lldb -#@enum StartCmd:str run "process launch" "process launch --stop-at-entry" +#@enum StartCmd:str "process launch" "process launch --stop-at-entry" #@arg :str "Image" "The target binary executable image" #@args "Arguments" "Command-line arguments to pass to the target" #@env OPT_LLDB_PATH:str="lldb" "Path to lldb" "The path to lldb. Omit the full path to resolve using the system PATH." diff --git a/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/arch.py b/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/arch.py index 42a3198bc8..246ec7b398 100644 --- a/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/arch.py +++ b/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/arch.py @@ -50,8 +50,8 @@ language_map = { 'thumbv7em': ['ARM:BE:32:Cortex', 'ARM:LE:32:Cortex'], 'armv8': ['ARM:BE:32:v8', 'ARM:LE:32:v8'], 'armv8l': ['ARM:BE:32:v8', 'ARM:LE:32:v8'], - 'arm64': ['ARM:BE:64:v8', 'ARM:LE:64:v8'], - 'arm64e': ['ARM:BE:64:v8', 'ARM:LE:64:v8'], + 'arm64': ['AARCH64:BE:64:v8A', 'AARCH64:LE:64:AppleSilicon', 'AARCH64:LE:64:v8A'], + 'arm64e': ['AARCH64:BE:64:v8A', 'AARCH64:LE:64:AppleSilicon', 'AARCH64:LE:64:v8A'], 'arm64_32': ['ARM:BE:32:v8', 'ARM:LE:32:v8'], 'mips': ['MIPS:BE:32:default', 'MIPS:LE:32:default'], 'mipsr2': ['MIPS:BE:32:default', 'MIPS:LE:32:default'], @@ -141,10 +141,24 @@ compiler_map = { } -def get_arch(): +def find_host_triple(): + dbg = util.get_debugger() + for i in range(dbg.GetNumPlatforms()): + platform = dbg.GetPlatformAtIndex(i) + if platform.GetName() == 'host': + return platform.GetTriple() + return 'unrecognized' + + +def find_triple(): triple = util.get_target().triple - if triple is None: - return "x86_64" + if triple is not None: + return triple + return find_host_triple() + + +def get_arch(): + triple = find_triple() return triple.split('-')[0] @@ -152,7 +166,6 @@ def get_endian(): parm = util.get_convenience_variable('endian') if parm != 'auto': return parm - # Once again, we have to hack using the human-readable 'show' order = util.get_target().GetByteOrder() if order is lldb.eByteOrderLittle: return 'little' @@ -167,15 +180,11 @@ def get_osabi(): parm = util.get_convenience_variable('osabi') if not parm in ['auto', 'default']: return parm - # We have to hack around the fact the LLDB won't give us the current OS ABI - # via the API if it is "auto" or "default". Using "show", we can get it, but - # we have to parse output meant for a human. The current value will be on - # the top line, delimited by double quotes. It will be the last delimited - # thing on that line. ("auto" may appear earlier on the line.) - triple = util.get_target().triple + triple = find_triple() # this is an unfortunate feature of the tests if triple is None or '-' not in triple: return "default" + triple = find_triple() return triple.split('-')[2] @@ -274,29 +283,8 @@ class DefaultRegisterMapper(object): def map_name(self, proc, name): return name - """ - def convert_value(self, value, type=None): - if type is None: - type = value.dynamic_type.strip_typedefs() - l = type.sizeof - # l - 1 because array() takes the max index, inclusive - # NOTE: Might like to pre-lookup 'unsigned char', but it depends on the - # architecture *at the time of lookup*. - cv = value.cast(lldb.lookup_type('unsigned char').array(l - 1)) - rng = range(l) - if self.byte_order == 'little': - rng = reversed(rng) - return bytes(cv[i] for i in rng) - """ - def map_value(self, proc, name, value): - try: - # TODO: this seems half-baked - av = value.to_bytes(8, "big") - except e: - raise ValueError("Cannot convert {}'s value: '{}', type: '{}'" - .format(name, value, value.type)) - return RegVal(self.map_name(proc, name), av) + return RegVal(self.map_name(proc, name), value) def map_name_back(self, proc, name): return name diff --git a/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/commands.py b/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/commands.py index f48e541160..36fcd91966 100644 --- a/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/commands.py +++ b/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/commands.py @@ -16,6 +16,7 @@ from contextlib import contextmanager import functools import inspect +import optparse import os.path import shlex import socket @@ -129,6 +130,8 @@ elif lldb.debugger: 'command container add -h "Commands for connecting to Ghidra" ghidra') lldb.debugger.HandleCommand( 'command container add -h "Commands for exporting data to a Ghidra trace" ghidra trace') + lldb.debugger.HandleCommand( + 'command container add -h "Utility commands for testing with Ghidra" ghidra util') lldb.debugger.HandleCommand( 'command script add -f ghidralldb.commands.ghidra_trace_connect ghidra trace connect') @@ -183,7 +186,7 @@ elif lldb.debugger: lldb.debugger.HandleCommand( 'command script add -f ghidralldb.commands.ghidra_trace_retain_values ghidra trace retain-values') lldb.debugger.HandleCommand( - 'command script add -f ghidralldb.commands.ghidra_trace_get_obj ghidra trace get_obj') + 'command script add -f ghidralldb.commands.ghidra_trace_get_obj ghidra trace get-obj') lldb.debugger.HandleCommand( 'command script add -f ghidralldb.commands.ghidra_trace_get_values ghidra trace get-values') lldb.debugger.HandleCommand( @@ -223,7 +226,7 @@ elif lldb.debugger: lldb.debugger.HandleCommand( 'command script add -f ghidralldb.commands.ghidra_trace_sync_synth_stopped ghidra trace sync-synth-stopped') lldb.debugger.HandleCommand( - 'command script add -f ghidralldb.commands.ghidra_util_mark _mark_') + 'command script add -f ghidralldb.commands.ghidra_util_wait_stopped ghidra util wait-stopped') #lldb.debugger.HandleCommand('target stop-hook add -P ghidralldb.hooks.StopHook') lldb.debugger.SetAsync(True) print("Commands loaded.") @@ -246,20 +249,22 @@ def ghidra_trace_connect(debugger, command, result, internal_dict): """ Connect LLDB to Ghidra for tracing - Address must be of the form 'host:port' + Usage: ghidra trace connect ADDRESS + ADDRESS must be HOST:PORT + + The required address must be of the form 'host:port' """ args = shlex.split(command) STATE.require_no_client() if len(args) != 1: - raise RuntimeError( - "ghidra trace connect: missing required argument 'address'") + raise RuntimeError("Usage: ghidra trace connect ADDRESS") address = args[0] parts = address.split(':') if len(parts) != 2: - raise RuntimeError("address must be in the form 'host:port'") + raise RuntimeError("ADDRESS must be HOST:PORT") host, port = parts try: c = socket.socket() @@ -275,6 +280,9 @@ def ghidra_trace_listen(debugger, command, result, internal_dict): """ Listen for Ghidra to connect for tracing + Usage: ghidra trace listen [ADDRESS] + ADDRESS must be PORT or HOST:PORT + Takes an optional address for the host and port on which to listen. Either the form 'host:port' or just 'port'. If omitted, it will bind to an ephemeral port on all interfaces. If only the port is given, it will bind to @@ -282,18 +290,22 @@ def ghidra_trace_listen(debugger, command, result, internal_dict): established. """ - STATE.require_no_client() - address = command if len(command) > 0 else None - if address is not None: + args = shlex.split(command) + if len(args) == 0: + host, port = '0.0.0.0', 0 + elif len(args) == 1: + address = args[0] parts = address.split(':') if len(parts) == 1: host, port = '0.0.0.0', parts[0] elif len(parts) == 2: host, port = parts else: - raise RuntimeError("address must be 'port' or 'host:port'") + raise RuntimeError("ADDRESS must be PORT or HOST:PORT") else: - host, port = '0.0.0.0', 0 + raise RuntimError("Usage: ghidra trace listen [ADDRESS]") + + STATE.require_no_client() try: s = socket.socket() s.bind((host, int(port))) @@ -304,14 +316,22 @@ def ghidra_trace_listen(debugger, command, result, internal_dict): s.close() print(f"Connection from {chost}:{cport}") STATE.client = Client( - c, "lldb-" + util.LLDB_VERSION.full, methods.REGISTRY) + c, util.LLDB_VERSION.display, methods.REGISTRY) except ValueError: - raise RuntimeError("port must be numeric") + raise RuntimeError("PORT must be numeric") @convert_errors def ghidra_trace_disconnect(debugger, command, result, internal_dict): - """Disconnect LLDB from Ghidra for tracing""" + """ + Disconnect LLDB from Ghidra for tracing + + Usage: ghidra trace disconnect + """ + + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace disconnect") STATE.require_client().close() STATE.reset_client() @@ -339,25 +359,47 @@ def start_trace(name): schema_xml = schema_file.read() with STATE.trace.open_tx("Create Root Object"): root = STATE.trace.create_root_object(schema_xml, 'LldbSession') - root.set_value('_display', 'GNU lldb ' + util.LLDB_VERSION.full) + root.set_value('_display', util.LLDB_VERSION.display) + STATE.trace.create_object(AVAILABLES_PATH).insert() + STATE.trace.create_object(PROCESSES_PATH).insert() util.set_convenience_variable('_ghidra_tracing', "true") @convert_errors def ghidra_trace_start(debugger, command, result, internal_dict): - """Start a Trace in Ghidra""" + """ + Start a Trace in Ghidra + + Usage: ghidra trace start [NAME] + + Takes an optional name for the trace. If omitted, it tries to derive the + name from the target image. + """ + + args = shlex.split(command) + if len(args) == 0: + name = compute_name() + elif len(args) == 1: + name = args[0] + else: + raise RuntimeError("Usage: ghidra trace start [NAME]") STATE.require_client() - name = command if len(command) > 0 else compute_name() - # if name is None: - # name = compute_name() STATE.require_no_trace() start_trace(name) @convert_errors def ghidra_trace_stop(debugger, command, result, internal_dict): - """Stop the Trace in Ghidra""" + """ + Stop the Trace in Ghidra + + Usage: ghidra trace stop + """ + + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace stop") STATE.require_trace().close() STATE.reset_trace() @@ -365,21 +407,41 @@ def ghidra_trace_stop(debugger, command, result, internal_dict): @convert_errors def ghidra_trace_restart(debugger, command, result, internal_dict): - """Restart or start the Trace in Ghidra""" + """ + Restart or start the Trace in Ghidra + + Usage: ghidra trace restart [NAME] + + Takes an optional name for the trace. If omitted, it tries to derive the + name from the target image. + """ + + args = shlex.split(command) + if len(args) == 0: + name = compute_name() + elif len(args) == 1: + name = args[0] + else: + raise RuntimeError("Usage: ghidra trace restart [NAME]") STATE.require_client() if STATE.trace is not None: STATE.trace.close() STATE.reset_trace() - name = command if len(command) > 0 else compute_name() - # if name is None: - # name = compute_name() start_trace(name) @convert_errors def ghidra_trace_info(debugger, command, result, internal_dict): - """Get info about the Ghidra connection""" + """ + Get info about the Ghidra connection + + Usage: ghidra trace info + """ + + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace info") result = {} if STATE.client is None: @@ -397,11 +459,18 @@ def ghidra_trace_info(debugger, command, result, internal_dict): @convert_errors def ghidra_trace_info_lcsp(debugger, command, result, internal_dict): """ - Get the selected Ghidra language-compiler-spec pair. Even when - 'show ghidra language' is 'auto' and/or 'show ghidra compiler' is 'auto', - this command provides the current actual language and compiler spec. + Get the selected Ghidra language-compiler-spec pair + + Usage: ghidra trace info-lcsp + + For diagnostics, shows the Ghidra language-compiler-spec pair that will be + selected when starting the trace. """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace info-lcsp") + language, compiler = arch.compute_ghidra_lcsp() print(f"Selected Ghidra language: {language}") print(f"Selected Ghidra compiler: {compiler}") @@ -411,9 +480,16 @@ def ghidra_trace_info_lcsp(debugger, command, result, internal_dict): def ghidra_trace_txstart(debugger, command, result, internal_dict): """ Start a transaction on the trace + + Usage: ghidra trace tx-start DESCRIPTION + DESCRIPTION must be in quotes if it contains spaces """ - description = command + args = shlex.split(command) + if len(args) != 1: + raise RuntimeError("Usage: ghidra trace tx-start DESCRIPTION") + description = args[0] + STATE.require_no_tx() STATE.tx = STATE.require_trace().start_tx(description, undoable=False) @@ -422,8 +498,14 @@ def ghidra_trace_txstart(debugger, command, result, internal_dict): def ghidra_trace_txcommit(debugger, command, result, internal_dict): """ Commit the current transaction + + Usage: ghidra trace tx-commit """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace tx-commit") + STATE.require_tx().commit() STATE.reset_tx() @@ -433,9 +515,16 @@ def ghidra_trace_txabort(debugger, command, result, internal_dict): """ Abort the current transaction - Use only in emergencies. + Usage: ghidra trace tx-abort + + Use only in emergencies. This may not always succeed, and it may leave the + trace in an inconsistent state. """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace tx-abort") + tx = STATE.require_tx() print("Aborting trace transaction!") tx.abort() @@ -455,23 +544,35 @@ def ghidra_trace_txopen(debugger, command, result, internal_dict): """ Run a command with an open transaction - This is generally useful only when executing a single 'put' command, or - when executing a custom command that performs several puts. + Usage: ghidra trace tx-open DESCRIPTION COMMAND + + Execute the given command with an open transaction. This is generally + useful only when executing a single 'put' command, or when executing a + custom command that performs several puts. """ - items = command.split(" ") - description = items[0] - command = items[1] + args = shlex.split(command) + if len(args) != 2: + raise RuntimeError("Usage: ghidra trace tx-open DESCRIPTION COMMAND") + + description = args[0] + cmd = args[1] with open_tracked_tx(description): - lldb.debugger.HandleCommand(command) + lldb.debugger.GetCommandInterpreter().HandleCommand(cmd, result) @convert_errors def ghidra_trace_save(debugger, command, result, internal_dict): """ Save the current trace + + Usage: ghidra trace save """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace save") + STATE.require_trace().save() @@ -480,17 +581,17 @@ def ghidra_trace_new_snap(debugger, command, result, internal_dict): """ Create a new snapshot + Usage: ghidra trace new-snap DESCRIPTION + Subsequent modifications to machine state will affect the new snapshot. """ - description = str(command) - STATE.require_tx() + args = shlex.split(command) + if len(args) != 1: + raise RuntimeError("Usage: ghidra trace new-snap DESCRIPTION") + description = args[0] -# TODO: A convenience var for the current snapshot -# Will need to update it on: -# ghidra trace snapshot/set-snap -# process ? (only if per-process tracing.... I don't think I'm doing that.) -# ghidra trace trace start/stop/restart + STATE.require_trace().snapshot(description) @convert_errors @@ -498,15 +599,17 @@ def ghidra_trace_set_snap(debugger, command, result, internal_dict): """ Go to a snapshot + Usage: ghidra trace set-snap SNAP + Subsequent modifications to machine state will affect the given snapshot. """ - snap = command - eval = util.get_eval(snap) - if eval.IsValid(): - snap = eval.GetValueAsUnsigned() + args = shlex.split(command) + if len(args) != 1: + raise RuntimeError("Usage: ghidra trace set-snap SNAP") + snap = util.get_eval(args[0]) - STATE.require_trace().set_snap(int(snap)) + STATE.require_trace().set_snap(snap.signed) def quantize_pages(start, end): @@ -553,41 +656,81 @@ def eval_range(address, length): def putmem(address, length, result, pages=True): start, end = eval_range(address, length) - return put_bytes(start, end, result, pages) + put_bytes(start, end, result, pages) @convert_errors def ghidra_trace_putmem(debugger, command, result, internal_dict): """ - Record the given block of memory into the Ghidra trace. + Record the given block of memory into the Ghidra trace + + Usage: ghidra trace putmem ADDRESS LENGTH [PAGES] + + Writes the given range of bytes from memory into the Ghidra trace. ADDRESS + is a memory address. It is expression evaluated within the current target. + LENGTH is the number of bytes to write, also evaluated within the current + target. PAGES is a boolean value. If true, the range will be quantized to + page boundaries that include the requested range. """ - items = command.split(" ") - address = items[0] - length = items[1] - pages = items[2] if len(items) > 2 else True + args = shlex.split(command) + if len(args) == 2: + address = args[0] + length = args[1] + pages = True + elif len(args) == 3: + address = args[0] + length = args[1] + pages = (util.get_eval(args[2]).unsigned != 0) + else: + raise RuntimeError("Usage: ghidra trace putmem ADDRESS LENGTH [PAGES]") STATE.require_tx() - return putmem(address, length, result, pages) + putmem(address, length, result, pages) @convert_errors def ghidra_trace_putval(debugger, command, result, internal_dict): """ - Record the given value into the Ghidra trace, if it's in memory. + Record the given value into the Ghidra trace, if it's in memory + + Usage: ghidra trace putval EXPRESSION [PAGES] + + Evaluates the given expression within the current target. If the resulting + value has an address in the target's memory, the bytes comprising that value + are written into the Ghidra trace. If PAGES is true, then the full page(s) + containing those bytes are written. If the resulting value has no address, + or its address is not in memory, an error results. + + Please note, register and value aliases, e.g., '$pc' or '$1' may be assigned + to a temporary memory address by LLDB. Thus, a command like + + ghidra trace putval $1 + + may result in undefined behavior. """ - items = command.split(" ") - value = items[0] - pages = items[1] if len(items) > 1 else True + args = shlex.split(command) + if len(args) == 1: + expression = args[0] + pages = True + elif len(args) == 2: + expression = args[0] + pages = (util.get_eval(args[2]).unsigned != 0) + else: + raise RuntimeError("Usage: ghidra trace putval EXPRESSION [PAGES]") STATE.require_tx() try: - start = util.parse_and_eval(value) + value = util.get_eval(expression) + address = value.addr except BaseExcepion as e: - raise RuntimeError(f"Value '{value}' has no address: {e}") - end = start + int(start.GetType().GetByteSize()) - return put_bytes(start, end, pages, True) + raise RuntimeError(f"Could not evaluate {expression}: {e}") + if not address.IsValid(): + raise RuntimeError(f"Expression {expression} does not have an address") + start = int(address) + end = start + start + value.size + return put_bytes(start, end, result, pages) def putmem_state(address, length, state, pages=True): @@ -605,31 +748,56 @@ def putmem_state(address, length, state, pages=True): @convert_errors def ghidra_trace_putmem_state(debugger, command, result, internal_dict): """ - Set the state of the given range of memory in the Ghidra trace. + Set the state of the given range of memory in the Ghidra trace + + Usage: ghidra trace putmem-state ADDRESS LENGTH STATE [PAGES] + STATE is one of known, unknown, or error + + Marks the given range of memory in the Ghidra trace with the given state. + By default, all addresses in the trace are marked 'unknown'. Writing bytes + to the trace, e.g., via putmem, implicitly marks the affected bytes as + 'known'. The interpretation of START, LENGTH, and PAGES is the same as in + 'ghidra trace putmem'. """ - items = command.split(" ") - address = items[0] - length = items[1] - state = items[2] + args = shlex.split(command) + if len(args) == 3: + address = args[0] + length = args[1] + state = args[2] + pages = True + elif len(args) == 4: + address = args[0] + length = args[1] + state = args[2] + pages = (util.get_eval(args[2]).unsigned != 0) + else: + raise RuntimeError( + "Usage: ghidra trace putmem ADDRESS LENGTH STATE [PAGES]") STATE.require_tx() - putmem_state(address, length, state) + putmem_state(address, length, state, pages) @convert_errors def ghidra_trace_delmem(debugger, command, result, internal_dict): """ - Delete the given range of memory from the Ghidra trace. + Delete the given range of memory from the Ghidra trace - Why would you do this? Keep in mind putmem quantizes to full pages by - default, usually to take advantage of spatial locality. This command does - not quantize. You must do that yourself, if necessary. + Usage: ghidra trace delmem ADDRESS LENGTH + + Why would you do this? There are probably good reasons, but please consider + that deleting information is typically not helping the user. + + Note there is no PAGES argument. This is to prevent accidental deletion of + more bytes than intended. Expand the range manually, if you must. """ - items = command.split(" ") - address = items[0] - length = items[1] + args = shlex.split(command) + if len(args) != 2: + raise RuntimeError("Usage: ghidra trace delmem ADDRESS LENGTH") + address = args[0] + length = args[1] STATE.require_tx() start, end = eval_range(address, length) @@ -641,22 +809,25 @@ def ghidra_trace_delmem(debugger, command, result, internal_dict): def putreg(frame, bank): proc = util.get_process() - space = REGS_PATTERN.format(procnum=proc.GetProcessID(), tnum=util.selected_thread().GetThreadID(), + space = REGS_PATTERN.format(procnum=proc.GetProcessID(), + tnum=util.selected_thread().GetThreadID(), level=frame.GetFrameID()) - subspace = BANK_PATTERN.format(procnum=proc.GetProcessID(), tnum=util.selected_thread().GetThreadID(), - level=frame.GetFrameID(), bank=bank.name) + bank_path = BANK_PATTERN.format(procnum=proc.GetProcessID(), + tnum=util.selected_thread().GetThreadID(), + level=frame.GetFrameID(), bank=bank.name) STATE.trace.create_overlay_space('register', space) robj = STATE.trace.create_object(space) robj.insert() - bobj = STATE.trace.create_object(subspace) + bobj = STATE.trace.create_object(bank_path) bobj.insert() mapper = STATE.trace.register_mapper values = [] - for i in range(0, bank.GetNumChildren()): + for i in range(bank.GetNumChildren()): item = bank.GetChildAtIndex(i, lldb.eDynamicCanRunTarget, True) values.append(mapper.map_value( - proc, item.GetName(), item.GetValueAsUnsigned())) - bobj.set_value(item.GetName(), hex(item.GetValueAsUnsigned())) + proc, item.GetName(), data_to_reg_bytes(item.data))) + # In the tree, just use the human-friendly display value + bobj.set_value(item.GetName(), item.value) # TODO: Memorize registers that failed for this arch, and omit later. STATE.trace.put_registers(space, values) @@ -664,78 +835,128 @@ def putreg(frame, bank): @convert_errors def ghidra_trace_putreg(debugger, command, result, internal_dict): """ - Record the given register group for the current frame into the Ghidra trace. + Record the given register group for the current frame into the Ghidra trace + + Usage: ghidra trace putreg [GROUP] If no group is specified, 'all' is assumed. """ - group = command if len(command) > 0 else 'all' + args = shlex.split(command) + if len(args) == 0: + group = 'all' + elif len(args) == 1: + group = args[0] + else: + raise RuntimeError("Usage: ghidra trace putreg [GROUP]") STATE.require_tx() frame = util.selected_frame() regs = frame.GetRegisters() - if group != 'all': - bank = regs.GetFirstValueByName(group) - return putreg(frame, bank) + with STATE.client.batch() as b: + if group != 'all': + bank = regs.GetFirstValueByName(group) + putreg(frame, bank) + return + + for i in range(0, regs.GetSize()): + bank = regs.GetValueAtIndex(i) + putreg(frame, bank) - for i in range(0, regs.GetSize()): - bank = regs.GetValueAtIndex(i) - putreg(frame, bank) + +def collect_mapped_names(names, proc, bank): + mapper = STATE.trace.register_mapper + for i in range(bank.GetNumChildren()): + item = bank.GetChildAtIndex(i, lldb.eDynamicCanRunTarget, True) + names.append(mapper.map_name(proc, item.GetName())) @convert_errors def ghidra_trace_delreg(debugger, command, result, internal_dict): """ - Delete the given register group for the curent frame from the Ghidra trace. + Delete the given register group for the current frame from the Ghidra trace - Why would you do this? If no group is specified, 'all' is assumed. + Usage: ghidra trace delreg [GROUP] + + If no group is specified, 'all' is assumed. + + Why would you do this? There are probably good reasons, but please consider + that deleting information is typically not helping the user. """ - group = command if len(command) > 0 else 'all' + args = shlex.split(command) + if len(args) == 0: + group = 'all' + elif len(args) == 1: + group = args[0] + else: + raise RuntimeError("Usage: ghidra trace delreg [GROUP]") STATE.require_tx() proc = util.get_process() frame = util.selected_frame() + regs = frame.GetRegisters() space = REGS_PATTERN.format(procnum=proc.GetProcessID(), tnum=util.selected_thread().GetThreadID(), level=frame.GetFrameID()) - mapper = STATE.trace.register_mapper names = [] - for desc in frame.registers: - names.append(mapper.map_name(proc, desc.name)) - return STATE.trace.delete_registers(space, names) + if group != 'all': + bank = regs.GetFirstValueByName(group) + collect_mapped_names(names, proc, bank) + else: + for i in range(regs.GetSize()): + bank = regs.GetValueAtIndex(i) + collect_mapped_names(names, proc, bank) + STATE.trace.delete_registers(space, names) @convert_errors def ghidra_trace_create_obj(debugger, command, result, internal_dict): """ - Create an object in the Ghidra trace. + Create an object in the Ghidra trace + + Usage: ghidra trace create-obj PATH + + PATH gives the objects fully-qualified name, e.g., Processes[0].Threads[1], + which often denotes the second thread of the first target process. The new object is in a detached state, so it may not be immediately - recognized by the Debugger GUI. Use 'ghidra_trace_insert-obj' to finish the + recognized by the Debugger GUI. Use 'ghidra trace insert-obj' to finish the object, after all its required attributes are set. """ - path = command + args = shlex.split(command) + if len(args) != 1: + raise RuntimeError("Usage: ghidra trace create-obj PATH") + path = args[0] STATE.require_tx() obj = STATE.trace.create_object(path) obj.insert() - print(f"Created object: id={obj.id}, path='{obj.path}'") + result.PutCString(f"Created object: id={obj.id}, path='{obj.path}'") @convert_errors def ghidra_trace_insert_obj(debugger, command, result, internal_dict): """ - Insert an object into the Ghidra trace. + Insert an object into the Ghidra trace + + Usage: ghidra trace insert-obj PATH + + See 'ghidra trace create-obj'. An object in a detached state is missing + some or all of its ancestry for its lifespan. Inserting the object creates + its ancestry for its whole lifespan. """ - path = command + args = shlex.split(command) + if len(args) != 1: + raise RuntimeError("Usage: ghidra trace insert-obj PATH") + path = args[0] # NOTE: id parameter is probably not necessary, since this command is for # humans. STATE.require_tx() span = STATE.trace.proxy_object_path(path).insert() - print(f"Inserted object: lifespan={span}") + result.PutCString(f"Inserted object: lifespan={span}") @convert_errors @@ -743,11 +964,16 @@ def ghidra_trace_remove_obj(debugger, command, result, internal_dict): """ Remove an object from the Ghidra trace. + Usage: ghidra trace remove-obj PATH + This does not delete the object. It just removes it from the tree for the current snap and onwards. """ - path = command + args = shlex.split(command) + if len(args) != 1: + raise RuntimeError("Usage: ghidra trace remove-obj PATH") + path = args[0] # NOTE: id parameter is probably not necessary, since this command is for # humans. @@ -782,8 +1008,34 @@ def to_short_list(value, type): return [int(value.GetChildAtIndex(i).GetValueAsUnsigned()) for i in range(0, n)] -def eval_value(value, schema=None): - val = util.get_eval(value) +def get_byte_order(order): + if order == lldb.eByteOrderBig: + return 'big' + elif order == lldb.eByteOrderLittle: + return 'little' + elif order == lldb.eByteOrderPDP: + raise ValueError("PDP byte order unsupported") + else: + raise ValueError(f"Unrecognized order: {order}") + + +def data_to_int(data): + order = get_byte_order(data.byte_order) + return int.from_bytes(data.uint8s, order) + + +def data_to_reg_bytes(data): + order = get_byte_order(data.byte_order) + if order == 'little': + return bytes(reversed(data.uint8s)) + return bytes(data.uint8s) + + +def eval_value(expr, schema=None): + return convert_value(util.get_eval(expr), schema) + + +def convert_value(val, schema=None): type = val.GetType() while type.IsTypedefType(): type = type.GetTypedefedType() @@ -796,13 +1048,13 @@ def eval_value(value, schema=None): return int(val.GetValueAsUnsigned()), sch.CHAR return int(val.GetValueAsUnsigned()), sch.BYTE if code == lldb.eBasicTypeShort or code == lldb.eBasicTypeUnsignedShort: - return int(val.GetValue()), sch.SHORT + return data_to_int(val.data), sch.SHORT if code == lldb.eBasicTypeInt or code == lldb.eBasicTypeUnsignedInt: - return int(val.GetValue()), sch.INT + return data_to_int(val.data), sch.INT if code == lldb.eBasicTypeLong or code == lldb.eBasicTypeUnsignedLong: - return int(val.GetValue()), sch.LONG + return data_to_int(val.data), sch.LONG if code == lldb.eBasicTypeLongLong or code == lldb.eBasicTypeUnsignedLongLong: - return int(val.GetValue()), sch.LONG + return data_to_int(val.data), sch.LONG if code == lldb.eBasicTypeBool: return bool(val.GetValue()), sch.BOOL @@ -853,7 +1105,7 @@ def eval_value(value, schema=None): else: return to_int_list(val, type), sch.LONG_ARR elif type.IsPointerType(): - offset = int(val.GetValue(), 16) + offset = data_to_int(val.data) proc = util.get_process() base, addr = STATE.trace.memory_mapper.map(proc, offset) return (base, addr), sch.ADDRESS @@ -863,12 +1115,18 @@ def eval_value(value, schema=None): @convert_errors def ghidra_trace_set_value(debugger, command, result, internal_dict): """ - Set a value (attribute or element) in the Ghidra trace's object tree. + Set a value (attribute or element) in the Ghidra trace's object tree - A void value implies removal. NOTE: The type of an expression may be - subject to LLDB's current language. e.g., there is no 'bool' in C. You may - have to change to C++ if you need this type. Alternatively, you can use the - Python API. + Usage: ghidra trace set-value PATH KEY VALUE [SCHEMA] + + The object at PATH must exist, though it need not be inserted, yet. To + denote an element, KEY must be in the form [INDEX]. VALUE is an expression + evaluated within the current target. This command will attempt to convert + the value according to its type, into a type recordable by the Ghidra trace. + + A void or null value implies removal. NOTE: The type of an expression may be + subject to LLDB's current language. To explicitly specify the type, include + the SCHEMA argument. """ # NOTE: id parameter is probably not necessary, since this command is for @@ -878,20 +1136,21 @@ def ghidra_trace_set_value(debugger, command, result, internal_dict): # if we ever allow ids here, since the id would be for the object, not the # complete value path. - items = command.split(" ") - path = items[0] - key = items[1] - value = items[2] - if len(items) > 3 and items[3] != "": - schema = items[3] - # This is a horrible hack - if (value.startswith("\"") or value.startswith("L\"")) and schema.endswith("\""): - value = value+" "+schema - schema = None - else: + args = shlex.split(command) + if len(args) == 3: + path = args[0] + key = args[1] + value = args[2] schema = None + elif len(args) == 4: + path = args[0] + key = args[1] + value = args[2] + schema = sch.Schema(args[3]) + else: + raise RuntimeError( + "Usage: ghidra trace set-value PATH KEY VALUE [SCHEMA]") - schema = None if schema is None else sch.Schema(schema) STATE.require_tx() if schema == sch.OBJECT: val = STATE.trace.proxy_object_path(value) @@ -905,57 +1164,68 @@ def ghidra_trace_set_value(debugger, command, result, internal_dict): STATE.trace.proxy_object_path(path).set_value(key, val, schema) +retain_values_parser = optparse.OptionParser(prog='ghidra trace retain-values', + usage=""" +Usage: %prog [OPTIONS] [KEYS...]""") +retain_values_parser.add_option( + '-e', '--elements', action='store_const', dest='kinds', default='elements', + const='elements', help="Remove all other elements") +retain_values_parser.add_option( + '-a', '--attributes', action='store_const', dest='kinds', + const='attributes', help="Remove all other attributes") +retain_values_parser.add_option( + '-b', '--both', action='store_const', dest='kinds', + const='both', help="Remove all other elements and attributes") + + @convert_errors def ghidra_trace_retain_values(debugger, command, result, internal_dict): """ - Retain only those keys listed, settings all others to null. + Retain only those keys listed, setting all others to null - Takes a list of keys to retain. The first argument may optionally be one of - the following: + Usage: ghidra trace retain-values [OPTIONS] PATH [KEYS...] + + OPTIONS may be one of: --elements To set all other elements to null (default) --attributes To set all other attributes to null --both To set all other values (elements and attributes) to null - If, for some reason, one of the keys to retain would be mistaken for this - switch, then the switch is required. Only the first argument is taken as the - switch. All others are taken as keys. + KEYS is a space-separated list of keys to keep. This list may be empty, in + which case, all keys of the specified kind are removed. """ - items = command.split(" ") - path = items[0] - keys = items[1:] + options, args = retain_values_parser.parse_args(shlex.split(command)) + if len(args) < 1: + raise RuntimeError( + "Usage: ghidra trace retain-values [OPTIONS] PATH [KEYS...]") + path = args[0] + keys = args[1:] STATE.require_tx() - kinds = 'elements' - if keys[0] == '--elements': - kinds = 'elements' - keys = keys[1:] - elif keys[0] == '--attributes': - kinds = 'attributes' - keys = keys[1:] - elif keys[0] == '--both': - kinds = 'both' - keys = keys[1:] - elif keys[0].startswith('--'): - raise RuntimeError("Invalid argument: " + keys[0]) - STATE.trace.proxy_object_path(path).retain_values(keys, kinds=kinds) + STATE.trace.proxy_object_path( + path).retain_values(keys, kinds=options.kinds) @convert_errors def ghidra_trace_get_obj(debugger, command, result, internal_dict): """ - Get an object descriptor by its canonical path. + Get an object descriptor by its canonical path + + Usage: ghidra trace get-obj PATH This isn't the most informative, but it will at least confirm whether an object exists and provide its id. """ - path = command + args = shlex.split(command) + if len(args) != 1: + raise RuntimeError("Usage: ghidra trace get-obj PATH") + path = args[0] trace = STATE.require_trace() object = trace.get_object(path) - return object + result.PutCString(f"{object.id}\t{object.path}") class TableColumn(object): @@ -970,9 +1240,8 @@ class TableColumn(object): def finish(self): self.width = max(len(d) for d in self.contents) + 1 - def print_cell(self, i): - print( - self.contents[i] if self.is_last else self.contents[i].ljust(self.width), end='') + def format_cell(self, i): + return self.contents[i] if self.is_last else self.contents[i].ljust(self.width) class Tabular(object): @@ -986,13 +1255,11 @@ class Tabular(object): c.add_data(d) self.num_rows += 1 - def print_table(self): + def print_table(self, printfn): for c in self.columns: c.finish() for rn in range(self.num_rows): - for c in self.columns: - c.print_cell(rn) - print('') + printfn(''.join(c.format_cell(rn) for c in self.columns)) def val_repr(value): @@ -1003,37 +1270,56 @@ def val_repr(value): return repr(value) -def print_values(values): +def print_values(values, printfn): table = Tabular(['Parent', 'Key', 'Span', 'Value', 'Type']) for v in values: table.add_row( [v.parent.path, v.key, v.span, val_repr(v.value), v.schema]) - table.print_table() + table.print_table(printfn) @convert_errors def ghidra_trace_get_values(debugger, command, result, internal_dict): """ - List all values matching a given path pattern. + List all values matching a given path pattern + + Usage: ghidra trace get-values PATTERN + + PATTERN is a path where blanks indicate wild cards. Beware, this may seem a + little odd, esp., when the final key is a wild card. Here are some examples: + + Processes[] To get all processes + Processes[0].Threads[] To get all threads in the first process + Processes[].Threads[] To get all threads from all processes + Processes[0]. (Note the trailing period) to get all attributes + of the first process """ - pattern = command + args = shlex.split(command) + if len(args) != 1: + raise RuntimeError("Usage: ghidra trace get-values PATTERN") + pattern = args[0] trace = STATE.require_trace() values = trace.get_values(pattern) - print_values(values) - return values + print_values(values, result.PutCString) @convert_errors def ghidra_trace_get_values_rng(debugger, command, result, internal_dict): """ - List all values intersecting a given address range. + List all values intersecting a given address range + + Usage: ghidra trace get-values-rng ADDRESS LENGTH + + This can only retrieve values of type ADDRESS or RANGE. """ - items = command.split(" ") - address = items[0] - length = items[1] + args = shlex.split(command) + if len(args) != 2: + raise RuntimeError("Usage: ghidra trace get-values-rng ADDRESS LENGTH") + address = args[0] + length = args[1] trace = STATE.require_trace() start, end = eval_range(address, length) @@ -1041,8 +1327,7 @@ def ghidra_trace_get_values_rng(debugger, command, result, internal_dict): base, addr = trace.memory_mapper.map(proc, start) # Do not create the space. We're querying. No tx. values = trace.get_values_intersecting(addr.extend(end - start)) - print_values(values) - return values + print_values(values, result.PutCString) def activate(path=None): @@ -1066,13 +1351,21 @@ def activate(path=None): @convert_errors def ghidra_trace_activate(debugger, command, result, internal_dict): """ - Activate an object in Ghidra's GUI. + Activate an object in Ghidra's GUI - This has no effect if the current trace is not current in Ghidra. If path is + Usage: ghidra trace activate [PATH] + + This has no effect if the current trace is not current in Ghidra. If PATH is omitted, this will activate the current frame. """ - path = command if len(command) > 0 else None + args = shlex.split(command) + if len(args) == 0: + path = None + elif len(args) == 1: + path = args[0] + else: + raise RuntimeError("Usage: ghidra trace putmem ADDRESS LENGTH [PAGES]") activate(path) @@ -1080,13 +1373,18 @@ def ghidra_trace_activate(debugger, command, result, internal_dict): @convert_errors def ghidra_trace_disassemble(debugger, command, result, internal_dict): """ - Disassemble starting at the given seed. + Disassemble starting at the given seed + + Usage: ghidra trace disassemble ADDRESS Disassembly proceeds linearly and terminates at the first branch or unknown memory encountered. """ - address = command + args = shlex.split(command) + if len(args) != 1: + raise RuntimeError("Usage: ghidra trace disassemble ADDRESS") + address = args[0] STATE.require_tx() start = eval_address(address) @@ -1096,7 +1394,7 @@ def ghidra_trace_disassemble(debugger, command, result, internal_dict): trace.create_overlay_space(base, addr.space) length = STATE.trace.disassemble(addr) - print(f"Disassembled {length} bytes") + result.PutCString(f"Disassembled {length} bytes") def compute_proc_state(proc=None): @@ -1132,9 +1430,15 @@ def put_state(event_process): @convert_errors def ghidra_trace_put_processes(debugger, command, result, internal_dict): """ - Put the list of processes into the trace's Processes list. + Put the list of processes into the trace's Processes list + + Usage: ghidra trace put-processes """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace put-processes") + STATE.require_tx() with STATE.client.batch() as b: put_processes() @@ -1155,9 +1459,15 @@ def put_available(): @convert_errors def ghidra_trace_put_available(debugger, command, result, internal_dict): """ - Put the list of available processes into the trace's Available list. + Put the list of available processes into the trace's Available list + + Usage: ghidra trace put-available """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace put-available") + STATE.require_tx() with STATE.client.batch() as b: put_available() @@ -1184,6 +1494,7 @@ def put_single_breakpoint(b, ibobj, proc, ikeys): brkobj.set_value('Hit Count', b.GetHitCount()) brkobj.set_value('Ignore Count', b.GetIgnoreCount()) brkobj.set_value('Temporary', b.IsOneShot()) + brkobj.set_value('Enabled', b.IsEnabled()) keys = [] locs = util.BREAKPOINT_LOCATION_INFO_READER.get_locations(b) hooks.BRK_STATE.update_brkloc_count(b, len(locs)) @@ -1199,6 +1510,7 @@ def put_single_breakpoint(b, ibobj, proc, ikeys): if base != addr.space: STATE.trace.create_overlay_space(base, addr.space) locobj.set_value('_range', addr.extend(1)) + locobj.set_value('Enabled', l.IsEnabled()) else: # I guess it's a catchpoint pass locobj.insert() @@ -1230,6 +1542,7 @@ def put_single_watchpoint(b, ibobj, proc, ikeys): brkobj.set_value('Hardware Index', b.GetHardwareIndex()) brkobj.set_value('Watch Address', hex(b.GetWatchAddress())) brkobj.set_value('Watch Size', b.GetWatchSize()) + brkobj.set_value('Enabled', b.IsEnabled()) brkobj.insert() @@ -1267,9 +1580,15 @@ def put_watchpoints(): @convert_errors def ghidra_trace_put_breakpoints(debugger, command, result, internal_dict): """ - Put the current process's breakpoints into the trace. + Put the current process's breakpoints into the trace + + Usage: ghidra trace put-breakpoints """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace put-breakpoints") + STATE.require_tx() with STATE.client.batch() as b: put_breakpoints() @@ -1278,9 +1597,15 @@ def ghidra_trace_put_breakpoints(debugger, command, result, internal_dict): @convert_errors def ghidra_trace_put_watchpoints(debugger, command, result, internal_dict): """ - Put the current process's watchpoints into the trace. + Put the current process's watchpoints into the trace + + Usage: ghidra trace put-watchpoints """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace put-watchpoints") + STATE.require_tx() with STATE.client.batch() as b: put_watchpoints() @@ -1301,8 +1626,14 @@ def put_environment(): def ghidra_trace_put_environment(debugger, command, result, internal_dict): """ Put some environment indicators into the Ghidra trace + + Usage: ghidra trace put-environment """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace put-environment") + STATE.require_tx() with STATE.client.batch() as b: put_environment() @@ -1341,8 +1672,14 @@ def put_regions(): def ghidra_trace_put_regions(debugger, command, result, internal_dict): """ Read the memory map, if applicable, and write to the trace's Regions + + Usage: ghidra trace put-regions """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace put-regions") + STATE.require_tx() with STATE.client.batch() as b: put_regions() @@ -1389,8 +1726,14 @@ def put_modules(): def ghidra_trace_put_modules(debugger, command, result, internal_dict): """ Gather object files, if applicable, and write to the trace's Modules + + Usage: ghidra trace put-modules """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace put-modules") + STATE.require_tx() with STATE.client.batch() as b: put_modules() @@ -1464,8 +1807,14 @@ def put_event_thread(): def ghidra_trace_put_threads(debugger, command, result, internal_dict): """ Put the current process's threads into the Ghidra trace + + Usage: ghidra trace put-threads """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace put-threads") + STATE.require_tx() with STATE.client.batch() as b: put_threads() @@ -1499,8 +1848,14 @@ def put_frames(): def ghidra_trace_put_frames(debugger, command, result, internal_dict): """ Put the current thread's frames into the Ghidra trace + + Usage: ghidra trace put-frames """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace put-frames") + STATE.require_tx() with STATE.client.batch() as b: put_frames() @@ -1510,8 +1865,14 @@ def ghidra_trace_put_frames(debugger, command, result, internal_dict): def ghidra_trace_put_all(debugger, command, result, internal_dict): """ Put everything currently selected into the Ghidra trace + + Usage: ghidra trace put-all """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace put-all") + STATE.require_tx() with STATE.client.batch() as b: ghidra_trace_putreg(debugger, DEFAULT_REGISTER_BANK, @@ -1533,8 +1894,14 @@ def ghidra_trace_put_all(debugger, command, result, internal_dict): def ghidra_trace_install_hooks(debugger, command, result, internal_dict): """ Install hooks to trace in Ghidra + + Usage: ghidra trace install-hooks """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace install-hooks") + hooks.install_hooks() @@ -1543,11 +1910,17 @@ def ghidra_trace_remove_hooks(debugger, command, result, internal_dict): """ Remove hooks to trace in Ghidra + Usage: ghidra trace remove-hooks + Using this directly is not recommended, unless it seems the hooks are preventing lldb or other extensions from operating. Removing hooks will break trace synchronization until they are replaced. """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace remove-hooks") + hooks.remove_hooks() @@ -1556,17 +1929,21 @@ def ghidra_trace_sync_enable(debugger, command, result, internal_dict): """ Synchronize the current process with the Ghidra trace + Usage: ghidra trace sync-enable + This will automatically install hooks if necessary. The goal is to record the current frame, thread, and process into the trace immediately, and then to append the trace upon stopping and/or selecting new frames. This action is effective only for the current process. This command must be executed - for each individual process you'd like to synchronize. In older versions of - lldb, certain events cannot be hooked. In that case, you may need to execute - certain "trace put" commands manually, or go without. + for each individual process you'd like to synchronize. This will have no effect unless or until you start a trace. """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace sync-enable") + hooks.install_hooks() hooks.enable_current_process() @@ -1576,10 +1953,16 @@ def ghidra_trace_sync_disable(debugger, command, result, internal_dict): """ Cease synchronizing the current process with the Ghidra trace - This is the opposite of 'ghidra_trace_sync-disable', except it will not + Usage: ghidra trace sync-disable + + This is the opposite of 'ghidra trace sync-enable', except it will not automatically remove hooks. """ + args = shlex.split(command) + if len(args) != 0: + raise RuntimeError("Usage: ghidra trace sync-disable") + hooks.disable_current_process() @@ -1598,23 +1981,27 @@ def ghidra_trace_sync_synth_stopped(debugger, command, result, internal_dict): @convert_errors def ghidra_util_wait_stopped(debugger, command, result, internal_dict): """ - Spin wait until the selected thread is stopped. + Spin wait until the selected thread is stopped + + Usage: ghidra util wait-stopped [SECONDS] + + An optional timeout may be given in seconds. If omitted, the timeout is 1 + second. """ - timeout = commmand if len(command) > 0 else '1' + args = shlex.split(command) + if len(args) == 0: + timeout = 1 + elif len(args) == 1: + timeout = int(args[0]) + else: + raise RuntimeError("Usage: ghidra util wait-stopped [SECONDS]") - timeout = int(timeout) start = time.time() - t = util.selected_thread() - if t is None: - return - while not t.IsStopped() and not t.IsSuspended(): - t = util.selected_thread() # I suppose it could change + p = util.selected_process() + while p is not None and p.state == lldb.eStateRunnig: time.sleep(0.1) + p = util.selected_process() # I suppose it could change if time.time() - start > timeout: raise RuntimeError('Timed out waiting for thread to stop') - - -@convert_errors -def ghidra_util_mark(debugger, command, result, internal_dict): - print(command) + print(f"Finished wait. State={p.state}") diff --git a/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/hooks.py b/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/hooks.py index 7b58444401..b635cb94e1 100644 --- a/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/hooks.py +++ b/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/hooks.py @@ -67,13 +67,22 @@ class ProcessState(object): hashable_frame = (thread.GetThreadID(), frame.GetFrameID()) if first or hashable_frame not in self.visited: banks = frame.GetRegisters() - primary = banks.GetFirstValueByName(commands.DEFAULT_REGISTER_BANK) + primary = banks.GetFirstValueByName( + commands.DEFAULT_REGISTER_BANK) if primary.value is None: primary = banks[0] - commands.DEFAULT_REGISTER_BANK = primary.name - commands.putreg(frame, primary) - commands.putmem("$pc", "1", result=None) - commands.putmem("$sp", "1", result=None) + if primary is not None: + commands.DEFAULT_REGISTER_BANK = primary.name + if primary is not None: + commands.putreg(frame, primary) + try: + commands.putmem("$pc", "1", result=None) + except BaseException as e: + print(f"Couldn't record page with PC: {e}") + try: + commands.putmem("$sp", "1", result=None) + except BaseException as e: + print(f"Couldn't record page with SP: {e}") self.visited.add(hashable_frame) if first or self.regions or self.threads or self.modules: # Sections, memory syscalls, or stack allocations @@ -113,7 +122,7 @@ class BrkState(object): return self.break_loc_counts.get(b.GetID(), 0) def del_brkloc_count(self, b): - if b not in self.break_loc_counts: + if b.GetID() not in self.break_loc_counts: return 0 # TODO: Print a warning? count = self.break_loc_counts[b.GetID()] del self.break_loc_counts[b.GetID()] @@ -125,19 +134,32 @@ BRK_STATE = BrkState() PROC_STATE = {} +class QuitSentinel(object): + pass + + +QUIT = QuitSentinel() + + def process_event(self, listener, event): try: desc = util.get_description(event) - # print('Event:', desc) + # print(f"Event: {desc}") + target = util.get_target() + if not target.IsValid(): + # LLDB may crash on event.GetBroadcasterClass, otherwise + # All the checks below, e.g. SBTarget.EventIsTargetEvent, call this + print(f"Ignoring {desc} because target is invalid") + return event_process = util.get_process() - if event_process not in PROC_STATE: + if event_process.IsValid() and event_process not in PROC_STATE: PROC_STATE[event_process.GetProcessID()] = ProcessState() rc = event_process.GetBroadcaster().AddListener(listener, ALL_EVENTS) - if rc is False: + if not rc: print("add listener for process failed") # NB: Calling put_state on running leaves an open transaction - if event_process.is_running is False: + if not event_process.is_running: commands.put_state(event_process) type = event.GetType() if lldb.SBTarget.EventIsTargetEvent(event): @@ -157,6 +179,8 @@ def process_event(self, listener, event): return on_exited(event) if event_process.is_stopped: return on_stop(event) + if event_process.is_running: + return on_cont(event) return True if (type & lldb.SBProcess.eBroadcastBitInterrupt) != 0: if event_process.is_stopped: @@ -244,6 +268,9 @@ def process_event(self, listener, event): if (type & lldb.SBCommandInterpreter.eBroadcastBitAsynchronousOutputData) != 0: return True if (type & lldb.SBCommandInterpreter.eBroadcastBitQuitCommandReceived) != 0: + # DO NOT return QUIT here. + # For some reason, this event comes just after launch. + # Maybe need to figure out *which* interpreter? return True if (type & lldb.SBCommandInterpreter.eBroadcastBitResetPrompt) != 0: return True @@ -251,7 +278,7 @@ def process_event(self, listener, event): return True print("UNKNOWN EVENT") return True - except RuntimeError as e: + except BaseException as e: print(e) @@ -267,50 +294,57 @@ class EventThread(threading.Thread): target = util.get_target() proc = util.get_process() rc = cli.GetBroadcaster().AddListener(listener, ALL_EVENTS) - if rc is False: + if not rc: print("add listener for cli failed") - return + # return rc = target.GetBroadcaster().AddListener(listener, ALL_EVENTS) - if rc is False: + if not rc: print("add listener for target failed") - return + # return rc = proc.GetBroadcaster().AddListener(listener, ALL_EVENTS) - if rc is False: + if not rc: print("add listener for process failed") - return + # return # Not sure what effect this logic has rc = cli.GetBroadcaster().AddInitialEventsToListener(listener, ALL_EVENTS) - if rc is False: - print("add listener for cli failed") - return + if not rc: + print("add initial events for cli failed") + # return rc = target.GetBroadcaster().AddInitialEventsToListener(listener, ALL_EVENTS) - if rc is False: - print("add listener for target failed") - return + if not rc: + print("add initial events for target failed") + # return rc = proc.GetBroadcaster().AddInitialEventsToListener(listener, ALL_EVENTS) - if rc is False: - print("add listener for process failed") - return + if not rc: + print("add initial events for process failed") + # return rc = listener.StartListeningForEventClass( util.get_debugger(), lldb.SBThread.GetBroadcasterClassName(), ALL_EVENTS) - if rc is False: + if not rc: print("add listener for threads failed") - return + # return # THIS WILL NOT WORK: listener = util.get_debugger().GetListener() while True: event_recvd = False - while event_recvd is False: + while not event_recvd: if listener.WaitForEvent(lldb.UINT32_MAX, self.event): try: - self.func(listener, self.event) - while listener.GetNextEvent(self.event): - self.func(listener, self.event) - event_recvd = True + result = self.func(listener, self.event) + if result is QUIT: + return except BaseException as e: print(e) + while listener.GetNextEvent(self.event): + try: + result = self.func(listener, self.event) + if result is QUIT: + return + except BaseException as e: + print(e) + event_recvd = True proc = util.get_process() if proc is not None and not proc.is_alive: break @@ -445,7 +479,7 @@ def on_memory_changed(event): def on_register_changed(event): - print("Register changed: {}".format(dir(event))) + # print("Register changed: {}".format(dir(event))) proc = util.get_process() if proc.GetProcessID() not in PROC_STATE: return @@ -476,7 +510,8 @@ def on_cont(event): def on_stop(event): - proc = lldb.SBProcess.GetProcessFromEvent(event) if event is not None else util.get_process() + proc = lldb.SBProcess.GetProcessFromEvent( + event) if event is not None else util.get_process() if proc.GetProcessID() not in PROC_STATE: print("not in state") return @@ -586,7 +621,7 @@ def on_breakpoint_deleted(b): notify_others_breaks(proc) if proc.GetProcessID() not in PROC_STATE: return - old_count = BRK_STATE.del_brkloc_count(b.GetID()) + old_count = BRK_STATE.del_brkloc_count(b) trace = commands.STATE.trace if trace is None: return diff --git a/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/methods.py b/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/methods.py index 14db747329..669f0f062a 100644 --- a/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/methods.py +++ b/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/methods.py @@ -15,9 +15,11 @@ ## from concurrent.futures import Future, ThreadPoolExecutor import re +import sys from ghidratrace import sch from ghidratrace.client import MethodRegistry, ParamDesc, Address, AddressRange + import lldb from . import commands, util @@ -228,107 +230,122 @@ def find_bpt_loc_by_obj(object): return bpt.locations[locnum - 1] # Display is 1-up +def exec_convert_errors(cmd, to_string=False): + res = lldb.SBCommandReturnObject() + util.get_debugger().GetCommandInterpreter().HandleCommand(cmd, res) + if not res.Succeeded(): + if not to_string: + print(res.GetError(), file=sys.stderr) + raise RuntimeError(res.GetError()) + if to_string: + return res.GetOutput() + print(res.GetOutput(), end="") + + @REGISTRY.method def execute(cmd: str, to_string: bool=False): """Execute a CLI command.""" - res = lldb.SBCommandReturnObject() - util.get_debugger().GetCommandInterpreter().HandleCommand(cmd, res) - if to_string: - if res.Succeeded(): - return res.GetOutput() - else: - return res.GetError() + # TODO: Check for eCommandInterpreterResultQuitRequested? + return exec_convert_errors(cmd, to_string) -@REGISTRY.method(action='refresh') +@REGISTRY.method +def evaluate(expr: str): + """Evaluate an expression.""" + value = util.get_target().EvaluateExpression(expr) + if value.GetError().Fail(): + raise RuntimeError(value.GetError().GetCString()) + return commands.convert_value(value) + + +@REGISTRY.method +def pyeval(expr: str): + return eval(expr) + + +@REGISTRY.method(action='refresh', display="Refresh Available") def refresh_available(node: sch.Schema('AvailableContainer')): """List processes on lldb's host system.""" with commands.open_tracked_tx('Refresh Available'): - util.get_debugger().HandleCommand('ghidra trace put-available') + exec_convert_errors('ghidra trace put-available') -@REGISTRY.method(action='refresh') +@REGISTRY.method(action='refresh', display="Refresh Breakpoints") def refresh_breakpoints(node: sch.Schema('BreakpointContainer')): """ Refresh the list of breakpoints (including locations for the current process). """ with commands.open_tracked_tx('Refresh Breakpoints'): - util.get_debugger().HandleCommand('ghidra trace put-breakpoints') + exec_convert_errors('ghidra trace put-breakpoints') -@REGISTRY.method(action='refresh') +@REGISTRY.method(action='refresh', display="Refresh Processes") def refresh_processes(node: sch.Schema('ProcessContainer')): """Refresh the list of processes.""" with commands.open_tracked_tx('Refresh Processes'): - util.get_debugger().HandleCommand('ghidra trace put-threads') + exec_convert_errors('ghidra trace put-threads') -@REGISTRY.method(action='refresh') +@REGISTRY.method(action='refresh', display="Refresh Breakpoints") def refresh_proc_breakpoints(node: sch.Schema('BreakpointLocationContainer')): """ - Refresh the breakpoint locations for the process. - - In the course of refreshing the locations, the breakpoint list will also be - refreshed. + Refresh the breakpoints for the process. """ with commands.open_tracked_tx('Refresh Breakpoint Locations'): - util.get_debugger().HandleCommand('ghidra trace put-breakpoints') + exec_convert_errors('ghidra trace put-breakpoints') -@REGISTRY.method(action='refresh') +@REGISTRY.method(action='refresh', display="Refresh Watchpoints") def refresh_proc_watchpoints(node: sch.Schema('WatchpointContainer')): """ - Refresh the watchpoint locations for the process. - - In the course of refreshing the locations, the watchpoint list will also be - refreshed. + Refresh the watchpoints for the process. """ with commands.open_tracked_tx('Refresh Watchpoint Locations'): - util.get_debugger().HandleCommand('ghidra trace put-watchpoints') + exec_convert_errors('ghidra trace put-watchpoints') -@REGISTRY.method(action='refresh') +@REGISTRY.method(action='refresh', display="Refresh Environment") def refresh_environment(node: sch.Schema('Environment')): """Refresh the environment descriptors (arch, os, endian).""" with commands.open_tracked_tx('Refresh Environment'): - util.get_debugger().HandleCommand('ghidra trace put-environment') + exec_convert_errors('ghidra trace put-environment') -@REGISTRY.method(action='refresh') +@REGISTRY.method(action='refresh', display="Refresh Threads") def refresh_threads(node: sch.Schema('ThreadContainer')): """Refresh the list of threads in the process.""" with commands.open_tracked_tx('Refresh Threads'): - util.get_debugger().HandleCommand('ghidra trace put-threads') + exec_convert_errors('ghidra trace put-threads') -@REGISTRY.method(action='refresh') +@REGISTRY.method(action='refresh', display="Refresh Stack") def refresh_stack(node: sch.Schema('Stack')): """Refresh the backtrace for the thread.""" t = find_thread_by_stack_obj(node) t.process.SetSelectedThread(t) with commands.open_tracked_tx('Refresh Stack'): - util.get_debugger().HandleCommand('ghidra trace put-frames') + exec_convert_errors('ghidra trace put-frames') -@REGISTRY.method(action='refresh') +@REGISTRY.method(action='refresh', display="Refresh Registers") def refresh_registers(node: sch.Schema('RegisterValueContainer')): """Refresh the register values for the frame.""" f = find_frame_by_regs_obj(node) f.thread.SetSelectedFrame(f.GetFrameID()) # TODO: Groups? with commands.open_tracked_tx('Refresh Registers'): - util.get_debugger().HandleCommand('ghidra trace putreg') + exec_convert_errors('ghidra trace putreg') -@REGISTRY.method(action='refresh') +@REGISTRY.method(action='refresh', display="Refresh Memory") def refresh_mappings(node: sch.Schema('Memory')): """Refresh the list of memory regions for the process.""" with commands.open_tracked_tx('Refresh Memory Regions'): - util.get_debugger().HandleCommand('ghidra trace put-regions') + exec_convert_errors('ghidra trace put-regions') -@REGISTRY.method(action='refresh') +@REGISTRY.method(action='refresh', display="Refresh Modules") def refresh_modules(node: sch.Schema('ModuleContainer')): """ Refresh the modules and sections list for the process. @@ -336,12 +353,13 @@ def refresh_modules(node: sch.Schema('ModuleContainer')): This will refresh the sections for all modules, not just the selected one. """ with commands.open_tracked_tx('Refresh Modules'): - util.get_debugger().HandleCommand('ghidra trace put-modules') + exec_convert_errors('ghidra trace put-modules') @REGISTRY.method(action='activate') def activate_process(process: sch.Schema('Process')): """Switch to the process.""" + # TODO return @@ -363,41 +381,48 @@ def activate_frame(frame: sch.Schema('StackFrame')): def remove_process(process: sch.Schema('Process')): """Remove the process.""" proc = find_proc_by_obj(process) - util.get_debugger().HandleCommand(f'target delete 0') + exec_convert_errors(f'target delete 0') -@REGISTRY.method(action='connect') +@REGISTRY.method(action='connect', display="Connect Target") def target(process: sch.Schema('Process'), spec: str): """Connect to a target machine or process.""" - util.get_debugger().HandleCommand(f'target select {spec}') + exec_convert_errors(f'target select {spec}') -@REGISTRY.method(action='attach') +@REGISTRY.method(action='attach', display="Attach by Attachable") def attach_obj(process: sch.Schema('Process'), target: sch.Schema('Attachable')): """Attach the process to the given target.""" pid = find_availpid_by_obj(target) - util.get_debugger().HandleCommand(f'process attach -p {pid}') + exec_convert_errors(f'process attach -p {pid}') -@REGISTRY.method(action='attach') +@REGISTRY.method(action='attach', display="Attach by PID") def attach_pid(process: sch.Schema('Process'), pid: int): """Attach the process to the given target.""" - util.get_debugger().HandleCommand(f'process attach -p {pid}') + exec_convert_errors(f'process attach -p {pid}') -@REGISTRY.method(action='attach') +@REGISTRY.method(action='attach', display="Attach by Name") def attach_name(process: sch.Schema('Process'), name: str): """Attach the process to the given target.""" - util.get_debugger().HandleCommand(f'process attach -n {name}') + exec_convert_errors(f'process attach -n {name}') -@REGISTRY.method +@REGISTRY.method(display="Detach") def detach(process: sch.Schema('Process')): """Detach the process's target.""" - util.get_debugger().HandleCommand(f'process detach') + exec_convert_errors(f'process detach') -@REGISTRY.method(action='launch') +def do_launch(process, file, args, cmd): + exec_convert_errors(f'file {file}') + if args != '': + exec_convert_errors(f'settings set target.run-args {args}') + exec_convert_errors(cmd) + + +@REGISTRY.method(action='launch', display="Launch at Entry") def launch_loader(process: sch.Schema('Process'), file: ParamDesc(str, display='File'), args: ParamDesc(str, display='Arguments')=''): @@ -406,14 +431,10 @@ def launch_loader(process: sch.Schema('Process'), If 'main' is not defined in the file, this behaves like 'run'. """ - util.get_debugger().HandleCommand(f'file {file}') - if args != '': - util.get_debugger().HandleCommand( - f'settings set target.run-args {args}') - util.get_debugger().HandleCommand(f'process launch --stop-at-entry') + do_launch(process, file, args, 'process launch --stop-at-entry') -@REGISTRY.method(action='launch') +@REGISTRY.method(action='launch', display="Launch and Run") def launch(process: sch.Schema('Process'), file: ParamDesc(str, display='File'), args: ParamDesc(str, display='Arguments')=''): @@ -423,31 +444,27 @@ def launch(process: sch.Schema('Process'), The process will not stop until it hits one of your breakpoints, or it is signaled. """ - util.get_debugger().HandleCommand(f'file {file}') - if args != '': - util.get_debugger().HandleCommand( - f'settings set target.run-args {args}') - util.get_debugger().HandleCommand(f'run') + do_launch(process, file, args, 'run') @REGISTRY.method def kill(process: sch.Schema('Process')): """Kill execution of the process.""" - util.get_debugger().HandleCommand('process kill') + exec_convert_errors('process kill') @REGISTRY.method(name='continue', action='resume') def _continue(process: sch.Schema('Process')): """Continue execution of the process.""" - util.get_debugger().HandleCommand('process continue') + exec_convert_errors('process continue') @REGISTRY.method def interrupt(): """Interrupt the execution of the debugged program.""" - util.get_debugger().HandleCommand('process interrupt') + exec_convert_errors('process interrupt') # util.get_process().SendAsyncInterrupt() - # util.get_debugger().HandleCommand('^c') + # exec_convert_errors('^c') # util.get_process().Signal(2) @@ -456,7 +473,7 @@ def step_into(thread: sch.Schema('Thread'), n: ParamDesc(int, display='N')=1): """Step on instruction exactly.""" t = find_thread_by_obj(thread) t.process.SetSelectedThread(t) - util.get_debugger().HandleCommand('thread step-inst') + exec_convert_errors('thread step-inst') @REGISTRY.method(action='step_over') @@ -464,7 +481,7 @@ def step_over(thread: sch.Schema('Thread'), n: ParamDesc(int, display='N')=1): """Step one instruction, but proceed through subroutine calls.""" t = find_thread_by_obj(thread) t.process.SetSelectedThread(t) - util.get_debugger().HandleCommand('thread step-inst-over') + exec_convert_errors('thread step-inst-over') @REGISTRY.method(action='step_out') @@ -473,27 +490,27 @@ def step_out(thread: sch.Schema('Thread')): if thread is not None: t = find_thread_by_obj(thread) t.process.SetSelectedThread(t) - util.get_debugger().HandleCommand('thread step-out') + exec_convert_errors('thread step-out') -@REGISTRY.method(action='step_ext') -def step_ext(thread: sch.Schema('Thread'), address: Address): +@REGISTRY.method(action='step_ext', display="Advance") +def step_advance(thread: sch.Schema('Thread'), address: Address): """Continue execution up to the given address.""" t = find_thread_by_obj(thread) t.process.SetSelectedThread(t) offset = thread.trace.memory_mapper.map_back(t.process, address) - util.get_debugger().HandleCommand(f'thread until -a {offset}') + exec_convert_errors(f'thread until -a {offset}') -@REGISTRY.method(name='return', action='step_ext') -def _return(thread: sch.Schema('Thread'), value: int=None): +@REGISTRY.method(action='step_ext', display="Return") +def step_return(thread: sch.Schema('Thread'), value: int=None): """Skip the remainder of the current function.""" t = find_thread_by_obj(thread) t.process.SetSelectedThread(t) if value is None: - util.get_debugger().HandleCommand('thread return') + exec_convert_errors('thread return') else: - util.get_debugger().HandleCommand(f'thread return {value}') + exec_convert_errors(f'thread return {value}') @REGISTRY.method(action='break_sw_execute') @@ -501,14 +518,14 @@ def break_address(process: sch.Schema('Process'), address: Address): """Set a breakpoint.""" proc = find_proc_by_obj(process) offset = process.trace.memory_mapper.map_back(proc, address) - util.get_debugger().HandleCommand(f'breakpoint set -a 0x{offset:x}') + exec_convert_errors(f'breakpoint set -a 0x{offset:x}') @REGISTRY.method(action='break_sw_execute') def break_expression(expression: str): """Set a breakpoint.""" # TODO: Escape? - util.get_debugger().HandleCommand(f'breakpoint set -r {expression}') + exec_convert_errors(f'breakpoint set -r {expression}') @REGISTRY.method(action='break_hw_execute') @@ -516,14 +533,14 @@ def break_hw_address(process: sch.Schema('Process'), address: Address): """Set a hardware-assisted breakpoint.""" proc = find_proc_by_obj(process) offset = process.trace.memory_mapper.map_back(proc, address) - util.get_debugger().HandleCommand(f'breakpoint set -H -a 0x{offset:x}') + exec_convert_errors(f'breakpoint set -H -a 0x{offset:x}') @REGISTRY.method(action='break_hw_execute') def break_hw_expression(expression: str): """Set a hardware-assisted breakpoint.""" # TODO: Escape? - util.get_debugger().HandleCommand(f'breakpoint set -H -name {expression}') + exec_convert_errors(f'breakpoint set -H -name {expression}') @REGISTRY.method(action='break_read') @@ -533,15 +550,16 @@ def break_read_range(process: sch.Schema('Process'), range: AddressRange): offset_start = process.trace.memory_mapper.map_back( proc, Address(range.space, range.min)) sz = range.length() - util.get_debugger().HandleCommand( + exec_convert_errors( f'watchpoint set expression -s {sz} -w read -- {offset_start}') @REGISTRY.method(action='break_read') -def break_read_expression(expression: str): +def break_read_expression(expression: str, size=None): """Set a read watchpoint.""" - util.get_debugger().HandleCommand( - f'watchpoint set expression -w read -- {expression}') + size_part = '' if size is None else f'-s {size}' + exec_convert_errors( + f'watchpoint set expression {size_part} -w read -- {expression}') @REGISTRY.method(action='break_write') @@ -551,15 +569,16 @@ def break_write_range(process: sch.Schema('Process'), range: AddressRange): offset_start = process.trace.memory_mapper.map_back( proc, Address(range.space, range.min)) sz = range.length() - util.get_debugger().HandleCommand( + exec_convert_errors( f'watchpoint set expression -s {sz} -- {offset_start}') @REGISTRY.method(action='break_write') -def break_write_expression(expression: str): +def break_write_expression(expression: str, size=None): """Set a watchpoint.""" - util.get_debugger().HandleCommand( - f'watchpoint set expression -- {expression}') + size_part = '' if size is None else f'-s {size}' + exec_convert_errors( + f'watchpoint set expression {size_part} -- {expression}') @REGISTRY.method(action='break_access') @@ -569,21 +588,22 @@ def break_access_range(process: sch.Schema('Process'), range: AddressRange): offset_start = process.trace.memory_mapper.map_back( proc, Address(range.space, range.min)) sz = range.length() - util.get_debugger().HandleCommand( + exec_convert_errors( f'watchpoint set expression -s {sz} -w read_write -- {offset_start}') @REGISTRY.method(action='break_access') -def break_access_expression(expression: str): +def break_access_expression(expression: str, size=None): """Set an access watchpoint.""" - util.get_debugger().HandleCommand( - f'watchpoint set expression -w read_write -- {expression}') + size_part = '' if size is None else f'-s {size}' + exec_convert_errors( + f'watchpoint set expression {size_part} -w read_write -- {expression}') -@REGISTRY.method(action='break_ext') +@REGISTRY.method(action='break_ext', display="Break on Exception") def break_exception(lang: str): """Set a catchpoint.""" - util.get_debugger().HandleCommand(f'breakpoint set -E {lang}') + exec_convert_errors(f'breakpoint set -E {lang}') @REGISTRY.method(action='toggle') @@ -605,7 +625,7 @@ def toggle_breakpoint_location(location: sch.Schema('BreakpointLocation'), enabl """Toggle a breakpoint location.""" bptnum, locnum = find_bptlocnum_by_obj(location) cmd = 'enable' if enabled else 'disable' - util.get_debugger().HandleCommand(f'breakpoint {cmd} {bptnum}.{locnum}') + exec_convert_errors(f'breakpoint {cmd} {bptnum}.{locnum}') @REGISTRY.method(action='delete') @@ -613,7 +633,7 @@ def delete_watchpoint(watchpoint: sch.Schema('WatchpointSpec')): """Delete a watchpoint.""" wpt = find_wpt_by_obj(watchpoint) wptnum = wpt.GetID() - util.get_debugger().HandleCommand(f'watchpoint delete {wptnum}') + exec_convert_errors(f'watchpoint delete {wptnum}') @REGISTRY.method(action='delete') @@ -621,7 +641,7 @@ def delete_breakpoint(breakpoint: sch.Schema('BreakpointSpec')): """Delete a breakpoint.""" bpt = find_bpt_by_obj(breakpoint) bptnum = bpt.GetID() - util.get_debugger().HandleCommand(f'breakpoint delete {bptnum}') + exec_convert_errors(f'breakpoint delete {bptnum}') @REGISTRY.method @@ -638,7 +658,7 @@ def read_mem(process: sch.Schema('Process'), range: AddressRange): if result.Succeeded(): return print(f"Could not read 0x{offset_start:x}: {result}") - util.get_debugger().HandleCommand( + exec_convert_errors( f'ghidra trace putmem-state 0x{offset_start:x} {range.length()} error') @@ -660,5 +680,5 @@ def write_reg(frame: sch.Schema('StackFrame'), name: str, value: bytes): reg = find_reg_by_name(f, mname) size = int(lldb.parse_and_eval(f'sizeof(${mname})')) arr = '{' + ','.join(str(b) for b in mval) + '}' - util.get_debugger().HandleCommand( + exec_convert_errors( f'expr ((unsigned char[{size}])${mname}) = {arr};') diff --git a/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/schema.xml b/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/schema.xml index f6b8385720..dcde261e78 100644 --- a/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/schema.xml +++ b/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/schema.xml @@ -54,7 +54,6 @@ - diff --git a/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/util.py b/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/util.py index a5478caf0b..d2ac593dd4 100644 --- a/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/util.py +++ b/Ghidra/Debug/Debugger-agent-lldb/src/main/py/src/ghidralldb/util.py @@ -21,7 +21,7 @@ import sys import lldb -LldbVersion = namedtuple('LldbVersion', ['full', 'major', 'minor']) +LldbVersion = namedtuple('LldbVersion', ['display', 'full', 'major', 'minor']) def _compute_lldb_ver(): @@ -32,7 +32,7 @@ def _compute_lldb_ver(): else: full = top.split('-')[1] # "lldb-x.y.z" major, minor = full.split('.')[:2] - return LldbVersion(full, int(major), int(minor)) + return LldbVersion(top, full, int(major), int(minor)) LLDB_VERSION = _compute_lldb_ver() @@ -150,8 +150,11 @@ class RegionInfoReader(object): def full_mem(self): # TODO: This may not work for Harvard architectures - sizeptr = int(parse_and_eval('sizeof(void*)')) * 8 - return Region(0, 1 << sizeptr, 0, None, 'full memory') + try: + sizeptr = int(parse_and_eval('sizeof(void*)')) * 8 + return Region(0, 1 << sizeptr, 0, None, 'full memory') + except ValueError: + return Region(0, 1 << 64, 0, None, 'full memory') def _choose_region_info_reader(): diff --git a/Ghidra/Debug/Debugger-agent-lldb/src/test/java/agent/lldb/model/MacOSSpecimen.java b/Ghidra/Debug/Debugger-agent-lldb/src/test/java/agent/lldb/model/MacOSSpecimen.java index 2b7fa43ee1..085bc1b25b 100644 --- a/Ghidra/Debug/Debugger-agent-lldb/src/test/java/agent/lldb/model/MacOSSpecimen.java +++ b/Ghidra/Debug/Debugger-agent-lldb/src/test/java/agent/lldb/model/MacOSSpecimen.java @@ -35,6 +35,12 @@ public enum MacOSSpecimen implements DebuggerTestSpecimen, DebuggerModelTestUtil return DummyProc.which("expSpin"); } }, + READ { + @Override + public String getCommandLine() { + return DummyProc.which("expRead"); + } + }, FORK_EXIT { @Override public String getCommandLine() { diff --git a/Ghidra/Debug/Debugger-rmi-trace/ghidra_scripts/ListenTraceRmiScript.java b/Ghidra/Debug/Debugger-rmi-trace/ghidra_scripts/ListenTraceRmiScript.java index 43cf4e43ac..940dd5af94 100644 --- a/Ghidra/Debug/Debugger-rmi-trace/ghidra_scripts/ListenTraceRmiScript.java +++ b/Ghidra/Debug/Debugger-rmi-trace/ghidra_scripts/ListenTraceRmiScript.java @@ -19,8 +19,7 @@ import java.util.Objects; import ghidra.app.plugin.core.debug.service.tracermi.TraceRmiPlugin; import ghidra.app.script.GhidraScript; import ghidra.app.services.TraceRmiService; -import ghidra.debug.api.tracermi.TraceRmiAcceptor; -import ghidra.debug.api.tracermi.TraceRmiConnection; +import ghidra.debug.api.tracermi.*; public class ListenTraceRmiScript extends GhidraScript { @@ -42,8 +41,18 @@ public class ListenTraceRmiScript extends GhidraScript { TraceRmiConnection connection = acceptor.accept(); println("Connection from " + connection.getRemoteAddress()); - while (askYesNo("Execute?", "Execute 'echo test'?")) { - connection.getMethods().get("execute").invoke(Map.of("cmd", "echo test")); + RemoteMethod execute = connection.getMethods().get("execute"); + if (execute == null) { + printerr("No execute method!"); + } + while (true) { + String cmd = askString("Execute", "command?"); + try { + execute.invoke(Map.of("cmd", cmd)); + } + catch (TraceRmiError e) { + printerr(e.getMessage()); + } } } } diff --git a/Ghidra/Debug/Debugger-rmi-trace/src/main/py/src/ghidratrace/client.py b/Ghidra/Debug/Debugger-rmi-trace/src/main/py/src/ghidratrace/client.py index 0c9dda8d7b..86ae60c422 100644 --- a/Ghidra/Debug/Debugger-rmi-trace/src/main/py/src/ghidratrace/client.py +++ b/Ghidra/Debug/Debugger-rmi-trace/src/main/py/src/ghidratrace/client.py @@ -92,7 +92,11 @@ class Receiver(Thread): dbg_seq = 0 while not self._is_shutdown: #print("Receiving message") - reply = recv_delimited(self.client.s, bufs.RootMessage(), dbg_seq) + try: + reply = recv_delimited(self.client.s, bufs.RootMessage(), dbg_seq) + except BaseException as e: + self._is_shutdown = True + return #print(f"Got one: {reply.WhichOneof('msg')}") dbg_seq += 1 try: @@ -333,6 +337,14 @@ class Trace(object): return self.client._delete_bytes(self.id, snap, range) def put_registers(self, space, values, snap=None): + """ + TODO + + values is a dictionary, where each key is a a register name, and the + value is a byte array. No matter the target architecture, the value is + given in big-endian byte order. + """ + if snap is None: snap = self.snap() return self.client._put_registers(self.id, snap, space, values) diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/modules/DebuggerModulesPanel.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/modules/DebuggerModulesPanel.java index 3e1f671cc9..41680e5cc6 100644 --- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/modules/DebuggerModulesPanel.java +++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/modules/DebuggerModulesPanel.java @@ -160,6 +160,9 @@ public class DebuggerModulesPanel extends AbstractObjectsTableBasedPanel result = new HashSet<>(); for (TraceObjectValue value : ctx.getObjectValues()) { + if (!value.isObject()) { + continue; + } TraceObject child = value.getChild(); TraceObjectModule module = child.queryInterface(TraceObjectModule.class); if (module != null) { @@ -179,6 +182,9 @@ public class DebuggerModulesPanel extends AbstractObjectsTableBasedPanel result = new HashSet<>(); for (TraceObjectValue value : ctx.getObjectValues()) { + if (!value.isObject()) { + continue; + } TraceObject child = value.getChild(); TraceObjectModule module = child.queryInterface(TraceObjectModule.class); if (module != null) { diff --git a/Ghidra/Debug/Framework-Debugging/build.gradle b/Ghidra/Debug/Framework-Debugging/build.gradle index 327154b076..53609125ea 100644 --- a/Ghidra/Debug/Framework-Debugging/build.gradle +++ b/Ghidra/Debug/Framework-Debugging/build.gradle @@ -49,10 +49,11 @@ task testSpecimenWin_x86_64 { task testSpecimenLinux_x86_64 { dependsOn 'expCloneExecExecutable'//Linux_x86_64Executable' - dependsOn 'expCloneExitExecutable'//Linux_x86_64Executable' + dependsOn 'expCloneExitLinux_x86_64Executable' //dependsOn 'expCloneSpinExecutable'//Linux_x86_64Executable' dependsOn 'expForkExecutable'//Linux_x86_64Executable' dependsOn 'expPrintLinux_x86_64Executable' + dependsOn 'expReadLinux_x86_64Executable' dependsOn 'expSpinLinux_x86_64Executable' //dependsOn 'expTypesExecutable'//Linux_x86_64Executable' dependsOn 'expRegistersLinux_x86_64Executable' @@ -67,6 +68,12 @@ task testSpecimenLinux_x86_64 { } } +task testSpecimenMac_arm_64 { + dependsOn 'expCloneExitMac_arm_64Executable' + dependsOn 'expPrintMac_arm_64Executable' + dependsOn 'expReadMac_arm_64Executable' +} + // TODO: testSpecimenMac_x86_64 (Intel) // will likely need to codesign them to grant debugee-entitlement @@ -91,6 +98,7 @@ model { expCloneExit(NativeExecutableSpec) { targetPlatform "linux_x86_64" //targetPlatform "linux_x86_32" // TODO: Test on these + targetPlatform "mac_arm_64" } expCloneSpin(NativeExecutableSpec) { targetPlatform "linux_x86_64" @@ -105,6 +113,11 @@ model { //targetPlatform "linux_x86_32" // TODO: Test on these targetPlatform "win_x86_64" targetPlatform "win_x86_32" // TODO: Test on these + targetPlatform "mac_arm_64" + } + expRead(NativeExecutableSpec) { + targetPlatform "linux_x86_64" + targetPlatform "mac_arm_64" } expSpin(NativeExecutableSpec) { targetPlatform "linux_x86_64" diff --git a/Ghidra/Debug/Framework-Debugging/src/expCloneExit/c/expCloneExit.c b/Ghidra/Debug/Framework-Debugging/src/expCloneExit/c/expCloneExit.c index 8c62b27337..ef0a5ca89c 100644 --- a/Ghidra/Debug/Framework-Debugging/src/expCloneExit/c/expCloneExit.c +++ b/Ghidra/Debug/Framework-Debugging/src/expCloneExit/c/expCloneExit.c @@ -15,6 +15,7 @@ */ #include #include +#include pthread_t thread; diff --git a/Ghidra/Debug/Framework-Debugging/src/expPrint/c/expPrint.c b/Ghidra/Debug/Framework-Debugging/src/expPrint/c/expPrint.c index 4e40f3e54d..0fee38812d 100644 --- a/Ghidra/Debug/Framework-Debugging/src/expPrint/c/expPrint.c +++ b/Ghidra/Debug/Framework-Debugging/src/expPrint/c/expPrint.c @@ -21,7 +21,7 @@ #define DLLEXPORT __declspec(dllexport) #else #define DLLEXPORT -#define OutputDebugString(out) printf("%s\n", out) +#define OutputDebugString(out) puts(out) #endif DLLEXPORT volatile char overwrite[] = "Hello, World!"; diff --git a/Ghidra/Debug/Framework-Debugging/src/expRead/c/expRead.c b/Ghidra/Debug/Framework-Debugging/src/expRead/c/expRead.c new file mode 100644 index 0000000000..1f2527144c --- /dev/null +++ b/Ghidra/Debug/Framework-Debugging/src/expRead/c/expRead.c @@ -0,0 +1,21 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +#include + +int main(int argc, char** argv) { + char c; + read(0, &c, sizeof(c)); +} diff --git a/Ghidra/Framework/Pty/src/test/java/ghidra/pty/StreamPumper.java b/Ghidra/Framework/Pty/src/test/java/ghidra/pty/StreamPumper.java new file mode 100644 index 0000000000..662ca0581f --- /dev/null +++ b/Ghidra/Framework/Pty/src/test/java/ghidra/pty/StreamPumper.java @@ -0,0 +1,45 @@ +/* ### + * IP: GHIDRA + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package ghidra.pty; + +import java.io.*; + +public class StreamPumper extends Thread { + private final InputStream in; + private final OutputStream out; + + public StreamPumper(InputStream in, OutputStream out) { + setDaemon(true); + this.in = in; + this.out = out; + } + + @Override + public void run() { + byte[] buf = new byte[1024]; + try { + while (true) { + int len = in.read(buf); + if (len <= 0) { + break; + } + out.write(buf, 0, len); + } + } + catch (IOException e) { + } + } +} diff --git a/Ghidra/Framework/Pty/src/test/java/ghidra/pty/ssh/SshPtyTest.java b/Ghidra/Framework/Pty/src/test/java/ghidra/pty/ssh/SshPtyTest.java index 6a6c9e2a22..c62094ea0e 100644 --- a/Ghidra/Framework/Pty/src/test/java/ghidra/pty/ssh/SshPtyTest.java +++ b/Ghidra/Framework/Pty/src/test/java/ghidra/pty/ssh/SshPtyTest.java @@ -24,9 +24,8 @@ import org.junit.Before; import org.junit.Test; import ghidra.app.script.AskDialog; -import ghidra.pty.Pty; +import ghidra.pty.*; import ghidra.pty.PtyChild.Echo; -import ghidra.pty.PtySession; import ghidra.test.AbstractGhidraHeadedIntegrationTest; import ghidra.util.SystemUtilities; import ghidra.util.exception.CancelledException; @@ -49,33 +48,6 @@ public class SshPtyTest extends AbstractGhidraHeadedIntegrationTest { return dialog.getValueAsString(); } - public static class StreamPumper extends Thread { - private final InputStream in; - private final OutputStream out; - - public StreamPumper(InputStream in, OutputStream out) { - setDaemon(true); - this.in = in; - this.out = out; - } - - @Override - public void run() { - byte[] buf = new byte[1024]; - try { - while (true) { - int len = in.read(buf); - if (len <= 0) { - break; - } - out.write(buf, 0, len); - } - } - catch (IOException e) { - } - } - } - @Test public void testSessionBash() throws IOException, InterruptedException { try (Pty pty = factory.openpty()) { diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/AbstractLldbTraceRmiTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/AbstractLldbTraceRmiTest.java index 20dbb249d1..926248844f 100644 --- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/AbstractLldbTraceRmiTest.java +++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/AbstractLldbTraceRmiTest.java @@ -20,7 +20,8 @@ import static org.junit.Assert.*; import java.io.*; import java.net.*; -import java.nio.file.*; +import java.nio.file.Path; +import java.nio.file.Paths; import java.util.*; import java.util.concurrent.*; import java.util.function.Function; @@ -28,8 +29,11 @@ import java.util.regex.Matcher; import java.util.regex.Pattern; import java.util.stream.Collectors; +import org.apache.commons.io.output.TeeOutputStream; import org.apache.commons.lang3.exception.ExceptionUtils; +import org.hamcrest.Matchers; import org.junit.Before; +import org.junit.BeforeClass; import ghidra.app.plugin.core.debug.gui.AbstractGhidraHeadedDebuggerTest; import ghidra.app.plugin.core.debug.service.tracermi.TraceRmiPlugin; @@ -45,6 +49,7 @@ import ghidra.framework.plugintool.PluginsConfiguration; import ghidra.framework.plugintool.util.*; import ghidra.program.model.address.Address; import ghidra.program.model.address.AddressRangeImpl; +import ghidra.pty.*; import ghidra.trace.model.Lifespan; import ghidra.trace.model.breakpoint.TraceBreakpointKind; import ghidra.trace.model.breakpoint.TraceBreakpointKind.TraceBreakpointKindSet; @@ -54,56 +59,70 @@ import ghidra.util.Msg; import ghidra.util.NumericUtilities; public abstract class AbstractLldbTraceRmiTest extends AbstractGhidraHeadedDebuggerTest { + + record PlatDep(String name, String endian, String lang, String cSpec, String callMne, + String intReg, String floatReg) { + static final PlatDep ARM64 = + new PlatDep("arm64", "little", "AARCH64:LE:64:v8A", "default", "bl", "x0", "s0"); + static final PlatDep X8664 = // Note AT&T callq + new PlatDep("x86_64", "little", "x86:LE:64:default", "gcc", "callq", "rax", "st0"); + } + + public static final PlatDep PLAT = computePlat(); + + static PlatDep computePlat() { + return switch (System.getProperty("os.arch")) { + case "aarch64" -> PlatDep.ARM64; + case "x86" -> PlatDep.X8664; + case "amd64" -> PlatDep.X8664; + default -> throw new AssertionError( + "Unrecognized arch: " + System.getProperty("os.arch")); + }; + } + + static String getSpecimenClone() { + return DummyProc.which("expCloneExit"); + } + + static String getSpecimenPrint() { + return DummyProc.which("expPrint"); + } + + static String getSpecimenRead() { + return DummyProc.which("expRead"); + } + /** * Some features have to be disabled to avoid permissions issues in the test container. Namely, * don't try to disable ASLR. + * + * Color codes mess up the address parsing. */ public static final String PREAMBLE = """ script import ghidralldb + settings set use-color false settings set target.disable-aslr false """; // Connecting should be the first thing the script does, so use a tight timeout. protected static final int CONNECT_TIMEOUT_MS = 3000; protected static final int TIMEOUT_SECONDS = 300; protected static final int QUIT_TIMEOUT_MS = 1000; - public static final String INSTRUMENT_STOPPED = - """ - ghidra_trace_txopen "Fake" 'ghidra_trace_create_obj Processes[1]' - define do-set-stopped - ghidra_trace_set_value Processes[1] _state '"STOPPED"' - end - define set-stopped - ghidra_trace_txopen Stopped do-set-stopped - end - #lldb.debugger.HandleCommand('target stop-hook add -P ghidralldb.hooks.StopHook') - #python lldb.events.stop.connect(lambda e: lldb.execute("set-stopped"))"""; - public static final String INSTRUMENT_RUNNING = - """ - ghidra_trace_txopen "Fake" 'ghidra_trace_create_obj Processes[1]' - define do-set-running - ghidra_trace_set_value Processes[1] _state '"RUNNING"' - end - define set-running - ghidra_trace_txopen Running do-set-running - end - #lldb.debugger.HandleCommand('target stop-hook add -P ghidralldb.hooks.StopHook') - #python lldb.events.cont.connect(lambda e: lldb.execute("set-running"))"""; protected TraceRmiService traceRmi; private Path lldbPath; - private Path outFile; - private Path errFile; // @BeforeClass public static void setupPython() throws Throwable { - new ProcessBuilder("gradle", "Debugger-agent-lldb:assemblePyPackage") - .directory(TestApplicationUtils.getInstallationDirectory()) - .inheritIO() - .start() - .waitFor(); + new ProcessBuilder("gradle", + "Debugger-rmi-trace:assemblePyPackage", + "Debugger-agent-lldb:assemblePyPackage") + .directory(TestApplicationUtils.getInstallationDirectory()) + .inheritIO() + .start() + .waitFor(); } - protected void setPythonPath(ProcessBuilder pb) throws IOException { + protected void setPythonPath(Map env) throws IOException { String sep = OperatingSystem.CURRENT_OPERATING_SYSTEM == OperatingSystem.WINDOWS ? ";" : ":"; String rmiPyPkg = Application.getModuleSubDirectory("Debugger-rmi-trace", @@ -111,7 +130,7 @@ public abstract class AbstractLldbTraceRmiTest extends AbstractGhidraHeadedDebug String gdbPyPkg = Application.getModuleSubDirectory("Debugger-agent-lldb", "build/pypkg/src").getAbsolutePath(); String add = rmiPyPkg + sep + gdbPyPkg; - pb.environment().compute("PYTHONPATH", (k, v) -> v == null ? add : (v + sep + add)); + env.compute("PYTHONPATH", (k, v) -> v == null ? add : (v + sep + add)); } @Before @@ -124,8 +143,6 @@ public abstract class AbstractLldbTraceRmiTest extends AbstractGhidraHeadedDebug catch (RuntimeException e) { lldbPath = Paths.get(DummyProc.which("lldb")); } - outFile = Files.createTempFile("lldbout", null); - errFile = Files.createTempFile("lldberr", null); } protected void addAllDebuggerPlugins() throws PluginException { @@ -156,71 +173,70 @@ public abstract class AbstractLldbTraceRmiTest extends AbstractGhidraHeadedDebug throw new AssertionError("Unhandled address type " + address); } - protected record LldbResult(boolean timedOut, int exitCode, String stdout, String stderr) { + protected record LldbResult(boolean timedOut, int exitCode, String out) { protected String handle() { - if (!"".equals(stderr) || (0 != exitCode && 143 != exitCode)) { - throw new LldbError(exitCode, stdout, stderr); + if (0 != exitCode && 143 != exitCode) { + throw new LldbError(exitCode, out); } - return stdout; + return out; } } - protected record ExecInLldb(Process lldb, CompletableFuture future) { - } + protected record ExecInLldb(Pty pty, PtySession lldb, CompletableFuture future, + Thread pumper) {} @SuppressWarnings("resource") // Do not close stdin protected ExecInLldb execInLldb(String script) throws IOException { - ProcessBuilder pb = new ProcessBuilder(lldbPath.toString()); - setPythonPath(pb); + Pty pty = PtyFactory.local().openpty(); + Map env = new HashMap<>(System.getenv()); + setPythonPath(env); + env.put("TERM", "xterm-256color"); + ByteArrayOutputStream capture = new ByteArrayOutputStream(); + OutputStream tee = new TeeOutputStream(System.out, capture); + Thread pumper = new StreamPumper(pty.getParent().getInputStream(), tee); + pumper.start(); + PtySession lldbSession = pty.getChild().session(new String[] { lldbPath.toString() }, env); - // If commands come from file, LLDB will quit after EOF. - Msg.info(this, "outFile: " + outFile); - Msg.info(this, "errFile: " + errFile); - pb.redirectInput(ProcessBuilder.Redirect.PIPE); - pb.redirectOutput(outFile.toFile()); - pb.redirectError(errFile.toFile()); - Process lldbProc = pb.start(); - OutputStream stdin = lldbProc.getOutputStream(); + OutputStream stdin = pty.getParent().getOutputStream(); stdin.write(script.getBytes()); stdin.flush(); - return new ExecInLldb(lldbProc, CompletableFuture.supplyAsync(() -> { + return new ExecInLldb(pty, lldbSession, CompletableFuture.supplyAsync(() -> { try { - if (!lldbProc.waitFor(TIMEOUT_SECONDS, TimeUnit.SECONDS)) { - Msg.error(this, "Timed out waiting for LLDB"); - lldbProc.destroyForcibly(); - lldbProc.waitFor(TIMEOUT_SECONDS, TimeUnit.SECONDS); - return new LldbResult(true, -1, Files.readString(outFile), - Files.readString(errFile)); - } - Msg.info(this, "LLDB exited with code " + lldbProc.exitValue()); - return new LldbResult(false, lldbProc.exitValue(), Files.readString(outFile), - Files.readString(errFile)); + int exitVal = lldbSession.waitExited(TIMEOUT_SECONDS, TimeUnit.SECONDS); + Msg.info(this, "LLDB exited with code " + exitVal); + return new LldbResult(false, exitVal, capture.toString()); + } + catch (TimeoutException e) { + return new LldbResult(true, -1, capture.toString()); } catch (Exception e) { return ExceptionUtils.rethrow(e); } finally { - lldbProc.destroyForcibly(); + try { + pty.close(); + } + catch (IOException e) { + Msg.warn(this, "Couldn't close pty: " + e); + } + lldbSession.destroyForcibly(); + pumper.interrupt(); } - })); + }), pumper); } public static class LldbError extends RuntimeException { public final int exitCode; - public final String stdout; - public final String stderr; + public final String out; - public LldbError(int exitCode, String stdout, String stderr) { + public LldbError(int exitCode, String out) { super(""" exitCode=%d: - ----stdout---- + ----out---- %s - ----stderr---- - %s - """.formatted(exitCode, stdout, stderr)); + """.formatted(exitCode, out)); this.exitCode = exitCode; - this.stdout = stdout; - this.stderr = stderr; + this.out = out; } } @@ -250,17 +266,32 @@ public abstract class AbstractLldbTraceRmiTest extends AbstractGhidraHeadedDebug return (String) execute.invoke(Map.of("cmd", cmd, "to_string", true)); } + public Object evaluate(String expr) { + RemoteMethod evaluate = getMethod("evaluate"); + return evaluate.invoke(Map.of("expr", expr)); + } + + public Object pyeval(String expr) { + RemoteMethod pyeval = getMethod("pyeval"); + return pyeval.invoke(Map.of("expr", expr)); + } + @Override public void close() throws Exception { Msg.info(this, "Cleaning up lldb"); - exec.lldb().destroy(); + execute("settings set auto-confirm true"); + exec.pty.getParent().getOutputStream().write(""" + quit + """.getBytes()); try { LldbResult r = exec.future.get(TIMEOUT_SECONDS, TimeUnit.SECONDS); r.handle(); waitForPass(() -> assertTrue(connection.isClosed())); } finally { + exec.pty.close(); exec.lldb.destroyForcibly(); + exec.pumper.interrupt(); } } } @@ -276,8 +307,10 @@ public abstract class AbstractLldbTraceRmiTest extends AbstractGhidraHeadedDebug return new LldbAndConnection(exec, connection); } catch (SocketTimeoutException e) { + exec.pty.close(); exec.lldb.destroyForcibly(); exec.future.get(TIMEOUT_SECONDS, TimeUnit.SECONDS).handle(); + exec.pumper.interrupt(); throw e; } } @@ -285,7 +318,7 @@ public abstract class AbstractLldbTraceRmiTest extends AbstractGhidraHeadedDebug protected LldbAndConnection startAndConnectLldb() throws Exception { return startAndConnectLldb(addr -> """ %s - ghidra_trace_connect %s + ghidra trace connect %s """.formatted(PREAMBLE, addr)); } @@ -294,36 +327,56 @@ public abstract class AbstractLldbTraceRmiTest extends AbstractGhidraHeadedDebug throws Exception { LldbAndConnection conn = startAndConnectLldb(scriptSupplier); LldbResult r = conn.exec.future.get(TIMEOUT_SECONDS, TimeUnit.SECONDS); + conn.exec.pty.close(); + conn.exec.pumper.interrupt(); String stdout = r.handle(); waitForPass(() -> assertTrue(conn.connection.isClosed())); return stdout; } - protected void waitStopped() { + protected void waitState(String state) { TraceObject proc = Objects.requireNonNull(tb.objAny("Processes[]", Lifespan.at(0))); - waitForPass(() -> assertEquals("STOPPED", tb.objValue(proc, 0, "_state"))); + for (int i = 0; i < 5; i++) { + try { + waitForPass(() -> { + Long snap = tb.trace.getTimeManager().getMaxSnap(); + assertEquals(state, tb.objValue(proc, snap != null ? snap : 0, "_state")); + }); + break; + } + catch (AssertionError e) { + if (i == 4) { + throw e; + } + } + } waitTxDone(); } - protected void waitRunning() { - TraceObject proc = Objects.requireNonNull(tb.objAny("Processes[]", Lifespan.at(0))); - waitForPass(() -> assertEquals("RUNNING", tb.objValue(proc, 0, "_state"))); - waitTxDone(); + protected void waitStopped(LldbAndConnection conn) { + waitForPass(() -> assertEquals(Boolean.TRUE, + conn.pyeval("util.get_debugger().GetTargetAtIndex(0).GetProcess().is_stopped"))); + // waitState("STOPPED"); + } + + protected void waitRunning(LldbAndConnection conn) { + waitForPass(() -> assertEquals(Boolean.TRUE, + conn.pyeval("util.get_debugger().GetTargetAtIndex(0).GetProcess().is_running"))); + // waitState("RUNNING"); } protected String extractOutSection(String out, String head) { - String[] split = out.split("\n"); + String[] split = out.replace("\r", "").split("\n"); String xout = ""; for (String s : split) { - if (!s.startsWith("(lldb)") && !s.equals("")) { + if (!s.startsWith("(lldb)") && !s.contains("script print(") && !s.equals("")) { xout += s + "\n"; } } return xout.split(head)[1].split("---")[0].replace("(lldb)", "").trim(); } - record MemDump(long address, byte[] data) { - } + record MemDump(long address, byte[] data) {} protected MemDump parseHexDump(String dump) throws IOException { // First, get the address. Assume contiguous, so only need top line. @@ -348,13 +401,6 @@ public abstract class AbstractLldbTraceRmiTest extends AbstractGhidraHeadedDebug return new MemDump(address, buf.toByteArray()); } - record RegDump() { - } - - protected RegDump parseRegDump(String dump) { - return new RegDump(); - } - protected ManagedDomainObject openDomainObject(String path) throws Exception { DomainFile df = env.getProject().getProjectData().getFile(path); assertNotNull(df); @@ -376,6 +422,14 @@ public abstract class AbstractLldbTraceRmiTest extends AbstractGhidraHeadedDebug } } + protected void assertLocalOs(String actual) { + assertThat(actual, Matchers.startsWith(switch (OperatingSystem.CURRENT_OPERATING_SYSTEM) { + case LINUX -> "linux"; + case MAC_OS_X -> "macos"; + default -> throw new AssertionError("What OS?"); + })); + } + protected void assertBreakLoc(TraceObjectValue locVal, String key, Address addr, int len, Set kinds, String expression) throws Exception { assertEquals(key, locVal.getEntryKey()); diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbCommandsTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbCommandsTest.java index a62dc79713..d9353c2175 100644 --- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbCommandsTest.java +++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbCommandsTest.java @@ -24,11 +24,13 @@ import java.util.Map.Entry; import java.util.concurrent.atomic.AtomicReference; import java.util.function.Function; import java.util.stream.Collectors; -import java.util.stream.IntStream; +import java.util.stream.Stream; +import org.junit.Ignore; import org.junit.Test; import org.junit.experimental.categories.Category; +import db.Transaction; import generic.Unique; import generic.test.category.NightlyCategory; import ghidra.app.plugin.core.debug.utils.ManagedDomainObject; @@ -37,11 +39,15 @@ import ghidra.debug.api.tracermi.TraceRmiAcceptor; import ghidra.debug.api.tracermi.TraceRmiConnection; import ghidra.framework.model.DomainFile; import ghidra.program.model.address.*; +import ghidra.program.model.data.*; +import ghidra.program.model.lang.Register; import ghidra.program.model.lang.RegisterValue; import ghidra.program.model.listing.CodeUnit; import ghidra.trace.database.ToyDBTraceBuilder; import ghidra.trace.model.*; import ghidra.trace.model.breakpoint.TraceBreakpointKind; +import ghidra.trace.model.listing.TraceCodeSpace; +import ghidra.trace.model.listing.TraceData; import ghidra.trace.model.memory.*; import ghidra.trace.model.modules.TraceModule; import ghidra.trace.model.target.*; @@ -55,7 +61,7 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testManual() throws Exception { TraceRmiAcceptor acceptor = traceRmi.acceptOne(null); Msg.info(this, - "Use: ghidra_trace_connect " + sockToStringForLldb(acceptor.getAddress())); + "Use: ghidra trace connect " + sockToStringForLldb(acceptor.getAddress())); TraceRmiConnection connection = acceptor.accept(); Msg.info(this, "Connected: " + sockToStringForLldb(connection.getRemoteAddress())); connection.waitClosed(); @@ -64,25 +70,21 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { @Test public void testConnectErrorNoArg() throws Exception { - try { - runThrowError(""" - script import ghidralldb - ghidra_trace_connect - quit - """); - fail(); - } - catch (LldbError e) { - assertThat(e.stderr, containsString("'ghidra_trace_connect'")); - assertThat(e.stderr, containsString("'address'")); - } + String out = runThrowError(""" + script import ghidralldb + ghidra trace connect + quit + """); + assertThat(out, containsString("ghidra trace connect")); + assertThat(out, containsString("error:")); + assertThat(out, containsString("ADDRESS")); } @Test public void testConnect() throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s + ghidra trace connect %s quit """.formatted(PREAMBLE, addr)); } @@ -91,8 +93,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testDisconnect() throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s - ghidra_trace_disconnect + ghidra trace connect %s + ghidra trace disconnect quit """.formatted(PREAMBLE, addr)); } @@ -102,16 +104,16 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { // Default name and lcsp runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash - ghidra_trace_start + ghidra trace connect %s + file %s + ghidra trace start quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - assertEquals("x86:LE:64:default", + assertEquals(PLAT.lang(), tb.trace.getBaseLanguage().getLanguageID().getIdAsString()); - assertEquals("gcc", + assertEquals(PLAT.cSpec(), tb.trace.getBaseCompilerSpec().getCompilerSpecID().getIdAsString()); } } @@ -120,8 +122,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testStartTraceDefaultNoFile() throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s - ghidra_trace_start + ghidra trace connect %s + ghidra trace start quit """.formatted(PREAMBLE, addr)); try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) { @@ -134,14 +136,14 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { runThrowError( addr -> """ %s - ghidra_trace_connect %s - file bash + ghidra trace connect %s + file %s script ghidralldb.util.set_convenience_variable('ghidra-language','Toy:BE:64:default') script ghidralldb.util.set_convenience_variable('ghidra-compiler','default') - ghidra_trace_start myToy + ghidra trace start myToy quit """ - .formatted(PREAMBLE, addr)); + .formatted(PREAMBLE, addr, getSpecimenPrint())); DomainFile dfMyToy = env.getProject().getProjectData().getFile("/New Traces/myToy"); assertNotNull(dfMyToy); try (ManagedDomainObject mdo = new ManagedDomainObject(dfMyToy, false, false, monitor)) { @@ -155,19 +157,18 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { @Test public void testStopTrace() throws Exception { - // TODO: This test assumes lldb and the target file bash are x86-64 runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash - ghidra_trace_start - ghidra_trace_stop + ghidra trace connect %s + file %s + ghidra trace start + ghidra trace stop quit - """.formatted(PREAMBLE, addr)); - DomainFile dfBash = env.getProject().getProjectData().getFile("/New Traces/lldb/bash"); - assertNotNull(dfBash); + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + DomainFile df = env.getProject().getProjectData().getFile("/New Traces/lldb/expPrint"); + assertNotNull(df); // TODO: Given the 'quit' command, I'm not sure this assertion is checking anything. - assertFalse(dfBash.isOpen()); + assertFalse(df.isOpen()); } @Test @@ -176,24 +177,24 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { String out = runThrowError(addr -> { refAddr.set(addr); return """ - file bash + file %s %s - _mark_ ---Import--- - ghidra_trace_info - ghidra_trace_connect %s - _mark_ ---Connect--- - ghidra_trace_info - ghidra_trace_start - _mark_ ---Start--- - ghidra_trace_info - ghidra_trace_stop - _mark_ ---Stop--- - ghidra_trace_info - ghidra_trace_disconnect - _mark_ ---Disconnect--- - ghidra_trace_info + script print("---Import---") + ghidra trace info + ghidra trace connect %s + script print("---Connect---") + ghidra trace info + ghidra trace start + script print("---Start---") + ghidra trace info + ghidra trace stop + script print("---Stop---") + ghidra trace info + ghidra trace disconnect + script print("---Disconnect---") + ghidra trace info quit - """.formatted(PREAMBLE, addr); + """.formatted(getSpecimenPrint(), PREAMBLE, addr); }); assertEquals(""" @@ -218,32 +219,28 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { @Test public void testLcsp() throws Exception { - // TODO: This test assumes x86-64 on test system String out = runThrowError( """ script import ghidralldb - _mark_ ---Import--- - ghidra_trace_info_lcsp - _mark_ --- - file bash - _mark_ ---File--- - ghidra_trace_info_lcsp + script print("---Import---") + ghidra trace info-lcsp + script print("--- + file %s + script print("---File---") + ghidra trace info-lcsp script ghidralldb.util.set_convenience_variable('ghidra-language','Toy:BE:64:default') - _mark_ ---Language--- - ghidra_trace_info_lcsp + script print("---Language---") + ghidra trace info-lcsp script ghidralldb.util.set_convenience_variable('ghidra-compiler','posStack') - _mark_ ---Compiler--- - ghidra_trace_info_lcsp + script print("---Compiler---") + ghidra trace info-lcsp quit - """); + """ + .formatted(getSpecimenPrint())); -// assertEquals(""" -// Selected Ghidra language: DATA:LE:64:default -// Selected Ghidra compiler: pointer64""", -// extractOutSection(out, "---Import---")); assertEquals(""" - Selected Ghidra language: x86:LE:64:default - Selected Ghidra compiler: gcc""", + Selected Ghidra language: %s + Selected Ghidra compiler: %s""".formatted(PLAT.lang(), PLAT.cSpec()), extractOutSection(out, "---File---")); assertEquals(""" Selected Ghidra language: Toy:BE:64:default @@ -262,14 +259,14 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { // For sanity check, verify failing to save drops data runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash - ghidra_trace_start no-save - ghidra_trace_txstart "Create snapshot" - ghidra_trace_new_snap "Scripted snapshot" - ghidra_trace_txcommit + ghidra trace connect %s + file %s + ghidra trace start no-save + ghidra trace tx-start "Create snapshot" + ghidra trace new-snap "Scripted snapshot" + ghidra trace tx-commit quit - """.formatted(PREAMBLE, addr)); + """.formatted(PREAMBLE, addr, getSpecimenPrint())); try (ManagedDomainObject mdo = openDomainObject("/New Traces/no-save")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); assertEquals(0, tb.trace.getTimeManager().getAllSnapshots().size()); @@ -277,15 +274,15 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash - ghidra_trace_start save - ghidra_trace_txstart "Create snapshot" - ghidra_trace_new_snap "Scripted snapshot" - ghidra_trace_txcommit - ghidra_trace_save + ghidra trace connect %s + file %s + ghidra trace start save + ghidra trace tx-start "Create snapshot" + ghidra trace new-snap "Scripted snapshot" + ghidra trace tx-commit + ghidra trace save quit - """.formatted(PREAMBLE, addr)); + """.formatted(PREAMBLE, addr, getSpecimenPrint())); try (ManagedDomainObject mdo = openDomainObject("/New Traces/save")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); assertEquals(1, tb.trace.getTimeManager().getAllSnapshots().size()); @@ -296,19 +293,19 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testSnapshot() throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash - ghidra_trace_start - ghidra_trace_txstart "Create snapshot" - ghidra_trace_new_snap "Scripted snapshot" - ghidra_trace_txcommit + ghidra trace connect %s + file %s + ghidra trace start + ghidra trace tx-start "Create snapshot" + ghidra trace new-snap "Scripted snapshot" + ghidra trace tx-commit quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); TraceSnapshot snapshot = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()); assertEquals(0, snapshot.getKey()); - assertEquals("\"Scripted snapshot\"", snapshot.getDescription()); + assertEquals("Scripted snapshot", snapshot.getDescription()); } } @@ -316,21 +313,21 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testPutmem() throws Exception { String out = runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Create snapshot" - ghidra_trace_new_snap "Scripted snapshot" - ghidra_trace_putmem `(void(*)())main` 10 - ghidra_trace_txcommit - _mark_ ---Dump--- + ghidra trace start + ghidra trace tx-start "Create snapshot" + ghidra trace new-snap "Scripted snapshot" + ghidra trace putmem `(void(*)())main` 10 + ghidra trace tx-commit + script print("---Dump---") x/10bx `(void(*)())main` - _mark_ ---") + script print("---") kill quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey(); @@ -342,73 +339,42 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { } } - // Not sure this is a meaningful test anymore - @Test - public void testPutmemProcess2() throws Exception { - String out = runThrowError(addr -> """ - %s - ghidra_trace_connect %s - file bash - process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Create snapshot" - ghidra_trace_new_snap "Scripted snapshot" - ghidra_trace_putmem `(void(*)())main` 10 - ghidra_trace_txcommit - _mark_ ---Dump--- - x/10bx `(void(*)())main` - _mark_ ---") - kill - quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { - tb = new ToyDBTraceBuilder((Trace) mdo.get()); - AddressSpace ram2 = tb.trace.getBaseAddressFactory().getAddressSpace("ram"); - assertNotNull(ram2); - long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey(); - - MemDump dump = parseHexDump(extractOutSection(out, "---Dump---")); - ByteBuffer buf = ByteBuffer.allocate(dump.data().length); - tb.trace.getMemoryManager().getBytes(snap, ram2.getAddress(dump.address()), buf); - - assertArrayEquals(dump.data(), buf.array()); - } - } + // TODO: Test with ram from a second process (e.g., child) @Test public void testPutmemState() throws Exception { String out = runThrowError(addr -> """ settings set interpreter.echo-commands false %s - ghidra_trace_connect %s - file bash + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Create snapshot" - ghidra_trace_new_snap "Scripted snapshot" - ghidra_trace_putmem_state `(void(*)())main` 10 error - ghidra_trace_txcommit - _mark_ ---Start--- + ghidra trace start + ghidra trace tx-start "Create snapshot" + ghidra trace new-snap "Scripted snapshot" + ghidra trace putmem-state `(void(*)())main` 10 error + ghidra trace tx-commit + script print("---Start---") print/x (void(*)())main - _mark_ ---") + script print("---") kill quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey(); String eval = extractOutSection(out, "---Start---"); - String addrstr = eval.split("=")[1].trim(); - if (addrstr.contains(" ")) { - addrstr = addrstr.substring(0, addrstr.indexOf(" ")); - } - Address addr = tb.addr(Long.decode(addrstr)); + Address addr = tb.addr(Stream.of(eval.split("\\s+")) + .filter(s -> s.startsWith("0x")) + .mapToLong(Long::decode) + .findFirst() + .orElseThrow()); Entry entry = tb.trace.getMemoryManager().getMostRecentStateEntry(snap, addr); assertEquals(Map.entry(new ImmutableTraceAddressSnapRange( - new AddressRangeImpl(addr, 10), Lifespan.at(0)), TraceMemoryState.ERROR), entry); + quantize(rng(addr, 10), 4096), Lifespan.at(0)), TraceMemoryState.ERROR), entry); } } @@ -416,22 +382,22 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testDelmem() throws Exception { String out = runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Create snapshot" - ghidra_trace_new_snap "Scripted snapshot" - ghidra_trace_putmem `(void(*)())main` 10 - ghidra_trace_delmem `(void(*)())main` 5 - ghidra_trace_txcommit - _mark_ ---Dump--- + ghidra trace start + ghidra trace tx-start "Create snapshot" + ghidra trace new-snap "Scripted snapshot" + ghidra trace putmem `(void(*)())main` 10 + ghidra trace delmem `(void(*)())main` 5 + ghidra trace tx-commit + script print("---Dump---") x/10bx (void(*)())main - _mark_ ---") + script print("---") kill quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey(); @@ -446,26 +412,23 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { @Test public void testPutreg() throws Exception { - String count = IntStream.iterate(0, i -> i < 32, i -> i + 1) - .mapToObj(Integer::toString) - .collect(Collectors.joining(",", "{", "}")); + // TODO: Test vector register, e.g., ymm0 runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - expr $rax = 0xdeadbeef - #expr $ymm0 = %s - expr $st0 = 1.5 - ghidra_trace_txstart "Create snapshot" - ghidra_trace_new_snap "Scripted snapshot" - ghidra_trace_putreg - ghidra_trace_txcommit + ghidra trace start + expr $%s = 0xdeadbeef + expr $%s = 1.5 + ghidra trace tx-start "Create snapshot" + ghidra trace new-snap "Scripted snapshot" + ghidra trace putreg + ghidra trace tx-commit kill quit - """.formatted(PREAMBLE, addr, count)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint(), PLAT.intReg(), PLAT.floatReg())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey(); List regVals = tb.trace.getObjectManager() @@ -478,47 +441,54 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { .getAddressSpace(tobj.getCanonicalPath().toString()); TraceMemorySpace regs = tb.trace.getMemoryManager().getMemorySpace(t1f0, false); - RegisterValue rax = regs.getValue(snap, tb.reg("rax")); - assertEquals("deadbeef", rax.getUnsignedValue().toString(16)); + RegisterValue intRegVal = regs.getValue(snap, tb.reg(PLAT.intReg())); + assertEquals("deadbeef", intRegVal.getUnsignedValue().toString(16)); // RegisterValue ymm0 = regs.getValue(snap, tb.reg("ymm0")); // // LLDB treats registers in arch's endian // assertEquals("1f1e1d1c1b1a191817161514131211100f0e0d0c0b0a09080706050403020100", // ymm0.getUnsignedValue().toString(16)); -// TraceData st0; -// try (Transaction tx = tb.trace.openTransaction("Float80 unit")) { -// TraceCodeSpace code = tb.trace.getCodeManager().getCodeSpace(t1f0, true); -// st0 = code.definedData() -// .create(Lifespan.nowOn(0), tb.reg("st0"), Float10DataType.dataType); -// } -// assertEquals("1.5", st0.getDefaultValueRepresentation()); + // It's either my version of lldb for Linux or just that x86 fp is weird. + if (PLAT != PlatDep.X8664) { + TraceData floatData; + Register floatReg = Objects.requireNonNull(tb.reg(PLAT.floatReg())); + DataType floatType = switch (floatReg.getMinimumByteSize()) { + case 4 -> Float4DataType.dataType; + case 8 -> Float8DataType.dataType; + case 10 -> Float8DataType.dataType; + default -> throw new AssertionError("Unknown float size"); + }; + try (Transaction tx = tb.trace.openTransaction("Float unit")) { + TraceCodeSpace code = tb.trace.getCodeManager().getCodeSpace(t1f0, true); + floatData = code.definedData().create(Lifespan.nowOn(0), floatReg, floatType); + } + assertEquals("1.5", floatData.getDefaultValueRepresentation()); + } } } @Test public void testDelreg() throws Exception { - String count = IntStream.iterate(0, i -> i < 32, i -> i + 1) - .mapToObj(Integer::toString) - .collect(Collectors.joining(",", "{", "}")); + // TODO: Test vector register, e.g., ymm0 runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - #expr $ymm0 = %s - expr $st0 = 1.5 - ghidra_trace_txstart "Create snapshot" - ghidra_trace_new_snap "Scripted snapshot" - ghidra_trace_putreg - ghidra_trace_delreg - ghidra_trace_txcommit + ghidra trace start + expr $%s = 0xdeadbeef + expr $%s = 1.5 + ghidra trace tx-start "Create snapshot" + ghidra trace new-snap "Scripted snapshot" + ghidra trace putreg + ghidra trace delreg + ghidra trace tx-commit kill quit - """.formatted(PREAMBLE, addr, count)); + """.formatted(PREAMBLE, addr, getSpecimenPrint(), PLAT.intReg(), PLAT.floatReg())); // The spaces will be left over, but the values should be zeroed - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey(); List regVals = tb.trace.getObjectManager() @@ -531,19 +501,25 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { .getAddressSpace(tobj.getCanonicalPath().toString()); TraceMemorySpace regs = tb.trace.getMemoryManager().getMemorySpace(t1f0, false); - RegisterValue rax = regs.getValue(snap, tb.reg("rax")); - assertEquals("0", rax.getUnsignedValue().toString(16)); + RegisterValue intRegVal = regs.getValue(snap, tb.reg(PLAT.intReg())); + assertEquals("0", intRegVal.getUnsignedValue().toString(16)); // RegisterValue ymm0 = regs.getValue(snap, tb.reg("ymm0")); // assertEquals("0", ymm0.getUnsignedValue().toString(16)); -// TraceData st0; -// try (Transaction tx = tb.trace.openTransaction("Float80 unit")) { -// TraceCodeSpace code = tb.trace.getCodeManager().getCodeSpace(t1f0, true); -// st0 = code.definedData() -// .create(Lifespan.nowOn(0), tb.reg("st0"), Float10DataType.dataType); -// } -// assertEquals("0.0", st0.getDefaultValueRepresentation()); + TraceData floatData; + Register floatReg = Objects.requireNonNull(tb.reg(PLAT.floatReg())); + DataType floatType = switch (floatReg.getMinimumByteSize()) { + case 4 -> Float4DataType.dataType; + case 8 -> Float8DataType.dataType; + case 10 -> Float10DataType.dataType; + default -> throw new AssertionError("Unknown float size"); + }; + try (Transaction tx = tb.trace.openTransaction("Float unit")) { + TraceCodeSpace code = tb.trace.getCodeManager().getCodeSpace(t1f0, true); + floatData = code.definedData().create(Lifespan.nowOn(0), floatReg, floatType); + } + assertEquals("0.0", floatData.getDefaultValueRepresentation()); } } @@ -551,13 +527,13 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testCreateObj() throws Exception { String out = runThrowError(addr -> """ %s - ghidra_trace_connect %s - ghidra_trace_start - ghidra_trace_txstart "Create Object" - _mark_ ---Id--- - ghidra_trace_create_obj Test.Objects[1] - _mark_ ---") - ghidra_trace_txcommit + ghidra trace connect %s + ghidra trace start + ghidra trace tx-start "Create Object" + script print("---Id---") + ghidra trace create-obj Test.Objects[1] + script print("---") + ghidra trace tx-commit quit """.formatted(PREAMBLE, addr)); try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) { @@ -575,14 +551,14 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testInsertObj() throws Exception { String out = runThrowError(addr -> """ %s - ghidra_trace_connect %s - ghidra_trace_start - ghidra_trace_txstart "Create Object" - ghidra_trace_create_obj Test.Objects[1] - _mark_ ---Lifespan--- - ghidra_trace_insert_obj Test.Objects[1] - _mark_ ---") - ghidra_trace_txcommit + ghidra trace connect %s + ghidra trace start + ghidra trace tx-start "Create Object" + ghidra trace create-obj Test.Objects[1] + script print("---Lifespan---") + ghidra trace insert-obj Test.Objects[1] + script print("---") + ghidra trace tx-commit quit """.formatted(PREAMBLE, addr)); try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) { @@ -601,20 +577,20 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testRemoveObj() throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Create Object" - ghidra_trace_create_obj Test.Objects[1] - ghidra_trace_insert_obj Test.Objects[1] - ghidra_trace_set_snap 1 - ghidra_trace_remove_obj Test.Objects[1] - ghidra_trace_txcommit + ghidra trace start + ghidra trace tx-start "Create Object" + ghidra trace create-obj Test.Objects[1] + ghidra trace insert-obj Test.Objects[1] + ghidra trace set-snap 1 + ghidra trace remove-obj Test.Objects[1] + ghidra trace tx-commit kill quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); TraceObject object = tb.trace.getObjectManager() .getObjectByCanonicalPath(TraceObjectKeyPath.parse("Test.Objects[1]")); @@ -629,20 +605,20 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Create Object" - ghidra_trace_create_obj Test.Objects[1] - ghidra_trace_insert_obj Test.Objects[1] + ghidra trace start + ghidra trace tx-start "Create Object" + ghidra trace create-obj Test.Objects[1] + ghidra trace insert-obj Test.Objects[1] %s - ghidra_trace_set_value Test.Objects[1] test %s %s - ghidra_trace_txcommit + ghidra trace set-value Test.Objects[1] test %s %s + ghidra trace tx-commit kill quit - """.formatted(PREAMBLE, addr, extra, lldbExpr, gtype)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint(), extra, lldbExpr, gtype)); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); TraceObject object = tb.trace.getObjectManager() .getObjectByCanonicalPath(TraceObjectKeyPath.parse("Test.Objects[1]")); @@ -655,84 +631,110 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { // NB: Fails in gdb tests as well //@Test public void testSetValueNull() throws Exception { - assertNull(runTestSetValue("", "(void)null", "")); + assertNull(runTestSetValue("", """ + (void)null\ + """, "")); } @Test public void testSetValueBool() throws Exception { - // C++ required for bool - assertEquals(Boolean.TRUE, runTestSetValue("#set language c++", "(bool)1", "")); + assertEquals(Boolean.TRUE, runTestSetValue("", """ + (bool)1\ + """, "")); } @Test public void testSetValueByte() throws Exception { - assertEquals(Byte.valueOf((byte) 1), runTestSetValue("", "(char)1", "")); + assertEquals(Byte.valueOf((byte) 1), runTestSetValue("", """ + (char)1\ + """, "")); } @Test public void testSetValueChar() throws Exception { - assertEquals(Character.valueOf('A'), runTestSetValue("", "'A'", "CHAR")); + assertEquals(Character.valueOf('A'), runTestSetValue("", """ + "'A'"\ + """, "CHAR")); } @Test public void testSetValueShort() throws Exception { - assertEquals(Short.valueOf((short) 1), runTestSetValue("", "(short)1", "")); + assertEquals(Short.valueOf((short) 1), runTestSetValue("", """ + (short)1\ + """, "")); } @Test public void testSetValueInt() throws Exception { - assertEquals(Integer.valueOf(1), runTestSetValue("", "(int)1", "")); + assertEquals(Integer.valueOf(1), runTestSetValue("", """ + (int)1\ + """, "")); } @Test public void testSetValueLong() throws Exception { - assertEquals(Long.valueOf(1), runTestSetValue("", "(long)1", "")); + assertEquals(Long.valueOf(1), runTestSetValue("", """ + (long)1\ + """, "")); } @Test + @Ignore("LLDB Can't seem to allocate the string. EXC_BAD_ACCESS.") public void testSetValueString() throws Exception { - assertEquals("\"Hello World!\"", runTestSetValue("", "\"Hello World!\"", "")); + assertEquals("\"Hello World!\"", runTestSetValue("", """ + '"Hello World!"'\ + """, "")); } @Test + @Ignore("LLDB Can't seem to allocate the string. EXC_BAD_ACCESS.") public void testSetValueStringWide() throws Exception { - assertEquals("L\"Hello World!\"", runTestSetValue("", "L\"Hello World!\"", "")); + assertEquals("L\"Hello World!\"", runTestSetValue("", """ + 'L"Hello World!"'\ + """, "")); } @Test + @Ignore("Temp var $x thing doesn't work") public void testSetValueBoolArr() throws Exception { - // C++ required for bool, true, false assertArrayEquals(new boolean[] { true, false }, runTestSetValue("expr bool $x[2]={ true, false }", "$x", "")); } @Test + @Ignore("LLDB Can't seem to allocate the string. EXC_BAD_ACCESS.") public void testSetValueByteArrUsingString() throws Exception { // Because explicit array type is chosen, we get null terminator - assertArrayEquals(new byte[] { 'H', 0, 'W', 0 }, - runTestSetValue("expr char $x[]=\"H\\0W\"", "$x", "BYTE_ARR")); + assertArrayEquals(new byte[] { 'H', 0, 'W', 0 }, runTestSetValue("", """ + '"H\\0W"'\ + """, "BYTE_ARR")); } @Test + @Ignore("Temp var $x thing doesn't work") public void testSetValueByteArrUsingArray() throws Exception { assertArrayEquals(new byte[] { 'H', 0, 'W' }, runTestSetValue("expr char $x[]={'H', 0, 'W'}", "$x", "BYTE_ARR")); } @Test + @Ignore("LLDB Can't seem to allocate the string. EXC_BAD_ACCESS.") public void testSetValueCharArrUsingString() throws Exception { // Because explicit array type is chosen, we get null terminator - assertArrayEquals(new char[] { 'H', 0, 'W', 0 }, - runTestSetValue("expr char $x[]=\"H\\0W\"", "$x", "CHAR_ARR")); + assertArrayEquals(new char[] { 'H', 0, 'W', 0 }, runTestSetValue("", """ + '"H\\0W"'\ + """, "CHAR_ARR")); } @Test + @Ignore("Temp var $x thing doesn't work") public void testSetValueCharArrUsingArray() throws Exception { assertArrayEquals(new char[] { 'H', 0, 'W' }, runTestSetValue("expr char $x[]={'H', 0, 'W'}", "$x", "CHAR_ARR")); } @Test + @Ignore("Temp var $x thing doesn't work") public void testSetValueShortArrUsingString() throws Exception { // Because explicit array type is chosen, we get null terminator assertArrayEquals(new short[] { 'H', 0, 'W', 0 }, @@ -740,12 +742,14 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { } @Test + @Ignore("Temp var $x thing doesn't work") public void testSetValueShortArrUsingArray() throws Exception { assertArrayEquals(new short[] { 'H', 0, 'W' }, runTestSetValue("expr short $x[]={'H', 0, 'W'}", "$x", "SHORT_ARR")); } @Test + @Ignore("Temp var $x thing doesn't work") public void testSetValueIntArrayUsingMixedArray() throws Exception { // Because explicit array type is chosen, we get null terminator assertArrayEquals(new int[] { 'H', 0, 'W' }, @@ -753,12 +757,14 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { } @Test + @Ignore("Temp var $x thing doesn't work") public void testSetValueIntArrUsingArray() throws Exception { assertArrayEquals(new int[] { 1, 2, 3, 4 }, runTestSetValue("expr int $x[]={1,2,3,4}", "$x", "")); } @Test + @Ignore("Temp var $x thing doesn't work") public void testSetValueLongArr() throws Exception { assertArrayEquals(new long[] { 1, 2, 3, 4 }, runTestSetValue("expr long long $x[]={1LL,2LL,3LL,4LL}", "$x", "")); @@ -768,7 +774,9 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { @Test public void testSetValueAddress() throws Exception { - Address address = runTestSetValue("", "(void*)0xdeadbeef", ""); + Address address = runTestSetValue("", """ + (void*)0xdeadbeef\ + """, ""); // Don't have the address factory to create expected address assertEquals(0xdeadbeefL, address.getOffset()); assertEquals("ram", address.getAddressSpace().getName()); @@ -784,24 +792,23 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testRetainValues() throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash - #set language c++ + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Create Object" - ghidra_trace_create_obj Test.Objects[1] - ghidra_trace_insert_obj Test.Objects[1] - ghidra_trace_set_value Test.Objects[1] [1] '"A"' - ghidra_trace_set_value Test.Objects[1] [2] '"B"' - ghidra_trace_set_value Test.Objects[1] [3] '"C"' - ghidra_trace_set_snap 10 - ghidra_trace_retain_values Test.Objects[1] [1] [3] - ghidra_trace_txcommit + ghidra trace start + ghidra trace tx-start "Create Object" + ghidra trace create-obj Test.Objects[1] + ghidra trace insert-obj Test.Objects[1] + ghidra trace set-value Test.Objects[1] [1] 10 + ghidra trace set-value Test.Objects[1] [2] 20 + ghidra trace set-value Test.Objects[1] [3] 30 + ghidra trace set-snap 10 + ghidra trace retain-values Test.Objects[1] [1] [3] + ghidra trace tx-commit kill quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); TraceObject object = tb.trace.getObjectManager() .getObjectByCanonicalPath(TraceObjectKeyPath.parse("Test.Objects[1]")); @@ -820,16 +827,16 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testGetObj() throws Exception { String out = runThrowError(addr -> """ %s - ghidra_trace_connect %s - ghidra_trace_start - ghidra_trace_txstart "Create Object" - _mark_ ---Id--- - ghidra_trace_create_obj Test.Objects[1] - _mark_ ---") - ghidra_trace_txcommit - _mark_ ---GetObject--- - ghidra_trace_get_obj Test.Objects[1] - _mark_ ---") + ghidra trace connect %s + ghidra trace start + ghidra trace tx-start "Create Object" + script print("---Id---") + ghidra trace create-obj Test.Objects[1] + script print("---") + ghidra trace tx-commit + script print("---GetObject---") + ghidra trace get-obj Test.Objects[1] + script print("---") quit """.formatted(PREAMBLE, addr)); try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) { @@ -838,7 +845,7 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { .getObjectByCanonicalPath(TraceObjectKeyPath.parse("Test.Objects[1]")); assertNotNull(object); String getObject = extractOutSection(out, "---GetObject---"); - assertEquals("1\tTest.Objects[1]", getObject); + assertEquals("%d\tTest.Objects[1]".formatted(object.getKey()), getObject); } } @@ -846,65 +853,43 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testGetValues() throws Exception { String out = runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Create Object" - ghidra_trace_create_obj Test.Objects[1] - ghidra_trace_insert_obj Test.Objects[1] - #ghidra_trace_set_value Test.Objects[1] vnull (void)null - ghidra_trace_set_value Test.Objects[1] vbool true - ghidra_trace_set_value Test.Objects[1] vbyte (char)1 - ghidra_trace_set_value Test.Objects[1] vchar 'A' CHAR - ghidra_trace_set_value Test.Objects[1] vshort (short)2 - ghidra_trace_set_value Test.Objects[1] vint 3 - ghidra_trace_set_value Test.Objects[1] vlong 4LL - ghidra_trace_set_value Test.Objects[1] vstring "Hello" - expr bool $vboolarr[] = {true, false} - ghidra_trace_set_value Test.Objects[1] vboolarr $vboolarr - expr char $vbytearr[] = {1, 2, 3} - ghidra_trace_set_value Test.Objects[1] vbytearr $vbytearr BYTE_ARR - expr char $vchararr[] = "Hello" - ghidra_trace_set_value Test.Objects[1] vchararr $vchararr CHAR_ARR - expr short $vshortarr[] = {1, 2, 3} - ghidra_trace_set_value Test.Objects[1] vshortarr $vshortarr - expr int $vintarr[] = {1, 2, 3} - ghidra_trace_set_value Test.Objects[1] vintarr $vintarr - expr long $vlongarr[] = {1LL, 2LL, 3LL} - ghidra_trace_set_value Test.Objects[1] vlongarr $vlongarr - ghidra_trace_set_value Test.Objects[1] vaddr (void*)0xdeadbeef - ghidra_trace_set_value Test.Objects[1] vobj Test.Objects[1] OBJECT - ghidra_trace_txcommit - _mark_ ---GetValues--- - ghidra_trace_get_values Test.Objects[1]. - _mark_ ---") + ghidra trace start + ghidra trace tx-start "Create Object" + ghidra trace create-obj Test.Objects[1] + ghidra trace insert-obj Test.Objects[1] + ghidra trace set-value Test.Objects[1] vbool true + ghidra trace set-value Test.Objects[1] vbyte (char)1 + ghidra trace set-value Test.Objects[1] vchar "'A'" CHAR + ghidra trace set-value Test.Objects[1] vshort (short)2 + ghidra trace set-value Test.Objects[1] vint 3 + ghidra trace set-value Test.Objects[1] vlong 4LL + ghidra trace set-value Test.Objects[1] vaddr (void*)0xdeadbeef + ghidra trace set-value Test.Objects[1] vobj Test.Objects[1] OBJECT + ghidra trace tx-commit + script print("---GetValues---") + ghidra trace get-values Test.Objects[1]. + script print("---") kill quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); assertEquals( """ - Parent Key Span Value Type - Test.Objects[1] vaddr [0,+inf) ram:deadbeef ADDRESS - Test.Objects[1] vbool [0,+inf) True BOOL - Test.Objects[1] vboolarr [0,+inf) [True, False] BOOL_ARR - Test.Objects[1] vbyte [0,+inf) 1 BYTE - Test.Objects[1] vbytearr [0,+inf) b'\\x01\\x02\\x03' BYTE_ARR - Test.Objects[1] vchar [0,+inf) 'A' CHAR - Test.Objects[1] vchararr [0,+inf) 'Hello\\x00' CHAR_ARR - Test.Objects[1] vint [0,+inf) 3 INT - Test.Objects[1] vintarr [0,+inf) [1, 2, 3] INT_ARR - Test.Objects[1] vlong [0,+inf) 4 LONG - Test.Objects[1] vlongarr [0,+inf) [1, 2, 3] LONG_ARR - Test.Objects[1] vobj [0,+inf) Test.Objects[1] OBJECT - Test.Objects[1] vshort [0,+inf) 2 SHORT - Test.Objects[1] vshortarr [0,+inf) [1, 2, 3] SHORT_ARR - Test.Objects[1] vstring [0,+inf) '"Hello"' STRING""" - .replaceAll(" ", "") - .replaceAll("\n", ""), - extractOutSection(out, "---GetValues---").replaceAll(" ", "").replaceAll("\n", "")); + Parent Key Span Value Type + Test.Objects[1] vaddr [0,+inf) ram:deadbeef ADDRESS + Test.Objects[1] vbool [0,+inf) True BOOL + Test.Objects[1] vbyte [0,+inf) 1 BYTE + Test.Objects[1] vchar [0,+inf) 'A' CHAR + Test.Objects[1] vint [0,+inf) 3 INT + Test.Objects[1] vlong [0,+inf) 4 LONG + Test.Objects[1] vobj [0,+inf) Test.Objects[1] OBJECT + Test.Objects[1] vshort [0,+inf) 2 SHORT\ + """, + extractOutSection(out, "---GetValues---")); } } @@ -912,36 +897,28 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testGetValuesRng() throws Exception { String out = runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash - #set language c++ + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Create Object" - ghidra_trace_create_obj Test.Objects[1] - ghidra_trace_insert_obj Test.Objects[1] - ghidra_trace_set_value Test.Objects[1] vaddr (void*)0xdeadbeef - ghidra_trace_txcommit - _mark_ ---GetValues--- - ghidra_trace_get_values_rng (void*)0xdeadbeef 10 - _mark_ ---") + ghidra trace start + ghidra trace tx-start "Create Object" + ghidra trace create-obj Test.Objects[1] + ghidra trace insert-obj Test.Objects[1] + ghidra trace set-value Test.Objects[1] vaddr (void*)0xdeadbeef + ghidra trace tx-commit + script print("---GetValues---") + ghidra trace get-values-rng (void*)0xdeadbeef 10 + script print("---") kill quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); assertEquals(""" - Parent - Key - Span - Value - Type - Test.Objects[1] - vaddr - [0,+inf) - ram:deadbeef - ADDRESS""".replaceAll(" ", ""), - extractOutSection(out, "---GetValues---").replaceAll(" ", "")); + Parent Key Span Value Type + Test.Objects[1] vaddr [0,+inf) ram:deadbeef ADDRESS\ + """, + extractOutSection(out, "---GetValues---")); } } @@ -949,20 +926,19 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testActivateObject() throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash - #set language c++ + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Create Object" - ghidra_trace_create_obj Test.Objects[1] - ghidra_trace_insert_obj Test.Objects[1] - ghidra_trace_txcommit - ghidra_trace_activate Test.Objects[1] + ghidra trace start + ghidra trace tx-start "Create Object" + ghidra trace create-obj Test.Objects[1] + ghidra trace insert-obj Test.Objects[1] + ghidra trace tx-commit + ghidra trace activate Test.Objects[1] kill quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { assertSame(mdo.get(), traceManager.getCurrentTrace()); assertEquals("Test.Objects[1]", traceManager.getCurrentObject().getCanonicalPath().toString()); @@ -973,21 +949,20 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testDisassemble() throws Exception { String out = runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash - #set language c++ + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Tx" - ghidra_trace_putmem `(void(*)())main` 10 - _mark_ ---Disassemble--- - ghidra_trace_disassemble `(void(*)())main` - _mark_ ---") - ghidra_trace_txcommit + ghidra trace start + ghidra trace tx-start "Tx" + ghidra trace putmem `(void(*)())main` 10 + script print("---Disassemble---") + ghidra trace disassemble `(void(*)())main` + script print("---") + ghidra trace tx-commit kill quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); // Not concerned about specifics, so long as disassembly occurs long total = 0; @@ -1003,11 +978,11 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testPutProcesses() throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s - ghidra_trace_start - ghidra_trace_txstart "Tx" - ghidra_trace_put_processes - ghidra_trace_txcommit + ghidra trace connect %s + ghidra trace start + ghidra trace tx-start "Tx" + ghidra trace put-processes + ghidra trace tx-commit quit """.formatted(PREAMBLE, addr)); try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) { @@ -1025,11 +1000,11 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testPutAvailable() throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s - ghidra_trace_start - ghidra_trace_txstart "Tx" - ghidra_trace_put_available - ghidra_trace_txcommit + ghidra trace connect %s + ghidra trace start + ghidra trace tx-start "Tx" + ghidra trace put-available + ghidra trace tx-commit quit """.formatted(PREAMBLE, addr)); try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) { @@ -1047,19 +1022,19 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testPutBreakpoints() throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Tx" + ghidra trace start + ghidra trace tx-start "Tx" breakpoint set --name main breakpoint set -H --name main - ghidra_trace_put_breakpoints - ghidra_trace_txcommit + ghidra trace put-breakpoints + ghidra trace tx-commit kill quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); List procBreakLocVals = tb.trace.getObjectManager() .getValuePaths(Lifespan.at(0), @@ -1085,20 +1060,20 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testPutWatchpoints() throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Tx" - watchpoint set expression -- `(void(*)())main` - watchpoint set expression -w read -- `(void(*)())main`+-0x20 - watchpoint set expression -w read_write -- `(void(*)())main`+0x30 - ghidra_trace_put_watchpoints - ghidra_trace_txcommit + ghidra trace start + ghidra trace tx-start "Tx" + watchpoint set expression -s 1 -- `(void(*)())main` + watchpoint set expression -s 1 -w read -- `(void(*)())main`+-0x20 + watchpoint set expression -s 1 -w read_write -- `(void(*)())main`+0x30 + ghidra trace put-watchpoints + ghidra trace tx-commit kill quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); List procWatchLocVals = tb.trace.getObjectManager() .getValuePaths(Lifespan.at(0), @@ -1130,25 +1105,25 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testPutEnvironment() throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Tx" - ghidra_trace_put_environment - ghidra_trace_txcommit + ghidra trace start + ghidra trace tx-start "Tx" + ghidra trace put-environment + ghidra trace tx-commit kill quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); // Assumes LLDB on Linux amd64 TraceObject env = Objects.requireNonNull(tb.objAny("Processes[].Environment", Lifespan.at(0))); assertEquals("lldb", env.getValue(0, "_debugger").getValue()); - assertEquals("x86_64", env.getValue(0, "_arch").getValue()); - assertEquals("linux", env.getValue(0, "_os").getValue()); - assertEquals("little", env.getValue(0, "_endian").getValue()); + assertEquals(PLAT.name(), env.getValue(0, "_arch").getValue()); + assertLocalOs(env.getValue(0, "_os").castValue()); + assertEquals(PLAT.endian(), env.getValue(0, "_endian").getValue()); } } @@ -1156,17 +1131,17 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testPutRegions() throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Tx" - ghidra_trace_put_regions - ghidra_trace_txcommit + ghidra trace start + ghidra trace tx-start "Tx" + ghidra trace put-regions + ghidra trace tx-commit kill quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); // Would be nice to control / validate the specifics Collection all = @@ -1179,23 +1154,23 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testPutModules() throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Tx" - ghidra_trace_put_modules - ghidra_trace_txcommit + ghidra trace start + ghidra trace tx-start "Tx" + ghidra trace put-modules + ghidra trace tx-commit kill quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); // Would be nice to control / validate the specifics Collection all = tb.trace.getModuleManager().getAllModules(); - TraceModule modBash = - Unique.assertOne(all.stream().filter(m -> m.getName().contains("bash"))); - assertNotEquals(tb.addr(0), Objects.requireNonNull(modBash.getBase())); + TraceModule modExpPrint = + Unique.assertOne(all.stream().filter(m -> m.getName().contains("expPrint"))); + assertNotEquals(tb.addr(0), Objects.requireNonNull(modExpPrint.getBase())); } } @@ -1203,17 +1178,17 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testPutThreads() throws Exception { runThrowError(addr -> """ %s - ghidra_trace_connect %s - file bash + ghidra trace connect %s + file %s process launch --stop-at-entry - ghidra_trace_start - ghidra_trace_txstart "Tx" - ghidra_trace_put_threads - ghidra_trace_txcommit + ghidra trace start + ghidra trace tx-start "Tx" + ghidra trace put-threads + ghidra trace tx-commit kill quit - """.formatted(PREAMBLE, addr)); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + """.formatted(PREAMBLE, addr, getSpecimenPrint())); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); // Would be nice to control / validate the specifics Unique.assertOne(tb.trace.getThreadManager().getAllThreads()); @@ -1222,33 +1197,33 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { @Test public void testPutFrames() throws Exception { - try (LldbAndConnection conn = startAndConnectLldb()) { - conn.execute("file bash"); - conn.execute("ghidra_trace_start"); - conn.execute("ghidra_trace_txstart 'Tx'"); - conn.execute("ghidra_trace_put_processes"); - conn.execute("ghidra_trace_txcommit"); - conn.execute("ghidra_trace_install_hooks"); - conn.execute("breakpoint set -n read"); - conn.execute("run"); + // Cheat a little by switching to synchronous mode + runThrowError(addr -> """ + %s + ghidra trace connect %s + file %s + process launch --stop-at-entry + breakpoint set -n puts + script lldb.debugger.SetAsync(False) + continue + script lldb.debugger.SetAsync(True) + ghidra trace start + ghidra trace tx-start "Tx" + ghidra trace put-frames + ghidra trace tx-commit + kill + quit + """.formatted(PREAMBLE, addr, getSpecimenPrint())); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { - tb = new ToyDBTraceBuilder((Trace) mdo.get()); - - waitStopped(); - conn.execute("ghidra_trace_txstart 'Tx'"); - conn.execute("ghidra_trace_put_frames"); - conn.execute("ghidra_trace_txcommit"); - conn.execute("kill"); - conn.execute("quit"); - // Would be nice to control / validate the specifics - List stack = tb.trace.getObjectManager() - .getValuePaths(Lifespan.at(0), - PathPredicates.parse("Processes[].Threads[].Stack[]")) - .map(p -> p.getDestination(null)) - .toList(); - assertThat(stack.size(), greaterThan(2)); - } + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { + tb = new ToyDBTraceBuilder((Trace) mdo.get()); + // Would be nice to control / validate the specifics + List stack = tb.trace.getObjectManager() + .getValuePaths(Lifespan.at(0), + PathPredicates.parse("Processes[].Threads[].Stack[]")) + .map(p -> p.getDestination(null)) + .toList(); + assertThat(stack.size(), greaterThan(2)); } } @@ -1256,11 +1231,10 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest { public void testMinimal() throws Exception { Function scriptSupplier = addr -> """ %s - ghidra_trace_connect %s + ghidra trace connect %s """.formatted(PREAMBLE, addr); try (LldbAndConnection conn = startAndConnectLldb(scriptSupplier)) { conn.execute("script print('FINISHED')"); - conn.execute("quit"); } } } diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbHooksTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbHooksTest.java index fd47fb0954..703e3e582f 100644 --- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbHooksTest.java +++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbHooksTest.java @@ -15,7 +15,8 @@ */ package agent.lldb.rmi; -import static org.hamcrest.Matchers.*; +import static org.hamcrest.Matchers.greaterThan; +import static org.hamcrest.Matchers.instanceOf; import static org.junit.Assert.*; import java.nio.ByteBuffer; @@ -41,7 +42,7 @@ import ghidra.trace.model.time.TraceSnapshot; @Category(NightlyCategory.class) // this may actually be an @PortSensitive test public class LldbHooksTest extends AbstractLldbTraceRmiTest { - private static final long RUN_TIMEOUT_MS = 20000; + private static final long RUN_TIMEOUT_MS = 5000; private static final long RETRY_MS = 500; record LldbAndTrace(LldbAndConnection conn, ManagedDomainObject mdo) implements AutoCloseable { @@ -64,10 +65,7 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest { protected LldbAndTrace startAndSyncLldb() throws Exception { LldbAndConnection conn = startAndConnectLldb(); try { - // TODO: Why does using 'set arch' cause a hang at quit? - conn.execute( - "ghidralldb.util.set_convenience_variable('ghidra-language', 'x86:LE:64:default')"); - conn.execute("ghidra_trace_start"); + conn.execute("ghidra trace start"); ManagedDomainObject mdo = waitDomainObject("/New Traces/lldb/noname"); tb = new ToyDBTraceBuilder((Trace) mdo.get()); return new LldbAndTrace(conn, mdo); @@ -102,7 +100,7 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest { RUN_TIMEOUT_MS, RETRY_MS); conn.execute("continue"); - waitStopped(); + waitStopped(conn.conn); txPut(conn, "threads"); waitForPass(() -> assertEquals(2, tb.objValues(lastSnap(conn), "Processes[].Threads[]").size()), @@ -131,7 +129,7 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest { RUN_TIMEOUT_MS, RETRY_MS); conn.execute("continue"); - waitStopped(); + waitStopped(conn.conn); waitForPass(() -> { TraceObject inf = tb.objAny("Processes[]"); assertNotNull(inf); @@ -207,11 +205,11 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest { try (LldbAndTrace conn = startAndSyncLldb()) { traceManager.openTrace(tb.trace); - start(conn, "bash"); - conn.execute("breakpoint set -n read"); + start(conn, getSpecimenPrint()); + conn.execute("breakpoint set -n puts"); conn.execute("cont"); - waitStopped(); + waitStopped(conn.conn); waitForPass(() -> assertThat( tb.objValues(lastSnap(conn), "Processes[].Threads[].Stack[]").size(), greaterThan(2)), @@ -224,6 +222,8 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest { conn.execute("frame select 0"); waitForPass(() -> assertEquals("0", frameIndex(traceManager.getCurrentObject())), RUN_TIMEOUT_MS, RETRY_MS); + + conn.execute("kill"); } } @@ -234,16 +234,16 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest { // FWIW, I've already seen this getting exercised in other tests. } - @Test + //@Test // LLDB does not provide the necessary events public void testOnMemoryChanged() throws Exception { try (LldbAndTrace conn = startAndSyncLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); long address = Long.decode(conn.executeCapture("dis -c1 -n main").split("\\s+")[1]); conn.execute("expr *((char*)(void(*)())main) = 0x7f"); - conn.execute("ghidra_trace_txstart 'Tx'"); - conn.execute("ghidra_trace_putmem `(void(*)())main` 10"); - conn.execute("ghidra_trace_txcommit"); + //conn.execute("ghidra trace tx-start 'Tx'"); + //conn.execute("ghidra trace putmem '(void(*)())main' 10"); + //conn.execute("ghidra trace tx-commit"); waitForPass(() -> { ByteBuffer buf = ByteBuffer.allocate(10); @@ -253,15 +253,15 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest { } } - @Test + //@Test // LLDB does not provide the necessary events public void testOnRegisterChanged() throws Exception { try (LldbAndTrace conn = startAndSyncLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); - conn.execute("expr $rax = 0x1234"); - conn.execute("ghidra_trace_txstart 'Tx'"); - conn.execute("ghidra_trace_putreg"); - conn.execute("ghidra_trace_txcommit"); + conn.execute("expr $%s = 0x1234".formatted(PLAT.intReg())); + //conn.execute("ghidra trace tx-start 'Tx'"); + //conn.execute("ghidra trace putreg"); + //conn.execute("ghidra trace tx-commit"); String path = "Processes[].Threads[].Stack[].Registers"; TraceObject registers = Objects.requireNonNull(tb.objAny(path, Lifespan.at(0))); @@ -269,29 +269,33 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest { .getAddressSpace(registers.getCanonicalPath().toString()); TraceMemorySpace regs = tb.trace.getMemoryManager().getMemorySpace(space, false); waitForPass(() -> assertEquals("1234", - regs.getValue(lastSnap(conn), tb.reg("RAX")).getUnsignedValue().toString(16))); + regs.getValue(lastSnap(conn), tb.reg(PLAT.intReg())) + .getUnsignedValue() + .toString(16))); } } @Test public void testOnCont() throws Exception { try (LldbAndTrace conn = startAndSyncLldb()) { - start(conn, "bash"); + start(conn, getSpecimenRead()); conn.execute("cont"); - waitRunning(); + waitRunning(conn.conn); TraceObject proc = waitForValue(() -> tb.objAny("Processes[]")); waitForPass(() -> { assertEquals("RUNNING", tb.objValue(proc, lastSnap(conn), "_state")); }, RUN_TIMEOUT_MS, RETRY_MS); + + conn.execute("process interrupt"); } } @Test public void testOnStop() throws Exception { try (LldbAndTrace conn = startAndSyncLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); TraceObject inf = waitForValue(() -> tb.objAny("Processes[]")); waitForPass(() -> { @@ -303,25 +307,22 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest { @Test public void testOnExited() throws Exception { try (LldbAndTrace conn = startAndSyncLldb()) { - conn.execute("file bash"); - conn.execute("ghidra_trace_sync_enable"); - conn.execute("process launch --stop-at-entry -- -c 'exit 1'"); - txPut(conn, "processes"); + start(conn, getSpecimenPrint()); conn.execute("cont"); - waitRunning(); + waitRunning(conn.conn); waitForPass(() -> { TraceSnapshot snapshot = tb.trace.getTimeManager().getSnapshot(lastSnap(conn), false); assertNotNull(snapshot); - assertEquals("Exited with code 1", snapshot.getDescription()); + assertEquals("Exited with code 72", snapshot.getDescription()); TraceObject proc = tb.objAny("Processes[]"); assertNotNull(proc); Object val = tb.objValue(proc, lastSnap(conn), "_exit_code"); assertThat(val, instanceOf(Number.class)); - assertEquals(1, ((Number) val).longValue()); + assertEquals(72, ((Number) val).longValue()); }, RUN_TIMEOUT_MS, RETRY_MS); } } @@ -329,7 +330,7 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest { @Test public void testOnBreakpointCreated() throws Exception { try (LldbAndTrace conn = startAndSyncLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); assertEquals(0, tb.objValues(lastSnap(conn), "Processes[].Breakpoints[]").size()); conn.execute("breakpoint set -n main"); @@ -346,9 +347,10 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest { @Test public void testOnBreakpointModified() throws Exception { try (LldbAndTrace conn = startAndSyncLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); assertEquals(0, tb.objValues(lastSnap(conn), "Breakpoints[]").size()); + //conn.execute("script lldb.debugger.SetAsync(False)"); conn.execute("breakpoint set -n main"); conn.execute("stepi"); TraceObject brk = waitForPass(() -> { @@ -357,6 +359,8 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest { return (TraceObject) brks.get(0); }); assertEquals(null, tb.objValue(brk, lastSnap(conn), "Condition")); + + waitStopped(conn.conn); conn.execute("breakpoint modify -c 'x>3'"); conn.execute("stepi"); // NB: Testing "Commands" requires multi-line input - not clear how to do this @@ -372,7 +376,7 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest { @Test public void testOnBreakpointDeleted() throws Exception { try (LldbAndTrace conn = startAndSyncLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); assertEquals(0, tb.objValues(lastSnap(conn), "Processes[].Breakpoints[]").size()); conn.execute("breakpoint set -n main"); @@ -384,6 +388,7 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest { return (TraceObject) brks.get(0); }); + waitStopped(conn.conn); conn.execute("breakpoint delete %s".formatted(brk.getCanonicalPath().index())); conn.execute("stepi"); @@ -395,15 +400,15 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest { private void start(LldbAndTrace conn, String obj) { conn.execute("file " + obj); - conn.execute("ghidra_trace_sync_enable"); + conn.execute("ghidra trace sync-enable"); conn.execute("process launch --stop-at-entry"); txPut(conn, "processes"); } private void txPut(LldbAndTrace conn, String obj) { - conn.execute("ghidra_trace_txstart 'Tx" + obj + "'"); - conn.execute("ghidra_trace_put_" + obj); - conn.execute("ghidra_trace_txcommit"); + conn.execute("ghidra trace tx-start 'Tx" + obj + "'"); + conn.execute("ghidra trace put-" + obj); + conn.execute("ghidra trace tx-commit"); } } diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbMethodsTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbMethodsTest.java index aae6054dd4..7ea4ea4e47 100644 --- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbMethodsTest.java +++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbMethodsTest.java @@ -18,9 +18,11 @@ package agent.lldb.rmi; import static org.hamcrest.Matchers.containsString; import static org.hamcrest.Matchers.greaterThan; import static org.junit.Assert.*; +import static org.junit.Assume.assumeTrue; import java.util.*; +import org.hamcrest.Matchers; import org.junit.Test; import org.junit.experimental.categories.Category; @@ -31,6 +33,7 @@ import ghidra.dbg.testutil.DummyProc; import ghidra.dbg.util.PathPattern; import ghidra.dbg.util.PathPredicates; import ghidra.debug.api.tracermi.RemoteMethod; +import ghidra.framework.OperatingSystem; import ghidra.program.model.address.*; import ghidra.program.model.lang.RegisterValue; import ghidra.trace.database.ToyDBTraceBuilder; @@ -59,10 +62,10 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testExecute() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); conn.execute("kill"); } - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { // Just confirm it's present } } @@ -70,7 +73,7 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testRefreshAvailable() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - conn.execute("ghidra_trace_start"); + conn.execute("ghidra trace start"); txCreate(conn, "Available"); RemoteMethod refreshAvailable = conn.getMethod("refresh_available"); @@ -93,13 +96,13 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testRefreshBreakpoints() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod refreshBreakpoints = conn.getMethod("refresh_breakpoints"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - //waitStopped(); + //waitStopped(conn); conn.execute("breakpoint set --name main"); conn.execute("breakpoint set -H --name main"); @@ -132,14 +135,14 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testRefreshProcBreakpoints() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); txPut(conn, "breakpoints"); RemoteMethod refreshProcBreakpoints = conn.getMethod("refresh_proc_breakpoints"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); TraceObject locations = Objects.requireNonNull(tb.objAny("Processes[].Breakpoints")); @@ -171,19 +174,20 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testRefreshProcWatchpoints() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "all"); RemoteMethod refreshProcWatchpoints = conn.getMethod("refresh_proc_watchpoints"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); TraceObject locations = Objects.requireNonNull(tb.objAny("Processes[].Watchpoints")); - conn.execute("watchpoint set expression -- `(void(*)())main`"); - conn.execute("watchpoint set expression -w read -- `(void(*)())main`+-0x20"); - conn.execute("watchpoint set expression -w read_write -- `(void(*)())main`+0x30"); + conn.execute("watchpoint set expression -s 1 -- `(void(*)())main`"); + conn.execute("watchpoint set expression -s 1 -w read -- `(void(*)())main`+-0x20"); + conn.execute( + "watchpoint set expression -s 1 -w read_write -- `(void(*)())main`+0x30"); refreshProcWatchpoints.invoke(Map.of("node", locations)); List procWatchLocVals = tb.trace.getObjectManager() @@ -219,7 +223,7 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testRefreshProcesses() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - conn.execute("ghidra_trace_start"); + conn.execute("ghidra trace start"); txCreate(conn, "Processes"); txCreate(conn, "Processes[1]"); @@ -244,21 +248,20 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { public void testRefreshEnvironment() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { String path = "Processes[].Environment"; - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "all"); RemoteMethod refreshEnvironment = conn.getMethod("refresh_environment"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); TraceObject env = Objects.requireNonNull(tb.objAny(path)); refreshEnvironment.invoke(Map.of("node", env)); - // Assumes LLDB on Linux amd64 assertEquals("lldb", env.getValue(0, "_debugger").getValue()); - assertEquals("x86_64", env.getValue(0, "_arch").getValue()); - assertEquals("linux", env.getValue(0, "_os").getValue()); - assertEquals("little", env.getValue(0, "_endian").getValue()); + assertEquals(PLAT.name(), env.getValue(0, "_arch").getValue()); + assertLocalOs(env.getValue(0, "_os").castValue()); + assertEquals(PLAT.endian(), env.getValue(0, "_endian").getValue()); } } } @@ -267,11 +270,11 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { public void testRefreshThreads() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { String path = "Processes[].Threads"; - start(conn, "bash"); + start(conn, getSpecimenPrint()); txCreate(conn, path); RemoteMethod refreshThreads = conn.getMethod("refresh_threads"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); TraceObject threads = Objects.requireNonNull(tb.objAny(path)); @@ -287,15 +290,16 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { public void testRefreshStack() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { String path = "Processes[].Threads[].Stack"; - conn.execute("file bash"); - conn.execute("ghidra_trace_start"); + conn.execute("file " + getSpecimenPrint()); + conn.execute("ghidra trace start"); txPut(conn, "processes"); - breakAt(conn, "read"); + breakAt(conn, "puts"); RemoteMethod refreshStack = conn.getMethod("refresh_stack"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); + waitTxDone(); txPut(conn, "frames"); TraceObject stack = Objects.requireNonNull(tb.objAny(path)); @@ -316,16 +320,16 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { public void testRefreshRegisters() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { String path = "Processes[].Threads[].Stack[].Registers"; - start(conn, "bash"); - conn.execute("ghidra_trace_txstart 'Tx'"); - conn.execute("ghidra_trace_putreg"); - conn.execute("ghidra_trace_txcommit"); + start(conn, getSpecimenPrint()); + conn.execute("ghidra trace tx-start 'Tx'"); + conn.execute("ghidra trace putreg"); + conn.execute("ghidra trace tx-commit"); RemoteMethod refreshRegisters = conn.getMethod("refresh_registers"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - conn.execute("expr $rax = 0xdeadbeef"); + conn.execute("expr $%s = 0xdeadbeef".formatted(PLAT.intReg())); TraceObject registers = Objects.requireNonNull(tb.objAny(path, Lifespan.at(0))); refreshRegisters.invoke(Map.of("node", registers)); @@ -334,9 +338,9 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { AddressSpace t1f0 = tb.trace.getBaseAddressFactory() .getAddressSpace(registers.getCanonicalPath().toString()); TraceMemorySpace regs = tb.trace.getMemoryManager().getMemorySpace(t1f0, false); - RegisterValue rax = regs.getValue(snap, tb.reg("rax")); + RegisterValue intRegVal = regs.getValue(snap, tb.reg(PLAT.intReg())); // LLDB treats registers in arch's endian - assertEquals("deadbeef", rax.getUnsignedValue().toString(16)); + assertEquals("deadbeef", intRegVal.getUnsignedValue().toString(16)); } } } @@ -345,11 +349,11 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { public void testRefreshMappings() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { String path = "Processes[].Memory"; - start(conn, "bash"); + start(conn, getSpecimenPrint()); txCreate(conn, path); RemoteMethod refreshMappings = conn.getMethod("refresh_mappings"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); TraceObject memory = Objects.requireNonNull(tb.objAny(path)); @@ -367,11 +371,11 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { public void testRefreshModules() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { String path = "Processes[].Modules"; - start(conn, "bash"); + start(conn, getSpecimenPrint()); txCreate(conn, path); RemoteMethod refreshModules = conn.getMethod("refresh_modules"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); TraceObject modules = Objects.requireNonNull(tb.objAny(path)); @@ -379,27 +383,30 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { // Would be nice to control / validate the specifics Collection all = tb.trace.getModuleManager().getAllModules(); - TraceModule modBash = - Unique.assertOne(all.stream().filter(m -> m.getName().contains("bash"))); - assertNotEquals(tb.addr(0), Objects.requireNonNull(modBash.getBase())); + TraceModule modExpPrint = Unique.assertOne( + all.stream().filter(m -> m.getName().contains("expPrint"))); + assertNotEquals(tb.addr(0), Objects.requireNonNull(modExpPrint.getBase())); } } } @Test public void testActivateThread() throws Exception { + // This test crashes lldb-1500.0.404.7 on macOS arm64 + assumeTrue(OperatingSystem.CURRENT_OPERATING_SYSTEM == OperatingSystem.LINUX); try (LldbAndConnection conn = startAndConnectLldb()) { // TODO: need to find this file (same issue in LldbHookTests String dproc = DummyProc.which("expCloneExit"); conn.execute("file " + dproc); - conn.execute("ghidra_trace_start"); + conn.execute("ghidra trace start"); txPut(conn, "processes"); breakAt(conn, "work"); RemoteMethod activateThread = conn.getMethod("activate_thread"); try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expCloneExit")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); + waitTxDone(); txPut(conn, "threads"); @@ -415,7 +422,10 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { activateThread.invoke(Map.of("thread", t)); String out = conn.executeCapture("thread info"); List indices = pattern.matchKeys(t.getCanonicalPath().getKeyList()); - assertThat(out, containsString("tid = %s".formatted(indices.get(1)))); + long index = Long.decode(indices.get(1)); + assertThat(out, Matchers + .either(containsString("tid = %s".formatted(index))) + .or(containsString("tid = 0x%x".formatted(index)))); } } } @@ -424,15 +434,16 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testActivateFrame() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - conn.execute("file bash"); - conn.execute("ghidra_trace_start"); + conn.execute("file " + getSpecimenPrint()); + conn.execute("ghidra trace start"); txPut(conn, "processes"); - breakAt(conn, "read"); + breakAt(conn, "puts"); RemoteMethod activateFrame = conn.getMethod("activate_frame"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); + waitTxDone(); txPut(conn, "frames"); @@ -456,11 +467,11 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testRemoveProcess() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod removeProcess = conn.getMethod("remove_process"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); TraceObject proc2 = Objects.requireNonNull(tb.objAny("Processes[]")); @@ -474,10 +485,12 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testAttachObj() throws Exception { + // Missing specimen for macOS + assumeTrue(OperatingSystem.CURRENT_OPERATING_SYSTEM == OperatingSystem.LINUX); String sleep = DummyProc.which("expTraceableSleep"); try (DummyProc dproc = DummyProc.run(sleep)) { try (LldbAndConnection conn = startAndConnectLldb()) { - conn.execute("ghidra_trace_start"); + conn.execute("ghidra trace start"); txPut(conn, "available"); txPut(conn, "processes"); @@ -499,10 +512,12 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testAttachPid() throws Exception { + // Missing specimen for macOS + assumeTrue(OperatingSystem.CURRENT_OPERATING_SYSTEM == OperatingSystem.LINUX); String sleep = DummyProc.which("expTraceableSleep"); try (DummyProc dproc = DummyProc.run(sleep)) { try (LldbAndConnection conn = startAndConnectLldb()) { - conn.execute("ghidra_trace_start"); + conn.execute("ghidra trace start"); txPut(conn, "processes"); RemoteMethod attachPid = conn.getMethod("attach_pid"); @@ -522,12 +537,12 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testDetach() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); //conn.execute("process attach -p %d".formatted(dproc.pid)); RemoteMethod detach = conn.getMethod("detach"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); TraceObject proc = Objects.requireNonNull(tb.objAny("Processes[]")); @@ -543,7 +558,7 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testLaunchEntry() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - conn.execute("ghidra_trace_start"); + conn.execute("ghidra trace start"); txPut(conn, "processes"); RemoteMethod launch = conn.getMethod("launch_loader"); @@ -553,11 +568,11 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { TraceObject proc = Objects.requireNonNull(tb.objAny("Processes[]")); launch.invoke(Map.ofEntries( Map.entry("process", proc), - Map.entry("file", "bash"))); - waitStopped(); + Map.entry("file", getSpecimenPrint()))); + waitStopped(conn); String out = conn.executeCapture("target list"); - assertThat(out, containsString("bash")); + assertThat(out, containsString(getSpecimenPrint())); } } } @@ -565,7 +580,7 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test //Not clear how to send interrupt public void testLaunch() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - conn.execute("ghidra_trace_start"); + conn.execute("ghidra trace start"); txPut(conn, "processes"); RemoteMethod launch = conn.getMethod("launch"); @@ -575,17 +590,17 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { TraceObject proc = Objects.requireNonNull(tb.objAny("Processes[]")); launch.invoke(Map.ofEntries( Map.entry("process", proc), - Map.entry("file", "bash"))); + Map.entry("file", getSpecimenRead()))); txPut(conn, "processes"); - waitRunning(); + waitRunning(conn); Thread.sleep(100); // Give it plenty of time to block on read conn.execute("process interrupt"); txPut(conn, "processes"); - waitStopped(); + waitStopped(conn); String out = conn.executeCapture("bt"); assertThat(out, containsString("read")); @@ -596,13 +611,13 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testKill() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod kill = conn.getMethod("kill"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); TraceObject proc = Objects.requireNonNull(tb.objAny("Processes[]")); kill.invoke(Map.of("process", proc)); @@ -613,95 +628,123 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { } } + protected void stepToCall(LldbAndConnection conn, RemoteMethod step, TraceObject thread) + throws InterruptedException { + while (true) { + String dis = conn.executeCapture("dis -c1 -s '$pc'"); + if (dis.contains(PLAT.callMne())) { + return; + } + step.invoke(Map.of("thread", thread)); + } + } + + record FoundHex(int idx, long value) { + static FoundHex findHex(List tokens, int start) { + for (int i = start; i < tokens.size(); i++) { + String tok = tokens.get(i); + if (tok.startsWith("0x")) { + return new FoundHex(i, Long.decode(tok)); + } + } + throw new AssertionError("Could not find 0x"); + } + } + + record CallInstr(long next, long target) { + static CallInstr parse(String dis2) { + List tokens = List.of(dis2.split("\\s+")); + int mneIndex = tokens.indexOf(PLAT.callMne()); + assertNotEquals("Could not find " + PLAT.callMne(), -1, mneIndex); + FoundHex target = FoundHex.findHex(tokens, mneIndex + 1); + FoundHex next = FoundHex.findHex(tokens, target.idx + 1); + return new CallInstr(next.value, target.value); + } + } + @Test public void testStepInto() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod step_into = conn.getMethod("step_into"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); + waitTxDone(); + txPut(conn, "threads"); + conn.execute("script lldb.debugger.SetAsync(False)"); TraceObject thread = Objects.requireNonNull(tb.objAny("Processes[].Threads[]")); - - while (!conn.executeCapture("dis -c1 -s '$pc'").contains("call")) { - step_into.invoke(Map.of("thread", thread)); - } + stepToCall(conn, step_into, thread); String dis2 = conn.executeCapture("dis -c2 -s '$pc'"); - // lab0: - // -> addr0 - // - // lab1: - // addr1 - long pcNext = Long.decode(dis2.strip().split("\n")[4].strip().split("\\s+")[0]); + CallInstr instr = CallInstr.parse(dis2); step_into.invoke(Map.of("thread", thread)); String disAt = conn.executeCapture("dis -c1 -s '$pc'"); - long pc = Long.decode(disAt.strip().split("\n")[1].strip().split("\\s+")[1]); - assertNotEquals(pcNext, pc); + FoundHex pc = FoundHex.findHex(List.of(disAt.split("\\s+")), 0); + assertEquals(instr.target, pc.value); } } } - @Test + //@Test // Debug information required (at least on macOS arm64) public void testStepOver() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - conn.execute("file bash"); - conn.execute("ghidra_trace_start"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); - breakAt(conn, "read"); RemoteMethod step_over = conn.getMethod("step_over"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); txPut(conn, "threads"); + conn.execute("script lldb.debugger.SetAsync(False)"); TraceObject thread = Objects.requireNonNull(tb.objAny("Processes[].Threads[]")); - - while (!conn.executeCapture("dis -c1 -s '$pc'").contains("call")) { - step_over.invoke(Map.of("thread", thread)); - } + stepToCall(conn, step_over, thread); String dis2 = conn.executeCapture("dis -c2 -s '$pc'"); - // lab0: - // -> addr0 - // addr1 - long pcNext = Long.decode(dis2.strip().split("\n")[2].strip().split("\\s+")[0]); + System.err.println(dis2); + CallInstr instr = CallInstr.parse(dis2); + // This winds up a step_into if lldb can't place its breakpoint step_over.invoke(Map.of("thread", thread)); String disAt = conn.executeCapture("dis -c1 -s '$pc'"); - long pc = Long.decode(disAt.strip().split("\n")[1].strip().split("\\s+")[1]); - assertEquals(pcNext, pc); + FoundHex pc = FoundHex.findHex(List.of(disAt.split("\\s+")), 0); + assertEquals(instr.next, pc.value); } } } - //@Test Not obvious "thread until -a" works (and definitely requires debug info") - public void testAdvance() throws Exception { + //@Test // Debug information required + public void testStepAdvance() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); + txPut(conn, "processes"); - RemoteMethod step_ext = conn.getMethod("step_ext"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + RemoteMethod step_advance = conn.getMethod("step_advance"); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - //waitStopped(); + waitStopped(conn); txPut(conn, "threads"); + conn.execute("script lldb.debugger.SetAsync(False)"); TraceObject thread = Objects.requireNonNull(tb.objAny("Processes[].Threads[]")); String dis3 = conn.executeCapture("disassemble -c3 -s '$pc'"); // TODO: Examine for control transfer? - long pcTarget = Long.decode(dis3.strip().split("\n")[2].strip().split("\\s+")[0]); + List lines = List.of(dis3.split("\n")); + String last = lines.get(lines.size() - 1); + FoundHex addr = FoundHex.findHex(List.of(last.split("\\s+")), 0); - step_ext.invoke(Map.of("thread", thread, "address", tb.addr(pcTarget))); + step_advance.invoke(Map.of("thread", thread, "address", tb.addr(addr.value))); - String dis1 = conn.executeCapture("disassemble -c1 -s '$pc'"); - long pc = Long.decode(dis1.strip().split("\n")[1].strip().split("\\s+")[1]); - assertEquals(pcTarget, pc); + String disAt = conn.executeCapture("disassemble -c1 -s '$pc'"); + FoundHex pc = FoundHex.findHex(List.of(disAt.split("\\s+")), 0); + assertEquals(addr.value, pc); } } } @@ -709,16 +752,18 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testFinish() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - conn.execute("file bash"); - conn.execute("ghidra_trace_start"); + conn.execute("file " + getSpecimenPrint()); + conn.execute("ghidra trace start"); txPut(conn, "processes"); - breakAt(conn, "read"); + breakAt(conn, "puts"); RemoteMethod activate = conn.getMethod("activate_thread"); RemoteMethod step_out = conn.getMethod("step_out"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); + waitTxDone(); + txPut(conn, "threads"); TraceObject thread = Objects.requireNonNull(tb.objAny("Processes[].Threads[]")); @@ -735,18 +780,20 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { } @Test - public void testReturn() throws Exception { + public void testStepReturn() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - conn.execute("file bash"); - conn.execute("ghidra_trace_start"); + conn.execute("file " + getSpecimenPrint()); + conn.execute("ghidra trace start"); txPut(conn, "processes"); - breakAt(conn, "read"); + breakAt(conn, "puts"); RemoteMethod activate = conn.getMethod("activate_thread"); - RemoteMethod ret = conn.getMethod("return"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + RemoteMethod ret = conn.getMethod("step_return"); + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); + waitTxDone(); + txPut(conn, "threads"); TraceObject thread = Objects.requireNonNull(tb.objAny("Processes[].Threads[]")); @@ -765,11 +812,11 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testBreakAddress() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod breakAddress = conn.getMethod("break_address"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); TraceObject proc = Objects.requireNonNull(tb.objAny("Processes[]")); @@ -786,13 +833,13 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testBreakExpression() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod breakExpression = conn.getMethod("break_expression"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); breakExpression.invoke(Map.of("expression", "main")); @@ -806,13 +853,13 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { // Are hardware breakpoints available on our VMs? public void testBreakHardwareAddress() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod breakAddress = conn.getMethod("break_hw_address"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); TraceObject proc = Objects.requireNonNull(tb.objAny("Processes[]")); long address = Long.decode(conn.executeCapture("dis -c1 -n main").split("\\s+")[1]); @@ -827,13 +874,13 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { //@Test There appear to be issues with hardware register availability in our virtual environments public void testBreakHardwareExpression() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod breakExpression = conn.getMethod("break_hw_expression"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); breakExpression.invoke(Map.of("expression", "`(void(*)())main`")); @@ -848,22 +895,22 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testBreakReadRange() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod breakRange = conn.getMethod("break_read_range"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); TraceObject proc = Objects.requireNonNull(tb.objAny("Processes[]")); long address = Long.decode(conn.executeCapture("dis -c1 -n main").split("\\s+")[1]); - AddressRange range = tb.range(address, address + 3); // length 4 + AddressRange range = tb.range(address, address + 0); // length 1 breakRange.invoke(Map.of("process", proc, "range", range)); String out = conn.executeCapture("watchpoint list"); assertThat(out, containsString("0x%x".formatted(address))); - assertThat(out, containsString("size = 4")); + assertThat(out, containsString("size = 1")); assertThat(out, containsString("type = r")); } } @@ -872,14 +919,16 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testBreakReadExpression() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod breakExpression = conn.getMethod("break_read_expression"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - breakExpression.invoke(Map.of("expression", "`(void(*)())main`")); + breakExpression.invoke(Map.of( + "expression", "`(void(*)())main`", + "size", 1)); long address = Long.decode(conn.executeCapture("dis -c1 -n main").split("\\s+")[1]); String out = conn.executeCapture("watchpoint list"); @@ -892,22 +941,22 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testBreakWriteRange() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod breakRange = conn.getMethod("break_write_range"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); TraceObject proc = Objects.requireNonNull(tb.objAny("Processes[]")); long address = Long.decode(conn.executeCapture("dis -c1 -n main").split("\\s+")[1]); - AddressRange range = tb.range(address, address + 3); // length 4 + AddressRange range = tb.range(address, address + 0); // length 1 breakRange.invoke(Map.of("process", proc, "range", range)); String out = conn.executeCapture("watchpoint list"); assertThat(out, containsString("0x%x".formatted(address))); - assertThat(out, containsString("size = 4")); + assertThat(out, containsString("size = 1")); assertThat(out, containsString("type = w")); } } @@ -916,14 +965,16 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testBreakWriteExpression() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod breakExpression = conn.getMethod("break_write_expression"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - breakExpression.invoke(Map.of("expression", "`(void(*)())main`")); + breakExpression.invoke(Map.of( + "expression", "`(void(*)())main`", + "size", 1)); long address = Long.decode(conn.executeCapture("dis -c1 -n main").split("\\s+")[1]); String out = conn.executeCapture("watchpoint list"); @@ -936,22 +987,22 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testBreakAccessRange() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod breakRange = conn.getMethod("break_access_range"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); TraceObject proc = Objects.requireNonNull(tb.objAny("Processes[]")); long address = Long.decode(conn.executeCapture("dis -c1 -n main").split("\\s+")[1]); - AddressRange range = tb.range(address, address + 3); // length 4 + AddressRange range = tb.range(address, address + 0); // length 1 breakRange.invoke(Map.of("process", proc, "range", range)); String out = conn.executeCapture("watchpoint list"); assertThat(out, containsString("0x%x".formatted(address))); - assertThat(out, containsString("size = 4")); + assertThat(out, containsString("size = 1")); assertThat(out, containsString("type = rw")); } } @@ -960,14 +1011,16 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testBreakAccessExpression() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod breakExpression = conn.getMethod("break_access_expression"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - breakExpression.invoke(Map.of("expression", "`(void(*)())main`")); + breakExpression.invoke(Map.of( + "expression", "`(void(*)())main`", + "size", 1)); long address = Long.decode(conn.executeCapture("dis -c1 -n main").split("\\s+")[1]); String out = conn.executeCapture("watchpoint list"); @@ -981,11 +1034,11 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testBreakException() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod breakExc = conn.getMethod("break_exception"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); breakExc.invoke(Map.of("lang", "C++")); @@ -1000,16 +1053,15 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testToggleBreakpoint() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - conn.execute("file bash"); - conn.execute("ghidra_trace_start"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); - breakAt(conn, "main"); RemoteMethod toggleBreakpoint = conn.getMethod("toggle_breakpoint"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); + conn.execute("breakpoint set -n main"); txPut(conn, "breakpoints"); TraceObject bpt = Objects.requireNonNull(tb.objAny("Breakpoints[]")); @@ -1024,19 +1076,17 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testToggleBreakpointLocation() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - conn.execute("file bash"); - conn.execute("ghidra_trace_start"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); - breakAt(conn, "main"); RemoteMethod toggleBreakpointLocation = conn.getMethod("toggle_breakpoint_location"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); + conn.execute("breakpoint set -n main"); txPut(conn, "breakpoints"); - // NB. Requires canonical path. Inf[].Brk[] is a link TraceObject loc = Objects.requireNonNull(tb.objAny("Breakpoints[][]")); toggleBreakpointLocation.invoke(Map.of("location", loc, "enabled", false)); @@ -1050,16 +1100,15 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testDeleteBreakpoint() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - conn.execute("file bash"); - conn.execute("ghidra_trace_start"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); - breakAt(conn, "main"); RemoteMethod deleteBreakpoint = conn.getMethod("delete_breakpoint"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - waitStopped(); + waitStopped(conn); + conn.execute("breakpoint set -n main"); txPut(conn, "breakpoints"); TraceObject bpt = Objects.requireNonNull(tb.objAny("Breakpoints[]")); @@ -1074,15 +1123,17 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { @Test public void testDeleteWatchpoint() throws Exception { try (LldbAndConnection conn = startAndConnectLldb()) { - start(conn, "bash"); + start(conn, getSpecimenPrint()); txPut(conn, "processes"); RemoteMethod breakExpression = conn.getMethod("break_read_expression"); RemoteMethod deleteWatchpoint = conn.getMethod("delete_watchpoint"); - try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/bash")) { + try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/expPrint")) { tb = new ToyDBTraceBuilder((Trace) mdo.get()); - breakExpression.invoke(Map.of("expression", "`(void(*)())main`")); + breakExpression.invoke(Map.of( + "expression", "`(void(*)())main`", + "size", 1)); long address = Long.decode(conn.executeCapture("dis -c1 -n main").split("\\s+")[1]); String out = conn.executeCapture("watchpoint list"); @@ -1101,25 +1152,26 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest { private void start(LldbAndConnection conn, String obj) { conn.execute("file " + obj); - conn.execute("ghidra_trace_start"); + conn.execute("ghidra trace start"); conn.execute("process launch --stop-at-entry"); } private void txPut(LldbAndConnection conn, String obj) { - conn.execute("ghidra_trace_txstart 'Tx'"); - conn.execute("ghidra_trace_put_" + obj); - conn.execute("ghidra_trace_txcommit"); + conn.execute("ghidra trace tx-start 'Tx'"); + conn.execute("ghidra trace put-" + obj); + conn.execute("ghidra trace tx-commit"); } private void txCreate(LldbAndConnection conn, String path) { - conn.execute("ghidra_trace_txstart 'Fake'"); - conn.execute("ghidra_trace_create_obj %s".formatted(path)); - conn.execute("ghidra_trace_txcommit"); + conn.execute("ghidra trace tx-start 'Fake'"); + conn.execute("ghidra trace create-obj %s".formatted(path)); + conn.execute("ghidra trace tx-commit"); } private void breakAt(LldbAndConnection conn, String fn) { - conn.execute("ghidra_trace_sync_enable"); + conn.execute("ghidra trace sync-enable"); conn.execute("breakpoint set -n " + fn); + conn.execute("script lldb.debugger.SetAsync(False)"); conn.execute("run"); }