Skip to content

Ghidra is a software reverse engineering (SRE) framework

GP-6787: Add 'Emulate Function' action and dialog.

Dan427d857d516d
diff --git a/Ghidra/Debug/Debugger-api/src/main/java/ghidra/debug/api/modules/IdentityDebuggerAddressTranslator.java b/Ghidra/Debug/Debugger-api/src/main/java/ghidra/debug/api/modules/IdentityDebuggerAddressTranslator.java
new file mode 100644
index 0000000000..5393c02e0d
--- /dev/null
+++ b/Ghidra/Debug/Debugger-api/src/main/java/ghidra/debug/api/modules/IdentityDebuggerAddressTranslator.java
@@ -0,0 +1,95 @@
+/* ###
+ * 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.debug.api.modules;
+
+import java.net.URL;
+import java.util.*;
+
+import ghidra.program.model.address.AddressSetView;
+import ghidra.program.model.listing.Program;
+import ghidra.program.util.ProgramLocation;
+import ghidra.trace.model.*;
+import ghidra.trace.model.program.TraceProgramView;
+
+public class IdentityDebuggerAddressTranslator implements DebuggerAddressTranslator {
+ private final Trace trace;
+ private final Program program;
+
+ public IdentityDebuggerAddressTranslator(Trace trace, Program program) {
+ this.trace = trace;
+ this.program = program;
+ }
+
+ @Override
+ public Set<Program> getOpenMappedProgramsAtSnap(Trace trace, long snap) {
+ return Set.of(program);
+ }
+
+ @Override
+ public ProgramLocation getOpenMappedLocation(TraceLocation loc) {
+ return new ProgramLocation(program, loc.getAddress());
+ }
+
+ @Override
+ public ProgramLocation getStaticLocationFromDynamic(ProgramLocation loc) {
+ return new ProgramLocation(program, loc.getAddress());
+ }
+
+ @Override
+ public Set<TraceLocation> getOpenMappedLocations(ProgramLocation loc) {
+ return Set.of(new DefaultTraceLocation(trace, null, Lifespan.ALL, loc.getAddress()));
+ }
+
+ @Override
+ public TraceLocation getOpenMappedLocation(Trace trace, ProgramLocation loc, long snap) {
+ if (trace != this.trace) {
+ return null;
+ }
+ return new DefaultTraceLocation(trace, null, Lifespan.ALL, loc.getAddress());
+ }
+
+ @Override
+ public ProgramLocation getDynamicLocationFromStatic(TraceProgramView view,
+ ProgramLocation loc) {
+ if (view.getTrace() != this.trace) {
+ return null;
+ }
+ return new ProgramLocation(view, loc.getAddress());
+ }
+
+ @Override
+ public Map<Program, Collection<MappedAddressRange>> getOpenMappedViews(Trace trace,
+ AddressSetView set, long snap) {
+ return Map.ofEntries(
+ Map.entry(program, set.stream().map(r -> new MappedAddressRange(r, r)).toList()));
+ }
+
+ @Override
+ public Map<TraceSpan, Collection<MappedAddressRange>> getOpenMappedViews(Program program,
+ AddressSetView set) {
+ if (program != this.program) {
+ return Map.of();
+ }
+ return Map.ofEntries(Map.entry(new DefaultTraceSpan(trace, Lifespan.ALL),
+ set.stream().map(r -> new MappedAddressRange(r, r)).toList()));
+ }
+
+ @Override
+ public Set<URL> getMappedProgramUrlsInView(Trace trace, AddressSetView set, long snap) {
+ // This is not necessary here
+ return Set.of();
+ }
+}
diff --git a/Ghidra/Debug/Debugger-rmi-trace/src/main/java/ghidra/app/plugin/core/debug/gui/tracermi/connection/TraceRmiConnectionManagerProvider.java b/Ghidra/Debug/Debugger-rmi-trace/src/main/java/ghidra/app/plugin/core/debug/gui/tracermi/connection/TraceRmiConnectionManagerProvider.java
index 515a7306f6..ecc170c747 100644
--- a/Ghidra/Debug/Debugger-rmi-trace/src/main/java/ghidra/app/plugin/core/debug/gui/tracermi/connection/TraceRmiConnectionManagerProvider.java
+++ b/Ghidra/Debug/Debugger-rmi-trace/src/main/java/ghidra/app/plugin/core/debug/gui/tracermi/connection/TraceRmiConnectionManagerProvider.java
@@ -239,6 +239,10 @@ public class TraceRmiConnectionManagerProvider extends ComponentProviderAdapter
createActions();
}
+ public void cleanConnectionNode(TraceRmiConnectionNode node) {
+ rootNode.cleanConnectionNode(node);
+ }
+
private void buildMainPanel() {
mainPanel = new JPanel(new BorderLayout());
diff --git a/Ghidra/Debug/Debugger-rmi-trace/src/main/java/ghidra/app/plugin/core/debug/gui/tracermi/connection/tree/TraceRmiConnectionNode.java b/Ghidra/Debug/Debugger-rmi-trace/src/main/java/ghidra/app/plugin/core/debug/gui/tracermi/connection/tree/TraceRmiConnectionNode.java
index 5f6a5f61e3..e98c2d0f0b 100644
--- a/Ghidra/Debug/Debugger-rmi-trace/src/main/java/ghidra/app/plugin/core/debug/gui/tracermi/connection/tree/TraceRmiConnectionNode.java
+++ b/Ghidra/Debug/Debugger-rmi-trace/src/main/java/ghidra/app/plugin/core/debug/gui/tracermi/connection/tree/TraceRmiConnectionNode.java
@@ -42,7 +42,13 @@ public class TraceRmiConnectionNode extends AbstractTraceRmiManagerNode {
@Override
public String getDisplayText() {
- return connection.getDescription() + " at " + connection.getRemoteAddress();
+ try {
+ return connection.getDescription() + " at " + connection.getRemoteAddress();
+ }
+ catch (Exception e) {
+ provider.cleanConnectionNode(this);
+ return "Error: " + e;
+ }
}
@Override
@@ -52,8 +58,13 @@ public class TraceRmiConnectionNode extends AbstractTraceRmiManagerNode {
@Override
public String getToolTip() {
- return "Trace RMI Connection to " + connection.getDescription() + " at " +
- connection.getRemoteAddress();
+ try {
+ return "Trace RMI Connection to " + connection.getDescription() + " at " +
+ connection.getRemoteAddress();
+ }
+ catch (Exception e) {
+ return "Error: " + e;
+ }
}
@Override
diff --git a/Ghidra/Debug/Debugger-rmi-trace/src/main/java/ghidra/app/plugin/core/debug/gui/tracermi/connection/tree/TraceRmiServiceNode.java b/Ghidra/Debug/Debugger-rmi-trace/src/main/java/ghidra/app/plugin/core/debug/gui/tracermi/connection/tree/TraceRmiServiceNode.java
index db3539667e..97045868eb 100644
--- a/Ghidra/Debug/Debugger-rmi-trace/src/main/java/ghidra/app/plugin/core/debug/gui/tracermi/connection/tree/TraceRmiServiceNode.java
+++ b/Ghidra/Debug/Debugger-rmi-trace/src/main/java/ghidra/app/plugin/core/debug/gui/tracermi/connection/tree/TraceRmiServiceNode.java
@@ -25,6 +25,7 @@ import ghidra.debug.api.target.Target;
import ghidra.debug.api.target.TargetPublicationListener;
import ghidra.debug.api.tracemgr.DebuggerCoordinates;
import ghidra.debug.api.tracermi.*;
+import ghidra.lifecycle.Internal;
import ghidra.util.Msg;
import ghidra.util.Swing;
@@ -83,6 +84,15 @@ public class TraceRmiServiceNode extends AbstractTraceRmiManagerNode
removeNode(node);
}
+ @Internal
+ public void cleanConnectionNode(TraceRmiConnectionNode node) {
+ TraceRmiConnection connection = node.getConnection();
+ synchronized (connectionNodes) {
+ connectionNodes.remove(connection);
+ }
+ removeNode(node);
+ }
+
private TraceRmiAcceptorNode newAcceptorNode(TraceRmiAcceptor acceptor) {
return new TraceRmiAcceptorNode(provider, acceptor);
}
diff --git a/Ghidra/Debug/Debugger/certification.manifest b/Ghidra/Debug/Debugger/certification.manifest
index 96169f2e80..c25baeb7ac 100644
--- a/Ghidra/Debug/Debugger/certification.manifest
+++ b/Ghidra/Debug/Debugger/certification.manifest
@@ -26,6 +26,7 @@ src/main/help/help/topics/DebuggerCopyActionsPlugin/DebuggerCopyActionsPlugin.ht
src/main/help/help/topics/DebuggerCopyActionsPlugin/images/DebuggerCopyIntoProgramDialog.png||GHIDRA||||END|
src/main/help/help/topics/DebuggerDisassemblerPlugin/DebuggerDisassemblerPlugin.html||GHIDRA||||END|
src/main/help/help/topics/DebuggerEmulationServicePlugin/DebuggerEmulationServicePlugin.html||GHIDRA||||END|
+src/main/help/help/topics/DebuggerEmulationServicePlugin/images/DebuggerEmulateFunctionDialog.png||GHIDRA||||END|
src/main/help/help/topics/DebuggerListingPlugin/DebuggerListingPlugin.html||GHIDRA||||END|
src/main/help/help/topics/DebuggerListingPlugin/images/DebuggerGoToDialog.png||GHIDRA||||END|
src/main/help/help/topics/DebuggerListingPlugin/images/DebuggerListingPlugin.png||GHIDRA||||END|
diff --git a/Ghidra/Debug/Debugger/ghidra_scripts/ListAllKnownMemoryScript.java b/Ghidra/Debug/Debugger/ghidra_scripts/ListAllKnownMemoryScript.java
new file mode 100644
index 0000000000..70d13dab19
--- /dev/null
+++ b/Ghidra/Debug/Debugger/ghidra_scripts/ListAllKnownMemoryScript.java
@@ -0,0 +1,38 @@
+/* ###
+ * 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.
+ */
+import ghidra.app.script.GhidraScript;
+import ghidra.debug.flatapi.FlatDebuggerAPI;
+import ghidra.program.model.address.AddressSetView;
+import ghidra.trace.model.Trace;
+import ghidra.trace.model.memory.TraceMemoryOperations.StatePredicate;
+
+//List all address ranges that are "known" at the current snapshot
+//This script must be run from the Debugger tool, or another tool with the required plugins.
+//@category Debugger
+//@keybinding
+//@menupath
+//@toolbar
+public class ListAllKnownMemoryScript extends GhidraScript implements FlatDebuggerAPI {
+ @Override
+ protected void run() throws Exception {
+ Trace trace = requireCurrentTrace();
+ long snap = getCurrentSnap();
+
+ AddressSetView addresses =
+ trace.getMemoryManager().getAddressesWithState(snap, StatePredicate.IS_KNOWN);
+ show("Known Memory at %d".formatted(snap), addresses);
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerEmulationServicePlugin/DebuggerEmulationServicePlugin.html b/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerEmulationServicePlugin/DebuggerEmulationServicePlugin.html
index e8ea74094e..8651258391 100644
--- a/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerEmulationServicePlugin/DebuggerEmulationServicePlugin.html
+++ b/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerEmulationServicePlugin/DebuggerEmulationServicePlugin.html
@@ -48,6 +48,12 @@
Optionally, other registers can be initialized via the UI or a script. The new thread is
activated so that control actions will affect it by default.</P>
+ <H3><A name="emulate_function"></A> Emulate Function</H3>
+
+ <P>This action is available whenever the cursor is within a function in the Static Listing. It
+ displays a <A href="#emulate_function_dialog">dialog</A> for harnessing and emulating the
+ current function.</P>
+
<H3><A name="configure_emulator"></A> Configure Emulator</H3>
<P>This action is always available. It lists emulators available for configuration. Selecting
@@ -62,5 +68,188 @@
emulated breakpoint, or when you patch the trace database. If you do not invalidate the cache,
the effects of your change may not appear, since the trace manager may recall a cached snapshot
instead of actually emulating.</P>
+
+ <H2><A name="emulate_function_dialog"></A> Emulate Function Dialog</H2>
+
+ <P>This dialog provides a means of harnessing and emulating a target function. Depending on the
+ size and scope of the function and the configuration of the emulator, the emulation may or may
+ not complete. See further below for options and actions in the dialog.</P>
+
+ <DIV class="image">
+ <IMG alt="" src="images/DebuggerEmulateFunctionDialog.png">
+ </DIV>
+
+ <P>The dialog supports the addition of vararg arguments, custom initializations, and heap
+ initializations. All of these inputs are handled in the top table. The "Run" button will
+ perform the emulation and capture the outputs into the bottom table. Analogous to the inputs,
+ the Outputs table can be configured with custom variables and pointer dereferences. The
+ emulation session can optionally be captured into a trace, which is opened automatically in
+ your tool, usually the Debugger or Emulator. Multiple sessions can be run from the same dialog,
+ allowing trial-and-error runs while also iterating on the target function's markup.</P>
+
+ <H3>Option: Ending Return Address</H3>
+
+ <P>In order to detect the proper completion of the target function, the harness places a
+ breakpoint at a "sentinel" address. That sentinel address must be placed where the function
+ expects the return address. This option allows specification of the sentinel address.
+ Generally, anything easily recognizable that does not conflict with a real address should work.
+ <B>NOTE:</B> You cannot specify the location of the return address. This is determined
+ automatically through static analysis, but you can place the sentinel address through a custom
+ input, if the analysis fails or is incorrect.</P>
+
+ <H3>Option: Snapshot Period</H3>
+
+ <P>By default, the harness captures a snapshot of the emulator's state into a trace after every
+ instruction step. This feature can be disabled entirely by setting this option to 0 (zero), in
+ which case no trace is captured or opened in your tool. Only the outputs are captured.
+ Otherwise, the period indicates how many instructions are executed between consecutive
+ snapshots. If only a starting and ending snapshot are desired, set this to a large number. The
+ initial and final snapshots are always captured, no matter the (non-zero) period.</P>
+
+ <H3><A name="next_alloc"></A> Option: Next Allocation</H3>
+
+ <P>Set this to the location of the heap, if applicable. Any address not already used by the
+ program with plenty of space above should suffice. It may help if the upper digits of the
+ address are easily recognizable. Several of the below actions on the Inputs table will
+ automatically initialize pointers to the start of an "allocated block". This field is then
+ automatically incremented by the size of that allocation. You may adjust this field at any time
+ to "undo" allocations, establish a second heap, etc.</P>
+
+ <H3>Inputs table</H3>
+
+ <P>The Inputs table lists of all the configured inputs. The types and values of the inputs are
+ specified in this table. <B>NOTE:</B> No actual initializations are performed until right
+ before emulation. If two inputs happen to be at the same address, that conflict will not be
+ discovered until clicking "Run." No two inputs can have the same name. Adding an input with a
+ duplicate name replaces the existing one.</P>
+
+ <P>The default inputs are derived from the target function's parameters. Adjusting the type of
+ an input <EM>does not</EM> edit or update the target function in the program database. The
+ columns are:</P>
+
+ <UL>
+ <LI>Name &mdash; Provides an informal name for the input. For parameters, this is the name of
+ the parameter. For custom inputs, this is "Custom 1" counting up in the order added. For
+ vararg arguments, this is, e.g., "Vararg 3" couting up in the order added, starting after the
+ number of fixed arguments. For allocated inputs, this is a C-like expression derived from the
+ pointer to it and its type. This field <EM>cannot</EM> be edited.</LI>
+
+ <LI>Storage &mdash; Provides a formal Sleigh expression describing the location of the input.
+ For custom inputs, this is specified by the user when added. For parameter and vararg inputs,
+ this is derived from the target function's signature, custom storage, and/or calling
+ convention. For pointer allocations, this is derived from the pointer to it and its type.
+ This field <EM>cannot</EM> be edited.</LI>
+
+ <LI>Value &mdash; Controls the raw initial value of the input variable. This can be specified
+ as a positive integer, e.g., <CODE>0x1234</CODE>, so long as it fits in the storage, or as a
+ byte sequence, e.g., <CODE>{ 34 12 }</CODE>, so long as its length matches that of the
+ storage.</LI>
+
+ <LI>Type &mdash; Controls the type of the input variable. This has no direct impact on the
+ emulation nor on the program database (except to resolve the type), but permits the initial
+ value to be specified using a representation suitable to that type.</LI>
+
+ <LI>Repr &mdash; Controls the initial value of the input variable as represented by the
+ chosen type. <B>NOTE:</B> some types, particularly structure types, do not have a string
+ representation, and so this box may appear empty. This field can be edited only if the chosen
+ type implements an encoder.<BR>
+ <BR>
+ </LI>
+ </UL>
+
+ <H3>Action: Remove Input</H3>
+
+ <P>This action removes the selected input(s) from the table. A removed input is no longer
+ initialized. <B>NOTE:</B> Inputs can have dependencies, e.g., an allocated block depends on its
+ pointer, because the storage location of that block is computed from the value of the pointer.
+ Removing the pointer will leave it uninitialized, likely resulting in the block's location
+ being 0 (zero). This will generally still work, but is usually not desired. Re-adding the
+ relevant pointer can fix this. So long as the old and new names match, the dependency
+ relationship is restored, too.</P>
+
+ <H3>Action: Clear Inputs</H3>
+
+ <P>For when things have gone so far south you need to start over. Typically this is followed by
+ a Refresh, too.</P>
+
+ <H3>Action: Add Custom Input</H3>
+
+ <P>This action prompts the user for a Sleigh expression of a variable's storage and adds it as
+ a Custom input. Typically, this is a register, e.g., <CODE>RAX</CODE>, or a fixed address and
+ size, e.g., <CODE>*:8 0x00401234</CODE>.</P>
+
+ <H3>Action: Add Vararg Input</H3>
+
+ <P>This action is only enabled if the target function has variable arguments. It prompts the
+ user for a type, derives the storage from the target function's signature and calling convetion
+ and adds it as a Vararg input. <B>NOTE:</B> Adjustments to this row's type <EM>will not</EM>
+ automatically update the argument's storage. Consider deleting and re-adding an argument along
+ with all its subsequent arguments if consistent storage is desired.</P>
+
+ <H3>Action: Allocate and Add Pointer Inputs</H3>
+
+ <P>This action is available when the selected input has a pointer type. (Multiple selections
+ are supported.) The size of the pointed-to type is calculated; the <EM>pointer's</EM> value is
+ initialized to the <A href="#next_alloc">Next Allocation</A>, which is then incremented by the
+ size of the pointed-to type. A new input row is then added and selected, describing the
+ variable pointed to by the formerly-selected input. Under normal operation, this allocates a
+ single instance of the pointed-to type. To instead allocate an array of the pointed-to type,
+ hold <B>&lt;Shift&gt;</B> when clicking the button. If the pointed-to type is a composite
+ (struct or union), a separate row is generated for each field. For the array case, yes, this
+ results in an <EM>n</EM>-by-<EM>m</EM> set of new rows. If the pointed-to type is a string (or
+ <CODE>char</CODE>), hold <B>&lt;Ctrl&gt;</B> when clicking the button. This will prompt the
+ user for string data type settings and then for the initial string value. It encodes it and
+ allocates sufficient space for the encoding. <B>NOTE:</B> So long as edits to the Repr column
+ result in encodings of smaller or equal size, no re-allocation is necessary. The table will
+ still permit the edit, but it may result in conflicts. Either update the pointer values
+ manually &mdash; this will automatically adjust the storage location of the pointed-to variable
+ &mdash; or delete and re-allocate the string input.</P>
+
+ <H3>Action: Refresh Inputs</H3>
+
+ <P>This re-adds (likely replacing) all the inputs derived from the function's parameters. This
+ is especially useful when trying to derive a function's signature by trial and error. Clicking
+ this button after editing a function's signature will update the Parameter inputs accordingly.
+ <B>NOTE:</B> This will not <EM>remove</EM> any Parameter inputs.</P>
+
+ <H3>Action: Type Settings</H3>
+
+ <P>This action is available in the right-click context menu on rows with an assigned type. It
+ controls the settings on the chosen datatype, e.g., radix for integer types, or encodings for
+ string types.</P>
+
+ <H3>Outputs table</H3>
+
+ <P>The Outputs table is analogous to the Inputs table, except that it displays values captured
+ from the last successful emulation. The default output is derived from the target function's
+ return type. It has the same columns and similar actions with the following exceptions:</P>
+
+ <UL>
+ <LI>There is no <B>Add Vararg Output</B> action.</LI>
+
+ <LI>Only the Type column can be edited.</LI>
+
+ <LI>Adding Pointed-to outputs does not "allocate," since the pointer is expected to be set by
+ the target function.</LI>
+
+ <LI>When adding pointed-to strings, the prompt is for the number of bytes to capture. The
+ string decoder should only use what it needs, so just pick a reasonable maximum expected
+ length. Adjust the type and settings using other actions afterward.</LI>
+ </UL>
+
+ <H3>Probe Outputs</H3>
+
+ <P>The Outputs table also supports "Probe" outputs. These are outputs automatically generated
+ during the emulation of the target function via the <CODE>emu_probe</CODE> userop. These are
+ configured using the <A href=
+ "help/topics/DebuggerBreakpointsPlugin/DebuggerBreakpointsPlugin.html#set_injection">Set
+ Injection</A> action on a breakpoint. The breakpoint need only be enabled. Even if
+ "ineffective,"" it will be installed by the harness. The <CODE>emu_probe</CODE> userop accepts
+ exactly one argument. All Probe outputs are cleared at the start of emulation. Each time the
+ userop is executed, its argument is captured with its location and value <EM>at the time of
+ invocation</EM>. These are then added as Probe outputs, counting 1-up by invocation. If the
+ userop is invoked within a loop of the target code, each run-time invocation gets a distinct
+ row. Types can be applied as usual. <B>NOTE:</B> If the userop argument is anything other than
+ a simple varnode, the location will be "$Unique."</P>
</BODY>
</HTML>
diff --git a/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerEmulationServicePlugin/images/DebuggerEmulateFunctionDialog.png b/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerEmulationServicePlugin/images/DebuggerEmulateFunctionDialog.png
new file mode 100644
index 0000000000..1de2c1998a
Binary files /dev/null and b/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerEmulationServicePlugin/images/DebuggerEmulateFunctionDialog.png differ
diff --git a/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerListingPlugin/DebuggerListingPlugin.html b/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerListingPlugin/DebuggerListingPlugin.html
index 842597dcd8..41ab8e0c50 100644
--- a/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerListingPlugin/DebuggerListingPlugin.html
+++ b/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerListingPlugin/DebuggerListingPlugin.html
@@ -191,7 +191,7 @@
debugger. This failure can be overcome by enabling <A href=
"help/topics/DebuggerRegionsPlugin/DebuggerRegionsPlugin.html">Force Full View</A>.</P>
- <P>Some examples (in <b>Hex</b> mode):</P>
+ <P>Some examples (in <B>Hex</B> mode):</P>
<UL>
<LI><CODE>00401234</CODE> &mdash; A constant address</LI>
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/BasicAutoReadMemorySpec.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/BasicAutoReadMemorySpec.java
index 4deced1017..5e424a962f 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/BasicAutoReadMemorySpec.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/BasicAutoReadMemorySpec.java
@@ -172,7 +172,7 @@ public enum BasicAutoReadMemorySpec implements AutoReadMemorySpec {
AddressSet toRead = new AddressSet(quantize(12, visible));
for (Lifespan span : coordinates.getView().getViewport().getOrderedSpans()) {
AddressSetView alreadyKnown =
- mm.getAddressesWithState(span.lmin(), visible, StatePredicate.IS_KNOWN);
+ mm.getAddressesWithState(span, toRead, StatePredicate.IS_KNOWN);
toRead.delete(alreadyKnown);
if (span.lmax() != span.lmin() || toRead.isEmpty()) {
break;
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/breakpoint/DebuggerBreakpointsProvider.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/breakpoint/DebuggerBreakpointsProvider.java
index 426f75fac7..ca4d04dfc9 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/breakpoint/DebuggerBreakpointsProvider.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/breakpoint/DebuggerBreakpointsProvider.java
@@ -1339,38 +1339,16 @@ public class DebuggerBreakpointsProvider extends ComponentProviderAdapter
return null;
}
- private boolean isAllInvolvedTracesUsingEmulatedBreakpoints(ActionContext ctx) {
- if (controlService == null) {
- return false;
- }
- Set<Trace> traces = new HashSet<>();
+ private boolean isAtLeastOneBreakpoint(ActionContext ctx) {
Collection<LogicalBreakpoint> breakpoints = getLogicalBreakpoints(ctx);
- if (breakpoints != null) {
- if (breakpoints.isEmpty()) {
- return false;
- }
- for (LogicalBreakpoint lb : breakpoints) {
- traces.addAll(lb.getParticipatingTraces());
- }
- }
- else if (ctx instanceof DebuggerBreakpointLocationsActionContext locCtx) {
- Collection<TraceBreakpointLocation> locations = locCtx.getLocations();
- if (locations.isEmpty()) {
- return false;
- }
- for (TraceBreakpointLocation loc : locations) {
- traces.add(loc.getTrace());
- }
- }
- else {
- return false;
+ if (breakpoints != null && !breakpoints.isEmpty()) {
+ return true;
}
- for (Trace trace : traces) {
- if (!controlService.getCurrentMode(trace).useEmulatedBreakpoints()) {
- return false;
- }
+ if (ctx instanceof DebuggerBreakpointLocationsActionContext locCtx &&
+ !locCtx.getLocations().isEmpty()) {
+ return true;
}
- return true;
+ return false;
}
private static final Set<TraceBreakpointKind> EXECUTE_KINDS =
@@ -1400,11 +1378,11 @@ public class DebuggerBreakpointsProvider extends ComponentProviderAdapter
}
private boolean isPopupSetCondition(ActionContext ctx) {
- return isAllInvolvedTracesUsingEmulatedBreakpoints(ctx) && isAllBreakpointsExecution(ctx);
+ return isAtLeastOneBreakpoint(ctx) && isAllBreakpointsExecution(ctx);
}
private boolean isPopupSetInjection(ActionContext ctx) {
- return isAllInvolvedTracesUsingEmulatedBreakpoints(ctx) && isAllBreakpointsExecution(ctx);
+ return isAtLeastOneBreakpoint(ctx) && isAllBreakpointsExecution(ctx);
}
private String deriveCurrentSleigh(ActionContext ctx) {
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/AddressInputVerifier.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/AddressInputVerifier.java
new file mode 100644
index 0000000000..2448ced76a
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/AddressInputVerifier.java
@@ -0,0 +1,58 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import javax.swing.*;
+
+import ghidra.program.model.address.Address;
+import ghidra.program.model.address.AddressFactory;
+
+public abstract class AddressInputVerifier extends InputVerifier {
+ private AddressFactory factory;
+
+ public AddressInputVerifier(AddressFactory factory) {
+ this.factory = factory;
+ }
+
+ @Override
+ public boolean verify(JComponent input) {
+ if (!(input instanceof JTextField text)) {
+ throw new IllegalArgumentException(
+ "Only JTextField is supported. Got %s".formatted(input.getClass()));
+ }
+ String str = text.getText();
+ try {
+ Address address = factory.getAddress(str);
+ if (address == null) {
+ reject("Invalid address: %s".formatted(str));
+ return false;
+ }
+ if (!verifyAddress(address)) {
+ reject("Invalid address: %s".formatted(str));
+ return false;
+ }
+ return true;
+ }
+ catch (Exception e) {
+ reject("%s while parsing '%s'".formatted(e.getMessage(), str));
+ return false;
+ }
+ }
+
+ protected abstract boolean verifyAddress(Address address);
+
+ protected abstract void reject(String message);
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/DebuggerEmulateFunctionDialog.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/DebuggerEmulateFunctionDialog.java
new file mode 100644
index 0000000000..d7decc1230
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/DebuggerEmulateFunctionDialog.java
@@ -0,0 +1,1148 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import java.awt.BorderLayout;
+import java.awt.Component;
+import java.awt.event.ActionEvent;
+import java.awt.event.MouseEvent;
+import java.util.*;
+import java.util.stream.Collectors;
+
+import javax.swing.*;
+
+import db.Transaction;
+import docking.*;
+import docking.action.ActionContextProvider;
+import docking.action.DockingActionIf;
+import docking.action.builder.ActionBuilder;
+import docking.menu.DialogToolbarButton;
+import docking.widgets.table.*;
+import ghidra.app.plugin.core.data.AbstractSettingsDialog;
+import ghidra.app.plugin.core.debug.gui.DebuggerResources;
+import ghidra.app.plugin.core.debug.gui.emulation.FunctionEmulationHarness.*;
+import ghidra.app.plugin.processors.sleigh.SleighLanguage;
+import ghidra.app.services.*;
+import ghidra.debug.api.control.ControlMode;
+import ghidra.debug.api.tracemgr.DebuggerCoordinates;
+import ghidra.docking.settings.*;
+import ghidra.framework.model.*;
+import ghidra.framework.plugintool.PluginTool;
+import ghidra.pcode.utils.Utils;
+import ghidra.program.database.data.DataTypeUtilities;
+import ghidra.program.model.address.Address;
+import ghidra.program.model.address.AddressSpace;
+import ghidra.program.model.data.*;
+import ghidra.program.model.lang.*;
+import ghidra.program.model.listing.*;
+import ghidra.program.model.mem.ByteMemBufferImpl;
+import ghidra.program.model.pcode.Varnode;
+import ghidra.program.util.FunctionChangeRecord;
+import ghidra.program.util.ProgramEvent;
+import ghidra.util.*;
+import ghidra.util.exception.CancelledException;
+import ghidra.util.table.GhidraTableFilterPanel;
+import ghidra.util.task.Task;
+import ghidra.util.task.TaskMonitor;
+
+public class DebuggerEmulateFunctionDialog extends DialogComponentProvider {
+ static final int GAP = 5;
+ static final String FMT_VA = "Vararg %d";
+ static final String FMT_CUSTOM = "Custom %d";
+ static final String PREFIX_PROBE = "Probe ";
+ static final String FMT_PROBE = PREFIX_PROBE + "%d";
+
+ protected static class VarActionContext<T extends VarRow> extends DefaultActionContext {
+ private final List<T> selection;
+
+ public VarActionContext(List<T> selection) {
+ this.selection = selection;
+ }
+
+ public List<T> getSelection() {
+ return selection;
+ }
+ }
+
+ protected static class InputActionContext extends VarActionContext<InputRow> {
+ public InputActionContext(List<InputRow> selection) {
+ super(selection);
+ }
+ }
+
+ protected static class OutputActionContext extends VarActionContext<OutputRow> {
+ public OutputActionContext(List<OutputRow> selection) {
+ super(selection);
+ }
+ }
+
+ protected abstract static class ActionContainer implements ActionContextProvider {
+ protected final JComponent component;
+ private final List<DockingActionIf> actions = new ArrayList<>();
+ private boolean valid;
+
+ public ActionContainer(JComponent container) {
+ this.component = container;
+ }
+
+ protected abstract void addGroupSeparator();
+
+ public void addAction(DockingActionIf action) {
+ if (actions.add(action)) {
+ valid = false;
+ }
+ }
+
+ private void revalidate() {
+ if (valid) {
+ return;
+ }
+ component.removeAll();
+
+ Map<String, List<DockingActionIf>> byGroup = actions.stream()
+ .collect(Collectors.groupingBy(a -> a.getToolBarData().getToolBarGroup()));
+ boolean first = true;
+ for (Map.Entry<String, List<DockingActionIf>> ent : byGroup.entrySet()) {
+ List<DockingActionIf> actions = ent.getValue();
+ actions.sort(Comparator.comparing(a -> a.getToolBarData().getToolBarSubGroup()));
+ if (!first) {
+ addGroupSeparator();
+ }
+ for (DockingActionIf action : actions) {
+ component.add(new DialogToolbarButton(action, this));
+ }
+ first = false;
+ }
+ valid = true;
+ }
+
+ public void contextChanged() {
+ revalidate();
+ ActionContext ctx = getActionContext(null);
+ for (DockingActionIf action : actions) {
+ action.setEnabled(action.isEnabledForContext(ctx));
+ }
+ }
+
+ /* Testing */ DockingActionIf byName(String name) {
+ return actions.stream().filter(a -> name.equals(a.getName())).findFirst().orElseThrow();
+ }
+ }
+
+ protected abstract static class HorizontalBoxActionContainer extends ActionContainer {
+ public HorizontalBoxActionContainer() {
+ super(Box.createHorizontalBox());
+ }
+
+ @Override
+ protected void addGroupSeparator() {
+ component.add(Box.createHorizontalStrut(5));
+ component.add(DockingUtils.createToolbarSeparator());
+ component.add(Box.createHorizontalStrut(5));
+ }
+ }
+
+ protected final PluginTool tool;
+ protected final Function function;
+ protected final SleighLanguage language;
+
+ protected JTextField textSentinel;
+ protected JTextField textSnapshotPeriod;
+ protected JTextField textNextAlloc;
+ protected Address sentinel;
+ protected long snapshotPeriod;
+ protected Address nextAlloc;
+
+ protected final InputsTableModel inputsTableModel;
+ protected GTable inputsTable;
+ protected GhidraTableFilterPanel<InputRow> inputsFilterPanel;
+
+ protected final OutputsTableModel outputsTableModel;
+ protected GTable outputsTable;
+ protected GhidraTableFilterPanel<OutputRow> outputsFilterPanel;
+
+ protected final ActionContainer inputActions = new HorizontalBoxActionContainer() {
+ @Override
+ public ActionContext getActionContext(MouseEvent e) {
+ return new InputActionContext(inputsFilterPanel.getSelectedItems());
+ }
+ };
+ protected final ActionContainer outputActions = new HorizontalBoxActionContainer() {
+ @Override
+ public ActionContext getActionContext(MouseEvent e) {
+ return new OutputActionContext(outputsFilterPanel.getSelectedItems());
+ }
+ };
+
+ protected final DomainObjectListener listenerForFunction = new DomainObjectListenerBuilder(this)
+ .any(DomainObjectEvent.RESTORED)
+ .terminate(inputActions::contextChanged)
+ .with(FunctionChangeRecord.class)
+ .each(ProgramEvent.FUNCTION_CHANGED)
+ .call(this::functionChanged)
+ .build();
+
+ public DebuggerEmulateFunctionDialog(PluginTool tool, Function function) {
+ super("Emulate %s of %s".formatted(function.getName(), function.getProgram().getName()),
+ false, true, true, true);
+ if (!(function.getProgram().getLanguage() instanceof SleighLanguage language)) {
+ throw new IllegalArgumentException("Sleigh language required");
+ }
+ this.tool = tool;
+ this.function = function;
+ this.language = language;
+
+ inputsTableModel = new InputsTableModel(tool, this);
+ outputsTableModel = new OutputsTableModel(tool, this);
+
+ inputsTableModel.addTableModelListener(evt -> {
+ inputActions.contextChanged();
+ });
+ outputsTableModel.addTableModelListener(evt -> {
+ outputActions.contextChanged();
+ });
+
+ sentinel = language.getDefaultSpace().getAddress(0xdeadbeef);
+ snapshotPeriod = 1;
+ nextAlloc = language.getDefaultDataSpace().getAddress(0x7beef000);
+
+ populateComponents();
+ createActions();
+
+ initializeVarTables();
+ inputActions.contextChanged();
+ outputActions.contextChanged();
+
+ function.getProgram().addListener(listenerForFunction);
+
+ }
+
+ protected void populateComponents() {
+ JPanel panel = new JPanel(new BorderLayout());
+
+ {
+ JPanel opts = new JPanel();
+ opts.setLayout(new BoxLayout(opts, BoxLayout.Y_AXIS));
+ opts.getAccessibleContext().setAccessibleName("Options");
+ {
+ Box box = Box.createHorizontalBox();
+ box.setBorder(BorderFactory.createEmptyBorder(GAP, GAP, GAP, GAP));
+ JLabel label = new JLabel("Ending Return Address:");
+ label.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, GAP));
+ box.add(label);
+ textSentinel = new JTextField("deadbeef");
+ box.add(textSentinel);
+ opts.add(box);
+ }
+ {
+ Box box = Box.createHorizontalBox();
+ box.setBorder(BorderFactory.createEmptyBorder(GAP, GAP, GAP, GAP));
+ JLabel label = new JLabel("Snapshot Period (0 for none):");
+ label.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, GAP));
+ box.add(label);
+ textSnapshotPeriod = new JTextField(Long.toString(snapshotPeriod));
+ box.add(textSnapshotPeriod);
+ opts.add(box);
+ }
+ {
+ Box box = Box.createHorizontalBox();
+ box.setBorder(BorderFactory.createEmptyBorder(GAP, GAP, GAP, GAP));
+ JLabel label = new JLabel("Next Allocation:");
+ label.setBorder(BorderFactory.createEmptyBorder(0, 0, 0, GAP));
+ box.add(label);
+ textNextAlloc = new JTextField(nextAlloc.toString());
+ box.add(textNextAlloc);
+ opts.add(box);
+ }
+ panel.add(opts, BorderLayout.NORTH);
+ }
+ {
+ JSplitPane splitPane = new JSplitPane(JSplitPane.VERTICAL_SPLIT);
+ {
+ JPanel inputsTablePanel = new JPanel(new BorderLayout());
+ JPanel topBar = new JPanel(new BorderLayout());
+ topBar.add(new JLabel("Inputs:"), BorderLayout.WEST);
+ topBar.add(inputActions.component, BorderLayout.EAST);
+ topBar.add(new JSeparator(SwingConstants.HORIZONTAL), BorderLayout.NORTH);
+ inputsTablePanel.add(topBar, BorderLayout.NORTH);
+
+ inputsTable = new GTable(inputsTableModel);
+ inputsTable.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
+ inputsTablePanel.add(new JScrollPane(inputsTable));
+ inputsFilterPanel = new GhidraTableFilterPanel<>(inputsTable, inputsTableModel);
+ inputsTablePanel.add(inputsFilterPanel, BorderLayout.SOUTH);
+ inputsTablePanel.getAccessibleContext().setAccessibleName("Inputs Filters");
+ splitPane.setTopComponent(inputsTablePanel);
+ }
+ {
+ JPanel outputsTablePanel = new JPanel(new BorderLayout());
+ JPanel topBar = new JPanel(new BorderLayout());
+ topBar.add(new JLabel("Outputs:"), BorderLayout.WEST);
+ topBar.add(outputActions.component, BorderLayout.EAST);
+ topBar.add(new JSeparator(SwingConstants.HORIZONTAL), BorderLayout.NORTH);
+ outputsTablePanel.add(topBar, BorderLayout.NORTH);
+
+ outputsTable = new GTable(outputsTableModel);
+ outputsTable.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
+ outputsTablePanel.add(new JScrollPane(outputsTable));
+ outputsFilterPanel = new GhidraTableFilterPanel<>(outputsTable, outputsTableModel);
+ outputsTablePanel.add(outputsFilterPanel, BorderLayout.SOUTH);
+ outputsTablePanel.getAccessibleContext().setAccessibleName("Outputs Filters");
+ splitPane.setBottomComponent(outputsTablePanel);
+ }
+ panel.add(splitPane);
+ }
+
+ panel.getAccessibleContext().setAccessibleName("Emulate " + function.getName());
+ addWorkPanel(panel);
+
+ addOKButton();
+ okButton.setText("Run");
+ addDismissButton();
+
+ inputsTable.getSelectionModel().addListSelectionListener(evt -> {
+ inputActions.contextChanged();
+ });
+ outputsTable.getSelectionModel().addListSelectionListener(evt -> {
+ outputActions.contextChanged();
+ });
+
+ textSentinel.setInputVerifier(new AddressInputVerifier(language.getAddressFactory()) {
+ @Override
+ protected boolean verifyAddress(Address address) {
+ sentinel = address;
+ return true;
+ }
+
+ @Override
+ protected void reject(String message) {
+ setStatusText(message, MessageType.ERROR);
+ }
+ });
+ textSnapshotPeriod.setInputVerifier(new LongInputVerifier() {
+ @Override
+ protected boolean verifyLong(long value) {
+ snapshotPeriod = value;
+ return true;
+ }
+
+ @Override
+ protected void reject(String message) {
+ setStatusText(message, MessageType.ERROR);
+ }
+ });
+ textNextAlloc.setInputVerifier(new AddressInputVerifier(language.getAddressFactory()) {
+ @Override
+ protected boolean verifyAddress(Address address) {
+ nextAlloc = address;
+ return true;
+ }
+
+ @Override
+ protected void reject(String message) {
+ setStatusText(message, MessageType.ERROR);
+ }
+ });
+ }
+
+ @Override
+ protected void dialogClosed() {
+ function.getProgram().removeListener(listenerForFunction);
+ super.dialogClosed();
+ }
+
+ protected void createActions() {
+ inputActions.addAction(new ActionBuilder("Add Custom Input", getTitle())
+ .toolBarIcon(DebuggerResources.ICON_ADD)
+ .toolBarGroup("Add", "1")
+ .onAction(this::addCustomInputActivated)
+ .build());
+ inputActions.addAction(new ActionBuilder("Add Vararg Input", getTitle())
+ // TODO: ICON
+ .toolBarIcon(DebuggerResources.ICON_OBJECT_POPULATED)
+ .toolBarGroup("Add", "2")
+ .enabledWhen(this::addVarargEnabled)
+ .onAction(this::addVarargActivated)
+ .build());
+ inputActions.addAction(new ActionBuilder("Allocate and Add Pointer Inputs", getTitle())
+ // TODO: ICON
+ .toolBarIcon(DebuggerResources.ICON_REGIONS)
+ .toolBarGroup("Add", "3")
+ .description("""
+ Allocate and add input variables for pointed-to types. \
+ Hold SHIFT for arrays. Hold CTRL for strings.""")
+ .withContext(InputActionContext.class)
+ .enabledWhen(this::addPointerVarsEnabled)
+ .onAction(this::addPointerInputsActivated)
+ .build());
+ inputActions.addAction(new ActionBuilder("Remove Input", getTitle())
+ .toolBarIcon(DebuggerResources.ICON_DELETE)
+ .toolBarGroup("Delete", "1")
+ .withContext(InputActionContext.class)
+ .enabledWhen(this::removeInputEnabled)
+ .onAction(this::removeInputActivated)
+ .build());
+ inputActions.addAction(new ActionBuilder("Clear Inputs", getTitle())
+ .toolBarIcon(DebuggerResources.ICON_CLEAR)
+ .toolBarGroup("Delete", "2")
+ .onAction(this::clearInputsActivated)
+ .build());
+ inputActions.addAction(new ActionBuilder("Refresh Parameter Inputs", getTitle())
+ .toolBarIcon(DebuggerResources.ICON_REFRESH)
+ .toolBarGroup("Util")
+ .onAction(this::refreshInputsActivated)
+ .build());
+
+ outputActions.addAction(new ActionBuilder("Add Custom Output", getTitle())
+ .toolBarIcon(DebuggerResources.ICON_ADD)
+ .toolBarGroup("Add", "1")
+ .onAction(this::addOutputActivated)
+ .build());
+ outputActions.addAction(new ActionBuilder("Add Pointer Outputs", getTitle())
+ // TODO: ICON
+ .toolBarIcon(DebuggerResources.ICON_REGIONS)
+ .toolBarGroup("Add", "2")
+ .description("""
+ Add output variables for pointed-to types. \
+ Hold SHIFT for arrays. Hold CTRL for strings.""")
+ .withContext(OutputActionContext.class)
+ .enabledWhen(this::addPointerVarsEnabled)
+ .onAction(this::addPointerOutputsActivated)
+ .build());
+ outputActions.addAction(new ActionBuilder("Remove Output", getTitle())
+ .toolBarIcon(DebuggerResources.ICON_DELETE)
+ .toolBarGroup("Delete", "1")
+ .withContext(OutputActionContext.class)
+ .enabledWhen(this::removeOutputEnabled)
+ .onAction(this::removeOutputActivated)
+ .build());
+ outputActions.addAction(new ActionBuilder("Clear Outputs", getTitle())
+ .toolBarIcon(DebuggerResources.ICON_CLEAR)
+ .toolBarGroup("Delete", "2")
+ .onAction(this::clearOutputsActivated)
+ .build());
+ outputActions.addAction(new ActionBuilder("Refresh Return Outputs", getTitle())
+ .toolBarIcon(DebuggerResources.ICON_REFRESH)
+ .toolBarGroup("Util")
+ .onAction(this::refreshOutputsActivated)
+ .build());
+
+ new ActionBuilder("Type Settings", getTitle())
+ .popupMenuPath("Type Settings")
+ .withContext(VarActionContext.class)
+ .enabledWhen(this::typeSettingsEnabled)
+ .onAction(this::typeSettingsActivated)
+ .buildAndInstallLocal(this);
+ }
+
+ private void functionChanged(FunctionChangeRecord rec) {
+ if (rec.getFunction() == function) {
+ inputActions.contextChanged();
+ }
+ }
+
+ <T extends VarRow> Optional<T> findRow(RowObjectTableModel<T> model, String name) {
+ return model.getModelData().stream().filter(v -> name.equals(v.getName())).findAny();
+ }
+
+ private DataType findParameterType(int i) {
+ Parameter parameter = function.getParameter(i);
+ if (parameter == null) {
+ throw new IllegalArgumentException("No such parameter %d".formatted(i));
+ }
+ Optional<InputRow> row = findRow(inputsTableModel, parameter.getName());
+ if (row.isPresent() && row.get().getType() != null) {
+ return row.get().getType();
+ }
+ return parameter.getDataType();
+ }
+
+ private Optional<DataType> findVarargType(int i) {
+ return findRow(inputsTableModel, FMT_VA.formatted(i)).map(input -> input.getType());
+ }
+
+ private boolean conflictsInputName(RowObjectTableModel<? extends VarRow> model, String name) {
+ return findRow(model, name).isPresent();
+ }
+
+ private String chooseCustomName(RowObjectTableModel<? extends VarRow> model) {
+ for (int i = 1;; i++) {
+ String name = FMT_CUSTOM.formatted(i);
+ if (!conflictsInputName(model, name)) {
+ return name;
+ }
+ }
+ }
+
+ private byte[] promptString(String title, String message, DataType type, Settings settings) {
+ while (true) {
+ Object response = JOptionPane.showInputDialog(rootPanel, message, title,
+ JOptionPane.QUESTION_MESSAGE, DebuggerResources.ICON_REGIONS, null, null);
+ if (response == null) {
+ return null;
+ }
+ try {
+ String str = response.toString();
+ return type.encodeValue(str,
+ new ByteMemBufferImpl(language.getDefaultDataSpace().getAddress(0),
+ new byte[] {}, language.isBigEndian()),
+ settings, -1);
+ }
+ catch (Exception e) {
+ setStatusText(e.getMessage(), MessageType.ERROR);
+ }
+ }
+ }
+
+ private int promptIntGt1(String title, String message) {
+ while (true) {
+ Object response = JOptionPane.showInputDialog(rootPanel, message, title,
+ JOptionPane.QUESTION_MESSAGE, DebuggerResources.ICON_REGIONS, null, null);
+ clearStatusText();
+ if (response == null) {
+ return -1;
+ }
+ try {
+ int count = Integer.parseInt(response.toString());
+ if (count >= 1) {
+ return count;
+ }
+ setStatusText("Must be 1 or greater", MessageType.ERROR);
+ }
+ catch (Exception e) {
+ setStatusText(e.getMessage(), MessageType.ERROR);
+ }
+ }
+ }
+
+ private VarStorage promptStorage(String title) {
+ while (true) {
+ Object expr = JOptionPane.showInputDialog(rootPanel, "Expression", title,
+ JOptionPane.QUESTION_MESSAGE, DebuggerResources.ICON_ADD, null, null);
+ clearStatusText();
+ if (expr == null) {
+ return null;
+ }
+ try {
+ return VarStorage.fromExpression(language, expr.toString());
+ }
+ catch (Exception e) {
+ setStatusText(e.getMessage(), MessageType.ERROR);
+ }
+ }
+ }
+
+ private void addCustomInputActivated(ActionContext ctx) {
+ VarStorage storage = promptStorage("Add Custom Input");
+ if (storage == null) {
+ return;
+ }
+ inputsTableModel.add(new InputRow(language, chooseCustomName(inputsTableModel),
+ storage, null));
+ }
+
+ private boolean removeInputEnabled(InputActionContext ctx) {
+ return !ctx.getSelection().isEmpty();
+ }
+
+ private void removeInputActivated(InputActionContext ctx) {
+ for (InputRow row : ctx.getSelection()) {
+ inputsTableModel.delete(row);
+ }
+ }
+
+ private boolean addVarargEnabled(ActionContext ctx) {
+ DataTypeManagerService dtms = tool.getService(DataTypeManagerService.class);
+ return dtms != null && function.hasVarArgs();
+ }
+
+ private static DataType getBaseDataType(DataType dt) {
+ return dt instanceof TypeDef tdef ? tdef.getBaseDataType() : dt;
+ }
+
+ private boolean addPointerVarsEnabled(VarActionContext<?> ctx) {
+ List<? extends VarRow> sel = ctx.getSelection();
+ if (sel.isEmpty()) {
+ return false;
+ }
+ for (VarRow input : sel) {
+ DataType baseType = getBaseDataType(input.getType());
+ if (!(baseType instanceof Pointer)) {
+ return false;
+ }
+ }
+ return true;
+ }
+
+ private Varnode doAllocate(int length) {
+ Address addr = nextAlloc;
+ nextAlloc = nextAlloc.add(length);
+ textNextAlloc.setText(nextAlloc.toString());
+ return new Varnode(addr, length);
+ }
+
+ interface Allocator {
+ void allocate(int length);
+ }
+
+ interface RowConstructor<T> {
+ T create(String name, VarStorage storage, DataType type);
+ }
+
+ abstract class VarAdder<T extends VarRow> {
+ protected final T from;
+ protected final DefaultEnumeratedColumnTableModel<?, T> into;
+ protected final List<T> added;
+
+ public VarAdder(T from, DefaultEnumeratedColumnTableModel<?, T> into, List<T> added) {
+ this.from = from;
+ this.into = into;
+ this.added = added;
+ }
+
+ byte[] addrToBytes(Address address, int length) {
+ return Utils.longToBytes(address.getOffset(), length, language.isBigEndian());
+ }
+
+ void allocate(int length) {
+ // Extension point
+ }
+
+ abstract T newRow(String name, VarStorage storage, DataType type);
+
+ public void addPointerVars(int count) {
+ if (!(getBaseDataType(from.getType()) instanceof Pointer ptr)) {
+ return;
+ }
+ DataType dest = ptr.getDataType();
+ int length = dest.getLength();
+ int alignedLen = dest.getAlignedLength();
+ if (length == -1) {
+ throw new IllegalArgumentException(
+ "DataType %s has dynamic length".formatted(dest));
+ }
+ allocate((alignedLen * (count - 1)) + length);
+
+ AddressSpace space = function.getProgram().getLanguage().getDefaultDataSpace();
+ int offset = 0;
+
+ if (!(DataTypeUtilities.getBaseDataType(dest) instanceof Composite composite)) {
+ for (int i = 0; i < count; i++) {
+ VarStorage deref = from.getStorage().deref(language, space, offset, length);
+ String name = count == 1 // LATER: Cull unnecessary ()s?
+ ? "*(%s)".formatted(from.name)
+ : "(%s)[%d]".formatted(from.name, i);
+ findRow(into, name).ifPresent(into::delete);
+ T row = newRow(name, deref, dest);
+ into.add(row);
+ added.add(row);
+
+ offset += alignedLen;
+ }
+ return;
+ }
+
+ for (int i = 0; i < count; i++) {
+ for (DataTypeComponent comp : composite.getDefinedComponents()) {
+ VarStorage deref = from.getStorage()
+ .deref(language, space, offset + comp.getOffset(), comp.getLength());
+ String fieldName = comp.getFieldName();
+ if (fieldName == null) {
+ fieldName = comp.getDefaultFieldName();
+ }
+ String name = count == 1
+ ? "(%s)->%s".formatted(from.name, fieldName)
+ : "(%s)[%d].%s".formatted(from.name, i, fieldName);
+ findRow(into, name).ifPresent(into::delete);
+ T row = newRow(name, deref, comp.getDataType());
+ into.add(row);
+ added.add(row);
+ }
+
+ offset += alignedLen;
+ }
+ }
+
+ record SettingsAndValue(Settings settings, byte[] encoded) {}
+
+ abstract SettingsAndValue defaultStringValue(String name, DataType type);
+
+ public void addStringVar() {
+ AddressSpace space = function.getProgram().getLanguage().getDefaultDataSpace();
+
+ DataType strType = deriveStringType(from.type);
+ if (strType == null) {
+ return;
+ }
+ SettingsAndValue value = defaultStringValue(from.name, strType);
+ Varnode alloc = doAllocate(value.encoded.length);
+ from.setValue(addrToBytes(alloc.getAddress(), from.length));
+ VarStorage deref = from.getStorage().deref(language, space, alloc.getSize());
+ T row = newRow("*(%s)".formatted(from.name), deref, strType);
+ copySettings(value.settings, row.getSettings(), strType.getSettingsDefinitions());
+ row.setValue(value.encoded);
+ added.add(row);
+ into.add(row);
+ }
+ }
+
+ class InputAdder extends VarAdder<InputRow> {
+ private final Map<DataType, Settings> settingsMap;
+
+ public InputAdder(InputRow from, List<InputRow> added,
+ Map<DataType, Settings> settingsMap) {
+ super(from, inputsTableModel, added);
+ this.settingsMap = settingsMap;
+ }
+
+ @Override
+ SettingsAndValue defaultStringValue(String name, DataType type) {
+ Settings settings = settingsMap.computeIfAbsent(type, t -> {
+ Settings s = new SettingsImpl();
+ tool.showDialog(new VarDataSettingsDialog(type, s));
+ return s;
+ });
+ byte[] encoded =
+ promptString("Allocate String", "Value of %s".formatted(name), type, settings);
+ return new SettingsAndValue(settings, encoded);
+ }
+
+ @Override
+ void allocate(int length) {
+ Varnode alloc = doAllocate(length);
+ from.setValue(addrToBytes(alloc.getAddress(), from.length));
+ }
+
+ @Override
+ InputRow newRow(String name, VarStorage storage, DataType type) {
+ return new InputRow(language, name, storage, type, Set.of(from.name));
+ }
+ }
+
+ class OutputAdder extends VarAdder<OutputRow> {
+ public OutputAdder(OutputRow from, List<OutputRow> added) {
+ super(from, outputsTableModel, added);
+ }
+
+ @Override
+ SettingsAndValue defaultStringValue(String name, DataType type) {
+ int length = promptIntGt1("Add String", "Length of %s".formatted(name));
+ if (length < -1) {
+ return null;
+ }
+ return new SettingsAndValue(new SettingsImpl(), new byte[length]);
+ }
+
+ @Override
+ OutputRow newRow(String name, VarStorage storage, DataType type) {
+ return new OutputRow(language, name, storage, type);
+ }
+ }
+
+ AbstractStringDataType deriveStringType(DataType dt) {
+ if (!(dt instanceof Pointer ptr)) {
+ return null;
+ }
+ return switch (ptr.getDataType()) {
+ case AbstractStringDataType strType -> strType;
+ case CharDataType charType -> TerminatedStringDataType.dataType;
+ default -> null;
+ };
+ }
+
+ private int getCount(ActionContext ctx) {
+ if ((ctx.getEventClickModifiers() & ActionEvent.SHIFT_MASK) == 0) {
+ return 1;
+ }
+ return promptIntGt1("Allocate Pointer Array Inputs", "Count");
+ }
+
+ private void addPointerInputsActivated(InputActionContext ctx) {
+ List<InputRow> added = new ArrayList<>();
+ Map<DataType, Settings> settingsMap = new HashMap<>();
+ if ((ctx.getEventClickModifiers() & ActionEvent.CTRL_MASK) != 0) {
+ for (InputRow input : ctx.getSelection()) {
+ new InputAdder(input, added, settingsMap).addStringVar();
+ }
+ }
+ else {
+ int count = getCount(ctx);
+ if (count < 0) {
+ return;
+ }
+ for (InputRow input : ctx.getSelection()) {
+ new InputAdder(input, added, settingsMap).addPointerVars(count);
+ }
+ }
+ if (!added.isEmpty()) {
+ inputsFilterPanel.setSelectedItems(added);
+ }
+ }
+
+ private void addPointerOutputsActivated(OutputActionContext ctx) {
+ List<OutputRow> added = new ArrayList<>();
+ if ((ctx.getEventClickModifiers() & ActionEvent.CTRL_MASK) != 0) {
+ for (OutputRow output : ctx.getSelection()) {
+ new OutputAdder(output, added).addStringVar();
+ }
+ }
+ else {
+ int count = getCount(ctx);
+ if (count < 0) {
+ return;
+ }
+ for (OutputRow output : ctx.getSelection()) {
+ new OutputAdder(output, added).addPointerVars(count);
+ }
+ if (!added.isEmpty()) {
+ outputsFilterPanel.setSelectedItems(added);
+ }
+ }
+ }
+
+ private void addVarargActivated(ActionContext ctx) {
+ DataTypeManagerService dtms = tool.getService(DataTypeManagerService.class);
+ if (dtms == null) {
+ return;
+ }
+ DataType chosenDt = dtms.promptForDataType(null);
+ if (chosenDt == null) {
+ return;
+ }
+ Program program = function.getProgram();
+ DataTypeManager dtm = program.getDataTypeManager();
+ try (Transaction tx = program.openTransaction("Resolve data type")) {
+ chosenDt = dtm.resolve(chosenDt, DataTypeConflictHandler.DEFAULT_HANDLER);
+ }
+
+ PrototypeModel cc = function.getCallingConvention();
+ PrototypePieces proto = new PrototypePieces(cc, function.getReturnType());
+
+ int paramCount = function.getParameterCount();
+ for (int i = 0; i < paramCount; i++) {
+ proto.intypes.add(findParameterType(i));
+ }
+ for (int i = 1;; i++) {
+ Optional<DataType> dt = findVarargType(i);
+ if (dt.isEmpty()) {
+ break;
+ }
+ proto.intypes.add(dt.get());
+ }
+ proto.intypes.add(chosenDt);
+
+ ArrayList<ParameterPieces> result = new ArrayList<>();
+ cc.assignParameterStorage(proto, dtm, result, true);
+ CompilerSpec cSpec = program.getCompilerSpec();
+ String name = FMT_VA.formatted(result.size() - 1); // -1 to account for "return" param
+ ParameterPieces last = result.getLast();
+ InputRow input = new InputRow(language, name,
+ VarStorage.fromVariableStorage(last.getVariableStorage(program), cSpec), last.type);
+ inputsTableModel.add(input);
+ }
+
+ private void refreshInputsActivated(ActionContext ctx) {
+ doRefreshInputs();
+ }
+
+ private void clearInputsActivated(ActionContext ctx) {
+ inputsTableModel.clear();
+ }
+
+ private void addOutputActivated(ActionContext ctx) {
+ outputsTableModel.add(new OutputRow(language, chooseCustomName(outputsTableModel),
+ promptStorage("Add Output"), null));
+ }
+
+ private boolean removeOutputEnabled(OutputActionContext ctx) {
+ return !ctx.getSelection().isEmpty();
+ }
+
+ private void removeOutputActivated(OutputActionContext ctx) {
+ for (OutputRow row : ctx.getSelection()) {
+ outputsTableModel.delete(row);
+ }
+ }
+
+ private void refreshOutputsActivated(ActionContext ctx) {
+ doRefreshOutputs();
+ }
+
+ private void clearOutputsActivated(ActionContext ctx) {
+ outputsTableModel.clear();
+ }
+
+ private void doRefreshInputs() {
+ CompilerSpec cSpec = function.getProgram().getCompilerSpec();
+ for (Parameter parameter : function.getParameters()) {
+ findRow(inputsTableModel, parameter.getName()).ifPresent(inputsTableModel::delete);
+ inputsTableModel.add(InputRow.fromVariable(parameter, cSpec));
+ }
+ }
+
+ private void doRefreshOutputs() {
+ CompilerSpec cSpec = function.getProgram().getCompilerSpec();
+ Parameter ret = function.getReturn();
+ findRow(outputsTableModel, ret.getName()).ifPresent(outputsTableModel::delete);
+ if (!(ret.getDataType() instanceof VoidDataType) &&
+ !ret.getVariableStorage().isUnassignedStorage()) {
+ outputsTableModel.add(OutputRow.fromVariable(ret, cSpec));
+ }
+ }
+
+ private boolean typeSettingsEnabled(VarActionContext<?> ctx) {
+ return ctx != null && ctx.getSelection().size() == 1;
+ }
+
+ protected static void copySettings(Settings src, Settings dst, SettingsDefinition[] defs) {
+ for (SettingsDefinition sd : defs) {
+ sd.copySetting(src, dst);
+ }
+ }
+
+ protected class VarDataSettingsDialog extends AbstractSettingsDialog {
+ private final Settings mySettings;
+
+ public VarDataSettingsDialog(DataType type, Settings mySettings) {
+ super("Settings for %s".formatted(type), type.getSettingsDefinitions(), mySettings);
+ this.mySettings = mySettings;
+ }
+
+ @Override
+ protected Settings getSettings() {
+ return super.getSettings();
+ }
+
+ @Override
+ protected void okCallback() {
+ super.okCallback();
+ }
+
+ @Override
+ protected String[] getSuggestedValues(StringSettingsDefinition settingsDefinition) {
+ if (!settingsDefinition.supportsSuggestedValues()) {
+ return null;
+ }
+ return settingsDefinition.getSuggestedValues(mySettings);
+ }
+
+ @Override
+ protected void applySettings() throws CancelledException {
+ copySettings(getSettings(), mySettings, getSettingsDefinitions());
+ }
+ }
+
+ private void typeSettingsActivated(VarActionContext<?> ctx) {
+ VarRow row = ctx.getSelection().getFirst();
+ DataType type = row.getType();
+ if (type == null) {
+ return;
+ }
+ tool.showDialog(new VarDataSettingsDialog(row.getType(), row.getSettings()));
+ // It is modal
+ row.settingsChanged();
+ if (row instanceof InputRow) {
+ inputsTableModel.fireTableDataChanged();
+ }
+ else {
+ outputsTableModel.fireTableDataChanged();
+ }
+ }
+
+ protected void initializeVarTables() {
+ doRefreshInputs();
+ doRefreshOutputs();
+ }
+
+ protected GTable containingTable(Component c) {
+ for (Component p = c; p != null; p = p.getParent()) {
+ if (p == inputsTable) {
+ return inputsTable;
+ }
+ if (p == outputsTable) {
+ return outputsTable;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public ActionContext getActionContext(MouseEvent event) {
+ if (event == null) {
+ return super.getActionContext(event);
+ }
+ GTable table = containingTable(event.getComponent());
+ if (table == inputsTable) {
+ return inputActions.getActionContext(event);
+ }
+ else if (table == outputsTable) {
+ return outputActions.getActionContext(event);
+ }
+ return super.getActionContext(event);
+ }
+
+ @Override
+ protected void okCallback() {
+ super.okCallback();
+
+ clearStatusText();
+
+ DebuggerTraceManagerService traceManager =
+ tool.getService(DebuggerTraceManagerService.class);
+ DebuggerControlService controlService = tool.getService(DebuggerControlService.class);
+
+ executeProgressTask(new Task("Emulate", true, false, false, false) {
+ @Override
+ public void run(TaskMonitor monitor) throws CancelledException {
+ monitor.setMessage("Starting");
+ try (FunctionEmulationHarness harness =
+ FunctionEmulationHarness.start(tool, function, monitor)) {
+ /**
+ * Sentinel placement precedes input initialization, because 1) The user's say
+ * should override anything we do automatically, though it may be a foot gun,
+ * and 2) input initialization commits the state to the trace. We'd have to
+ * commit again were we to place the sentinel after.
+ */
+ monitor.setMessage("Placing end breakpoint");
+ harness.placeSentinel(sentinel);
+ monitor.setMessage("Initializing inputs");
+ initializeInputs(harness.init());
+ monitor.setMessage("Installing injects");
+ harness.installInjects();
+ monitor.setMessage("Emulating");
+ EmulationResult result = harness.run(snapshotPeriod);
+ if (result.error() != null) {
+ setStatusText("Emulation Error: %s".formatted(result.error().getMessage()),
+ MessageType.ERROR);
+ }
+ else if (!sentinel.equals(harness.emuThread.getCounter())) {
+ setStatusText("Emulator interrupted before completion", MessageType.ERROR);
+ }
+ monitor.setMessage("Capturing Outputs");
+ captureOutputs(harness.eval(result.snap()), harness.getProbesOut());
+
+ if (snapshotPeriod != 0) {
+ if (traceManager != null) {
+ monitor.setMessage("Opening Trace");
+ traceManager.openTrace(harness.trace);
+ traceManager.activate(DebuggerCoordinates.NOWHERE
+ .trace(harness.trace)
+ .snap(result.defaultSnap()));
+ }
+
+ if (controlService != null) {
+ controlService.setCurrentMode(harness.trace, ControlMode.RW_EMULATOR);
+ }
+ }
+ }
+ catch (Exception e) {
+ setStatusText(e.getMessage(), MessageType.ERROR);
+ Msg.error(this, "Emulation Setup Error", e);
+ }
+ }
+ }, 500);
+ }
+
+ class InputInitializer {
+ final Eval eval;
+ final Collection<InputRow> inputs;
+ final Map<String, InputRow> remains;
+
+ public InputInitializer(Eval eval, Collection<InputRow> inputs) {
+ this.eval = eval;
+ this.inputs = inputs;
+ this.remains = inputs
+ .stream()
+ .collect(Collectors.toMap(InputRow::getName,
+ java.util.function.Function.identity()));
+ }
+
+ public void initializeInputs() {
+ for (InputRow input : inputs) {
+ initializeInput(input);
+ }
+ }
+
+ public void initializeInput(InputRow input) {
+ if (remains.remove(input.name) == null) {
+ return;
+ }
+ doInitialize(input);
+ }
+
+ public void doInitialize(InputRow input) {
+ initializeDependencies(input);
+ eval.writeVariable(input.storage, input.value);
+ }
+
+ public void initializeDependency(String name) {
+ InputRow input = remains.remove(name);
+ if (input == null) {
+ return;
+ }
+ doInitialize(input);
+ }
+
+ public void initializeDependencies(InputRow input) {
+ for (String dep : input.depsByName) {
+ initializeDependency(dep);
+ }
+ }
+
+ public String toHex(byte[] value, int length) {
+ return Utils.bytesToBigInteger(value, length, language.isBigEndian(), false)
+ .toString(16);
+ }
+
+ public void checkConflicts() {
+ for (InputRow r : inputs) {
+ LocAndVal value = eval.readVariable(r.storage);
+ if (!(Arrays.equals(value.value(), r.value))) {
+ throw new IllegalStateException("Input %s conflicts: 0x%s != 0x%s".formatted(
+ r.storage, toHex(r.value, r.length), toHex(value.value(), r.length)));
+ }
+ }
+ }
+ }
+
+ protected void initializeInputs(Eval eval) {
+ InputInitializer initializer = new InputInitializer(eval, inputsTableModel.getModelData());
+ initializer.initializeInputs();
+ initializer.checkConflicts();
+ eval.commit();
+ }
+
+ protected void captureOutputs(Eval eval, List<ProbeOut> probesOut) {
+ for (OutputRow r : outputsTableModel.copyModelData()) {
+ if (r.name.startsWith(PREFIX_PROBE)) {
+ outputsTableModel.delete(r);
+ }
+ else {
+ LocAndVal value = eval.readVariable(r.storage);
+ r.setValue(value.value());
+ }
+ }
+ CompilerSpec cSpec = function.getProgram().getCompilerSpec();
+ for (int i = 0; i < probesOut.size(); i++) {
+ ProbeOut po = probesOut.get(i);
+ OutputRow row = new OutputRow(language, FMT_PROBE.formatted(i + 1),
+ VarStorage.fromPieces(new Varnode[] { po.vn() }, cSpec), null);
+ row.setValue(po.value());
+ outputsTableModel.add(row);
+ }
+ Swing.runLater(outputsTableModel::fireTableDataChanged);
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/FunctionEmulationHarness.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/FunctionEmulationHarness.java
new file mode 100644
index 0000000000..f4f9c67558
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/FunctionEmulationHarness.java
@@ -0,0 +1,346 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import java.io.IOException;
+import java.util.*;
+
+import db.Transaction;
+import generic.Unique;
+import ghidra.app.plugin.core.debug.gui.emulation.LocAndVal.WriterAndExecutor;
+import ghidra.app.plugin.core.debug.service.breakpoint.ProgramBreakpoint;
+import ghidra.app.plugin.core.debug.service.emulation.DebuggerEmulationIntegration;
+import ghidra.app.plugin.core.debug.service.emulation.ProgramEmulationUtils;
+import ghidra.app.plugin.core.debug.service.emulation.data.TranslatedPcodeDebuggerAccess;
+import ghidra.app.plugin.core.debug.service.modules.DebuggerStaticMappingContext;
+import ghidra.app.plugin.core.debug.service.modules.DebuggerStaticMappingContext.ChangeCollector;
+import ghidra.app.plugin.core.debug.stack.*;
+import ghidra.app.plugin.core.debug.utils.ManagedDomainObject;
+import ghidra.app.plugin.processors.sleigh.SleighLanguage;
+import ghidra.debug.api.breakpoint.LogicalBreakpoint;
+import ghidra.debug.api.emulation.PcodeDebuggerAccess;
+import ghidra.debug.api.modules.DebuggerAddressTranslator;
+import ghidra.debug.api.tracemgr.DebuggerCoordinates;
+import ghidra.framework.plugintool.PluginTool;
+import ghidra.pcode.emu.*;
+import ghidra.pcode.eval.ArithmeticVarnodeEvaluator;
+import ghidra.pcode.exec.*;
+import ghidra.pcode.exec.PcodeArithmetic.Purpose;
+import ghidra.pcode.exec.PcodeExecutorStatePiece.Reason;
+import ghidra.pcode.exec.trace.TraceEmulationIntegration.Writer;
+import ghidra.pcode.utils.Utils;
+import ghidra.program.model.address.Address;
+import ghidra.program.model.lang.*;
+import ghidra.program.model.listing.*;
+import ghidra.program.model.pcode.PcodeOp;
+import ghidra.program.model.pcode.Varnode;
+import ghidra.trace.model.Trace;
+import ghidra.trace.model.guest.TracePlatform;
+import ghidra.trace.model.thread.TraceThread;
+import ghidra.trace.model.time.TraceSnapshot;
+import ghidra.util.Msg;
+import ghidra.util.NumericUtilities;
+import ghidra.util.task.TaskMonitor;
+
+public class FunctionEmulationHarness implements AutoCloseable {
+
+ public record ProbeOut(Varnode vn, byte[] value) {
+ public String toString(Language language) {
+ return "%s = %s (%s)".formatted(vn.toString(language),
+ NumericUtilities.convertBytesToString(value, ":"),
+ Utils.bytesToBigInteger(value, vn.getSize(), language.isBigEndian(), false));
+ }
+ }
+
+ public record ReturnAddressInfo(Address location, long mask) {
+ public Address computePhysicalLocation(Eval eval, CompilerSpec cSpec) {
+ if (location.isMemoryAddress() || location.isRegisterAddress()) {
+ return location;
+ }
+ if (location.isStackAddress()) {
+ Register sp = cSpec.getStackPointer();
+ LocAndVal spVal = eval.state.getVar(sp, Reason.INSPECT);
+ Address stackBase = eval.state.getArithmetic()
+ .toAddress(spVal, cSpec.getStackBaseSpace(), Purpose.INSPECT);
+ return stackBase.add(location.getOffset());
+ }
+ throw new IllegalStateException("Unknown space for return address location");
+ }
+ }
+
+ public ReturnAddressInfo locateReturnAddress() {
+ UnwindAnalysis unwindAnalysis = new UnwindAnalysis(program);
+ try {
+ UnwindInfo unwindInfo = unwindAnalysis.getUnwindInfo(function.getEntryPoint(), monitor);
+ return new ReturnAddressInfo(unwindInfo.ofReturn(), unwindInfo.maskOfReturn());
+ }
+ catch (UnwindException e) {
+ return null;
+ }
+ }
+
+ public static FunctionEmulationHarness start(PluginTool tool, Function function,
+ TaskMonitor monitor) throws IOException {
+ ManagedDomainObject<Trace> mt = new ManagedDomainObject<Trace>(mdo -> ProgramEmulationUtils
+ .launchEmulationTrace(function.getProgram(), function.getEntryPoint(), mdo));
+ return new FunctionEmulationHarness(tool, mt, function, monitor);
+ }
+
+ public class Eval {
+ public final long snap;
+ public final Writer writer;
+ public final PcodeExecutor<LocAndVal> exec;
+ public final PcodeExecutorState<LocAndVal> state;
+
+ private Eval(long snap) {
+ this.snap = snap;
+ WriterAndExecutor we = LocAndVal.buildExecutor(tool, start.snap(snap));
+ this.writer = we.writer();
+ this.exec = we.executor();
+ this.state = exec.getState();
+ }
+
+ public void writeNode(VarStorageNode node, LocAndVal value) {
+ LocAndVal cur = node.compile(language).evaluate(exec);
+ exec.getState().setVar(cur.loc().getAddress(), node.size(), false, value);
+ }
+
+ public void writeVariable(VarStorage storage, LocAndVal value) {
+ int shift = 0;
+ for (VarStorageNode n : storage.nodes()) {
+ LocAndVal piece = lvArith.binaryOp(PcodeOp.INT_RIGHT, n.size(),
+ value.value().length, value, 4, lvArith.fromConst(shift, 4));
+ shift += n.size();
+ writeNode(n, piece);
+ }
+ }
+
+ public void writeVariable(VarStorage storage, byte[] value) {
+ writeVariable(storage, lvArith.fromConst(value));
+ }
+
+ public void commit() {
+ writer.writeDown(snap);
+ }
+
+ public LocAndVal readNode(VarStorageNode node) {
+ return node.compile(language).evaluate(exec);
+ }
+
+ public LocAndVal readVariable(VarStorage storage) {
+ int total = storage.size();
+ LocAndVal value = lvArith.fromConst(0, total);
+ for (VarStorageNode n : storage.nodes()) {
+ LocAndVal piece = readNode(n);
+ value = ArithmeticVarnodeEvaluator.catenate(lvArith, total, value, piece, n.size());
+ }
+ return value;
+ }
+ }
+
+ class MonitoredCallbacks extends ComposedPcodeEmulationCallbacks<byte[]> {
+ public MonitoredCallbacks(PcodeEmulationCallbacks<byte[]> cb) {
+ super(cb);
+ }
+
+ @Override
+ public void beforeStepOp(PcodeThread<byte[]> thread, PcodeOp op, PcodeFrame frame) {
+ if (monitor.isCancelled()) {
+ throw new InterruptPcodeExecutionException(frame, null);
+ }
+ }
+ }
+
+ public class OverrideProbeUseropLibrary extends AnnotatedPcodeUseropLibrary<byte[]> {
+ @PcodeUserop
+ public void emu_probe(@OpExecutor PcodeExecutor<byte[]> exec, Varnode in) {
+ probesOut.add(new ProbeOut(in, exec.getState().getVar(in, Reason.INSPECT)));
+ }
+ }
+
+ class MonitoredEmulator extends PcodeEmulator {
+ public MonitoredEmulator(Language language, PcodeEmulationCallbacks<byte[]> cb) {
+ super(language, new MonitoredCallbacks(cb));
+ }
+
+ @Override
+ protected PcodeUseropLibrary<byte[]> createUseropLibrary() {
+ return super.createUseropLibrary().compose(new OverrideProbeUseropLibrary(), true);
+ }
+ }
+
+ final PluginTool tool;
+ final ManagedDomainObject<Trace> mt;
+ final Transaction tx;
+ public final Trace trace;
+ final TraceThread thread;
+ final DebuggerCoordinates start;
+ final Eval initEval;
+ public final PcodeArithmetic<LocAndVal> lvArith;
+ final SleighLanguage language;
+ final Function function;
+ final Program program;
+ final DebuggerAddressTranslator translator;
+ final TaskMonitor monitor;
+
+ final Writer writer;
+ final PcodeEmulator emulator;
+ final PcodeThread<byte[]> emuThread;
+
+ final List<ProbeOut> probesOut = new ArrayList<>();
+
+ private FunctionEmulationHarness(PluginTool tool, ManagedDomainObject<Trace> mt,
+ Function function, TaskMonitor monitor) {
+ this.tool = tool;
+ this.mt = mt;
+ this.trace = mt.get();
+ this.tx = trace.openTransaction("Emulate");
+ this.thread = Unique.assertOne(trace.getThreadManager().getAllThreads());
+ this.start = DebuggerCoordinates.NOWHERE.thread(thread);
+ this.initEval = new Eval(0);
+ this.lvArith = initEval.exec.getArithmetic();
+ this.language = initEval.exec.getLanguage();
+ this.function = function;
+ this.program = function.getProgram();
+ this.monitor = monitor;
+
+ TracePlatform host = trace.getPlatformManager().getHostPlatform();
+ this.translator = getTranslator();
+ PcodeDebuggerAccess access = new TranslatedPcodeDebuggerAccess(null, host, 0) {
+ @Override
+ public DebuggerAddressTranslator getAddressTranslator() {
+ return translator;
+ }
+ };
+ writer = DebuggerEmulationIntegration.bytesDelayedWriteTrace(access);
+ emulator = new MonitoredEmulator(language, writer.callbacks());
+ emuThread = emulator.newThread(thread.getPath());
+ }
+
+ private DebuggerAddressTranslator getTranslator() {
+ // Don't use the service. It requires the trace and program to be opened in the tool
+ DebuggerStaticMappingContext mapper = new DebuggerStaticMappingContext();
+ try (ChangeCollector cc = mapper.collectChanges()) {
+ mapper.addProgram(cc, program);
+ mapper.addTrace(cc, trace);
+ }
+ return mapper;
+ }
+
+ public Eval init() {
+ return initEval;
+ }
+
+ public Eval eval(long snap) {
+ return new Eval(snap);
+ }
+
+ public void placeSentinel(Address sentinel) {
+ ReturnAddressInfo retInfo = locateReturnAddress();
+ if (retInfo == null) {
+ Address zero = language.getDefaultSpace().getAddress(0);
+ Msg.warn(this,
+ "Could not locate return address. Placing end break at %s".formatted(zero));
+ emulator.addBreakpoint(zero, SleighUtils.CONDITION_ALWAYS);
+ }
+ else {
+ initEval.state.setVar(
+ retInfo.computePhysicalLocation(initEval, program.getCompilerSpec()),
+ language.getProgramCounter().getNumBytes(), false, lvArith.fromConst(sentinel));
+ emulator.addBreakpoint(sentinel.getNewAddress(sentinel.getOffset() & retInfo.mask),
+ SleighUtils.CONDITION_ALWAYS);
+ }
+ }
+
+ public void installInjects() {
+ Iterator<Bookmark> bit = program.getBookmarkManager()
+ .getBookmarksIterator(LogicalBreakpoint.ENABLED_BOOKMARK_TYPE);
+ while (bit.hasNext()) {
+ ProgramBreakpoint brk = ProgramBreakpoint.fromBookmark(program, bit.next());
+ String sleigh = brk.getEmuSleigh();
+ if (sleigh == null || SleighUtils.UNCONDITIONAL_BREAK.equals(sleigh)) {
+ continue;
+ }
+ emulator.inject(brk.getLocation().getAddress(), sleigh);
+ }
+ }
+
+ public void createSnapshot(long snap) {
+ TraceSnapshot snapshot = trace.getTimeManager().getSnapshot(snap, true);
+ snapshot.setDescription("Emulated");
+ snapshot.setEventThread(thread);
+ writer.writeDown(snap);
+ }
+
+ public record EmulationResult(long snap, Throwable error) {
+ /**
+ * In the case we terminate normally, we should probably ensure the {@code return}
+ * instruction highlighted. This can be accomplished by subtracting one from the last snap.
+ * For abnormal termination, I think we should just go to the last snap and let whatever
+ * problem(s) get displayed.
+ *
+ * @return the last snap - 1 if successful, otherwise just the last snap.
+ */
+ public long defaultSnap() {
+ if (error == null) {
+ return snap - 1;
+ }
+ return snap;
+ }
+ }
+
+ public EmulationResult run(long snapshotPeriod) {
+ long snap = 1;
+ boolean makeFinalSnap = false;
+ Throwable error = null;
+ try {
+ if (snapshotPeriod == 0) {
+ makeFinalSnap = true;
+ emuThread.run();
+ throw new AssertionError("Shouldn't happen");
+ }
+ for (;; snap += 1) {
+ emuThread.stepInstruction();
+ makeFinalSnap = true;
+ emuThread.stepInstruction(snapshotPeriod - 1);
+ createSnapshot(snap);
+ makeFinalSnap = false;
+ }
+ }
+ catch (InterruptPcodeExecutionException e) {
+ // Expected, but snap is now one ahead of the last snapshot
+ snap--;
+ }
+ catch (Throwable t) {
+ error = t;
+ snap--;
+ }
+ if (makeFinalSnap) {
+ createSnapshot(++snap);
+ }
+ return new EmulationResult(snap, error);
+ }
+
+ public List<ProbeOut> getProbesOut() {
+ return probesOut;
+ }
+
+ @Override
+ public void close() {
+ tx.close();
+ mt.close();
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/InputColumn.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/InputColumn.java
new file mode 100644
index 0000000000..532c3e7cdd
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/InputColumn.java
@@ -0,0 +1,92 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+
+import javax.swing.table.TableCellEditor;
+
+import docking.widgets.table.CustomToStringCellRenderer;
+import docking.widgets.table.EnumeratedTableColumn;
+import ghidra.program.model.data.DataType;
+import ghidra.util.table.column.GColumnRenderer;
+
+enum InputColumn implements EnumeratedTableColumn<InputColumn, InputRow> {
+ NAME("Name", String.class, InputRow::getName),
+ STORAGE("Storage", VarStorage.class, InputRow::getStorage),
+ VALUE("Value", String.class, InputRow::getValueStr, InputRow::setValueStr) {
+ @Override
+ public GColumnRenderer<?> getRenderer() {
+ return CustomToStringCellRenderer.MONO_OBJECT;
+ }
+ },
+ TYPE("Type", DataType.class, InputRow::getType, InputRow::setType) {
+ @Override
+ public TableCellEditor getEditor() {
+ return VarDataTypeEditor.INSTANCE;
+ }
+ },
+ REPR("Repr", String.class, InputRow::getRepr, InputRow::setRepr) {
+ @Override
+ public boolean isEditable(InputRow row) {
+ return row.isReprEditable();
+ }
+ };
+
+ final String header;
+ final Class<?> cls;
+ final Function<InputRow, Object> getter;
+ final BiConsumer<InputRow, Object> setter;
+
+ @SuppressWarnings("unchecked")
+ private <T> InputColumn(String header, Class<T> cls, Function<InputRow, T> getter,
+ BiConsumer<InputRow, T> setter) {
+ this.header = header;
+ this.cls = cls;
+ this.getter = (Function<InputRow, Object>) getter;
+ this.setter = (BiConsumer<InputRow, Object>) setter;
+ }
+
+ private <T> InputColumn(String header, Class<T> cls, Function<InputRow, T> getter) {
+ this(header, cls, getter, null);
+ }
+
+ @Override
+ public Class<?> getValueClass() {
+ return cls;
+ }
+
+ @Override
+ public Object getValueOf(InputRow row) {
+ return getter.apply(row);
+ }
+
+ @Override
+ public boolean isEditable(InputRow row) {
+ return setter != null;
+ }
+
+ @Override
+ public void setValueOf(InputRow row, Object value) {
+ setter.accept(row, value);
+ }
+
+ @Override
+ public String getHeader() {
+ return header;
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/InputRow.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/InputRow.java
new file mode 100644
index 0000000000..de70aecdcb
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/InputRow.java
@@ -0,0 +1,81 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import java.util.Arrays;
+import java.util.Set;
+
+import ghidra.program.model.data.DataType;
+import ghidra.program.model.data.DataTypeEncodeException;
+import ghidra.program.model.lang.CompilerSpec;
+import ghidra.program.model.lang.Language;
+import ghidra.program.model.listing.Variable;
+import ghidra.program.model.mem.ByteMemBufferImpl;
+import ghidra.program.model.mem.MemBuffer;
+
+class InputRow extends VarRow {
+ static InputRow fromVariable(Variable v, CompilerSpec cSpec) {
+ return VarRow.fromVariable(InputRow::new, v, cSpec);
+ }
+
+ final Set<String> depsByName; // Use names since the actual row can be replaced by refresh
+
+ InputRow(Language language, String name, VarStorage storage, DataType type,
+ Set<String> depsByName) {
+ super(language, name, storage, type);
+ this.depsByName = depsByName;
+ }
+
+ InputRow(Language language, String name, VarStorage storage, DataType type) {
+ this(language, name, storage, type, Set.of());
+ }
+
+ private void encodeRepr() throws DataTypeEncodeException {
+ MemBuffer buf = new ByteMemBufferImpl(address, value, language.isBigEndian());
+ byte[] data = type.encodeRepresentation(repr, buf, settings, length);
+ if (data.length == length) {
+ value = data;
+ }
+ else {
+ value = Arrays.copyOf(data, length);
+ }
+ }
+
+ void setValueStr(String string) {
+ RawStyle style = RawStyle.fromString(string);
+ byte[] value = style.fromString(string, length, language);
+ this.style = style;
+ this.value = value;
+ decodeValue();
+ }
+
+ void setRepr(String repr) {
+ String oldRepr = this.repr;
+ this.repr = repr;
+ try {
+ encodeRepr();
+ decodeValue();
+ }
+ catch (DataTypeEncodeException e) {
+ this.repr = oldRepr;
+ throw new IllegalArgumentException(e.getMessage(), e);
+ }
+ }
+
+ boolean isReprEditable() {
+ return repr != null && type.isEncodable();
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/InputsTableModel.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/InputsTableModel.java
new file mode 100644
index 0000000000..5dc44d4bde
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/InputsTableModel.java
@@ -0,0 +1,24 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import ghidra.framework.plugintool.ServiceProvider;
+
+class InputsTableModel extends VarTableModel<InputColumn, InputRow> {
+ public InputsTableModel(ServiceProvider tool, DebuggerEmulateFunctionDialog dialog) {
+ super(tool, "Inputs", InputColumn.class, dialog);
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/LocAndVal.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/LocAndVal.java
new file mode 100644
index 0000000000..09a51e4639
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/LocAndVal.java
@@ -0,0 +1,266 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.stream.Stream;
+
+import ghidra.app.plugin.core.debug.service.emulation.Mode;
+import ghidra.app.plugin.processors.sleigh.SleighLanguage;
+import ghidra.debug.api.tracemgr.DebuggerCoordinates;
+import ghidra.framework.plugintool.ServiceProvider;
+import ghidra.pcode.exec.*;
+import ghidra.pcode.exec.PcodeArithmetic.Purpose;
+import ghidra.pcode.exec.PcodeExecutorStatePiece.Reason;
+import ghidra.pcode.exec.trace.TraceEmulationIntegration.Writer;
+import ghidra.pcode.exec.trace.data.DefaultPcodeTraceAccess;
+import ghidra.pcode.exec.trace.data.PcodeTraceDataAccess;
+import ghidra.program.model.address.Address;
+import ghidra.program.model.address.AddressSpace;
+import ghidra.program.model.lang.*;
+import ghidra.program.model.mem.MemBuffer;
+import ghidra.trace.model.guest.TracePlatform;
+
+public record LocAndVal(byte[] value, ValueLocation loc) {
+ public enum LocAndValPcodeArithmetic implements PcodeArithmetic<LocAndVal> {
+ BIG_ENDIAN(BytesPcodeArithmetic.BIG_ENDIAN, LocationPcodeArithmetic.BIG_ENDIAN),
+ LITTLE_ENDIAN(BytesPcodeArithmetic.LITTLE_ENDIAN, LocationPcodeArithmetic.BIG_ENDIAN);
+
+ public static LocAndValPcodeArithmetic forEndian(boolean isBigEndian) {
+ return isBigEndian ? BIG_ENDIAN : LITTLE_ENDIAN;
+ }
+
+ public static LocAndValPcodeArithmetic forLanguage(Language language) {
+ return forEndian(language.isBigEndian());
+ }
+
+ private final BytesPcodeArithmetic bytes;
+ private final LocationPcodeArithmetic location;
+
+ private LocAndValPcodeArithmetic(BytesPcodeArithmetic bytes,
+ LocationPcodeArithmetic location) {
+ this.bytes = bytes;
+ this.location = location;
+ }
+
+ @Override
+ public Class<LocAndVal> getDomain() {
+ return LocAndVal.class;
+ }
+
+ @Override
+ public Endian getEndian() {
+ return bytes.getEndian();
+ }
+
+ @Override
+ public LocAndVal unaryOp(int opcode, int sizeout, int sizein1, LocAndVal in1) {
+ return new LocAndVal(
+ bytes.unaryOp(opcode, sizeout, sizein1, in1.value),
+ location.unaryOp(opcode, sizeout, sizein1, in1.loc));
+ }
+
+ @Override
+ public LocAndVal binaryOp(int opcode, int sizeout, int sizein1, LocAndVal in1, int sizein2,
+ LocAndVal in2) {
+ return new LocAndVal(
+ bytes.binaryOp(opcode, sizeout, sizein1, in1.value, sizein2, in2.value),
+ location.binaryOp(opcode, sizeout, sizein1, in1.loc, sizein2, in2.loc));
+ }
+
+ @Override
+ public LocAndVal modBeforeStore(int sizeinOffset, AddressSpace space, LocAndVal inOffset,
+ int sizeinValue, LocAndVal inValue) {
+ return new LocAndVal(
+ bytes.modBeforeStore(sizeinOffset, space, inOffset.value, sizeinValue,
+ inValue.value),
+ location.modBeforeStore(sizeinOffset, space, inOffset.loc, sizeinValue,
+ inValue.loc));
+ }
+
+ @Override
+ public LocAndVal modAfterLoad(int sizeinOffset, AddressSpace space, LocAndVal inOffset,
+ int sizeinValue, LocAndVal inValue) {
+ return new LocAndVal(
+ bytes.modAfterLoad(sizeinOffset, space, inOffset.value, sizeinValue, inValue.value),
+ location.modAfterLoad(sizeinOffset, space, inOffset.loc, sizeinValue, inValue.loc));
+ }
+
+ @Override
+ public LocAndVal fromConst(byte[] value) {
+ return new LocAndVal(
+ bytes.fromConst(value),
+ location.fromConst(value));
+ }
+
+ @Override
+ public byte[] toConcrete(LocAndVal value, Purpose purpose) {
+ return bytes.toConcrete(value.value, purpose);
+ }
+
+ @Override
+ public long sizeOf(LocAndVal value) {
+ return bytes.sizeOf(value.value);
+ }
+ }
+
+ public static class LocAndValPcodeExecutorStatePiece
+ implements PcodeExecutorStatePiece<byte[], LocAndVal> {
+ private final PcodeExecutorStatePiece<byte[], byte[]> bytesPiece;
+ private final PcodeExecutorStatePiece<byte[], ValueLocation> locationPiece;
+
+ private final PcodeArithmetic<LocAndVal> arithmetic;
+
+ public LocAndValPcodeExecutorStatePiece(
+ PcodeExecutorStatePiece<byte[], byte[]> bytesPiece,
+ PcodeExecutorStatePiece<byte[], ValueLocation> locationPiece) {
+ this.bytesPiece = bytesPiece;
+ this.locationPiece = locationPiece;
+ this.arithmetic = LocAndValPcodeArithmetic.forLanguage(bytesPiece.getLanguage());
+ }
+
+ @Override
+ public Language getLanguage() {
+ return bytesPiece.getLanguage();
+ }
+
+ @Override
+ public PcodeArithmetic<byte[]> getAddressArithmetic() {
+ return bytesPiece.getAddressArithmetic();
+ }
+
+ @Override
+ public PcodeArithmetic<LocAndVal> getArithmetic() {
+ return arithmetic;
+ }
+
+ @Override
+ public Stream<PcodeExecutorStatePiece<?, ?>> streamPieces() {
+ return Stream.of(bytesPiece, locationPiece);
+ }
+
+ @Override
+ public LocAndValPcodeExecutorStatePiece fork(PcodeStateCallbacks cb) {
+ return new LocAndValPcodeExecutorStatePiece(
+ bytesPiece.fork(cb),
+ locationPiece.fork(cb));
+ }
+
+ @Override
+ public void setVarInternal(AddressSpace space, byte[] offset, int size, LocAndVal val) {
+ bytesPiece.setVarInternal(space, offset, size, val.value);
+ locationPiece.setVarInternal(space, offset, size, val.loc);
+ }
+
+ @Override
+ public void setVar(AddressSpace space, byte[] offset, int size, boolean quantize,
+ LocAndVal val) {
+ bytesPiece.setVar(space, offset, size, quantize, val.value);
+ locationPiece.setVar(space, offset, size, quantize, val.loc);
+ }
+
+ @Override
+ public LocAndVal getVar(AddressSpace space, byte[] offset, int size, boolean quantize,
+ Reason reason) {
+ return new LocAndVal(
+ bytesPiece.getVar(space, offset, size, quantize, reason),
+ locationPiece.getVar(space, offset, size, quantize, reason));
+ }
+
+ @Override
+ public LocAndVal getVarInternal(AddressSpace space, byte[] offset, int size,
+ Reason reason) {
+ return new LocAndVal(
+ bytesPiece.getVarInternal(space, offset, size, reason),
+ locationPiece.getVarInternal(space, offset, size, reason));
+ }
+
+ @Override
+ public Map<Register, LocAndVal> getRegisterValues() {
+ Map<Register, LocAndVal> result = new HashMap<>();
+ for (Entry<Register, byte[]> entry : bytesPiece.getRegisterValues().entrySet()) {
+ Register reg = entry.getKey();
+ AddressSpace space = reg.getAddressSpace();
+ long offset = reg.getAddress().getOffset();
+ int size = reg.getNumBytes();
+ result.put(reg, new LocAndVal(
+ entry.getValue(),
+ locationPiece.getVar(space, offset, size, false, Reason.INSPECT)));
+ }
+ return result;
+ }
+
+ @Override
+ public MemBuffer getConcreteBuffer(Address address, Purpose purpose) {
+ return bytesPiece.getConcreteBuffer(address, purpose);
+ }
+
+ @Override
+ public void clear() {
+ bytesPiece.clear();
+ locationPiece.clear();
+ }
+ }
+
+ public static class LocAndValPcodeExecutorState
+ extends AbstractPcodeExecutorState<byte[], LocAndVal> {
+
+ public LocAndValPcodeExecutorState(PcodeExecutorStatePiece<byte[], LocAndVal> piece) {
+ super(piece);
+ }
+
+ @Override
+ protected byte[] extractAddress(LocAndVal value) {
+ return value.value;
+ }
+
+ @Override
+ public LocAndValPcodeExecutorState fork(PcodeStateCallbacks cb) {
+ return new LocAndValPcodeExecutorState(piece.fork(cb));
+ }
+ }
+
+ public record WriterAndState(Writer writer, LocAndValPcodeExecutorState state) {}
+
+ public static WriterAndState buildState(ServiceProvider provider,
+ DebuggerCoordinates coordinates) {
+ PcodeTraceDataAccess data = new DefaultPcodeTraceAccess(coordinates.getPlatform(),
+ coordinates.getViewSnap(), coordinates.getSnap())
+ .getDataForThreadState(coordinates.getThread(), coordinates.getFrame());
+ // Seems weird, but RO is in terms of the Target. RO writes the Trace.
+ DebuggerPcodeUtils.WriterAndState ws =
+ DebuggerPcodeUtils.executorStateForCoordinates(provider, coordinates, Mode.RO);
+ return new WriterAndState(ws.writer(),
+ new LocAndValPcodeExecutorState(new LocAndValPcodeExecutorStatePiece(ws.state(),
+ new LocationPcodeExecutorStatePiece(data.getLanguage()))));
+ }
+
+ public record WriterAndExecutor(Writer writer, PcodeExecutor<LocAndVal> executor) {}
+
+ public static WriterAndExecutor buildExecutor(ServiceProvider provider,
+ DebuggerCoordinates coordinates) {
+ TracePlatform platform = coordinates.getPlatform();
+ Language language = platform.getLanguage();
+ if (!(language instanceof SleighLanguage slang)) {
+ throw new IllegalArgumentException("Emulation requires a Sleigh language");
+ }
+ WriterAndState ws = buildState(provider, coordinates);
+ return new WriterAndExecutor(ws.writer,
+ new PcodeExecutor<>(slang, ws.state.getArithmetic(), ws.state, Reason.INSPECT));
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/LongInputVerifier.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/LongInputVerifier.java
new file mode 100644
index 0000000000..22ffc21507
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/LongInputVerifier.java
@@ -0,0 +1,48 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import java.math.BigInteger;
+
+import javax.swing.*;
+
+public abstract class LongInputVerifier extends InputVerifier {
+ @Override
+ public boolean verify(JComponent input) {
+ if (!(input instanceof JTextField text)) {
+ throw new IllegalArgumentException(
+ "Only JTextField is supported. Got %s".formatted(input.getClass()));
+ }
+ String str = text.getText();
+ try {
+ BigInteger value = new BigInteger(str);
+ long l = value.longValueExact();
+ if (!verifyLong(l)) {
+ reject("Invalid value: %s".formatted(str));
+ return false;
+ }
+ return true;
+ }
+ catch (Exception e) {
+ reject("%s while parsing '%s'".formatted(e.getMessage(), str));
+ return false;
+ }
+ }
+
+ protected abstract boolean verifyLong(long value);
+
+ protected abstract void reject(String message);
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/OutputColumn.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/OutputColumn.java
new file mode 100644
index 0000000000..73130d2d5b
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/OutputColumn.java
@@ -0,0 +1,87 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import java.util.function.BiConsumer;
+import java.util.function.Function;
+
+import javax.swing.table.TableCellEditor;
+
+import docking.widgets.table.CustomToStringCellRenderer;
+import docking.widgets.table.EnumeratedTableColumn;
+import ghidra.program.model.data.DataType;
+import ghidra.util.table.column.GColumnRenderer;
+
+enum OutputColumn implements EnumeratedTableColumn<OutputColumn, OutputRow> {
+ NAME("Name", String.class, OutputRow::getName),
+ STORAGE("Storage", VarStorage.class, OutputRow::getStorage),
+ VALUE("Value", String.class, OutputRow::getValueStr) {
+ @Override
+ public GColumnRenderer<?> getRenderer() {
+ return CustomToStringCellRenderer.MONO_OBJECT;
+ }
+ },
+ TYPE("Type", DataType.class, OutputRow::getType, OutputRow::setType) {
+ @Override
+ public TableCellEditor getEditor() {
+ return VarDataTypeEditor.INSTANCE;
+ }
+ },
+ REPR("Repr", String.class, OutputRow::getRepr);
+
+ final String header;
+ final Class<?> cls;
+ final Function<OutputRow, Object> getter;
+ final BiConsumer<OutputRow, Object> setter;
+
+ @SuppressWarnings("unchecked")
+ private <T> OutputColumn(String header, Class<T> cls, Function<OutputRow, T> getter,
+ BiConsumer<OutputRow, T> setter) {
+ this.header = header;
+ this.cls = cls;
+ this.getter = (Function<OutputRow, Object>) getter;
+ this.setter = (BiConsumer<OutputRow, Object>) setter;
+ }
+
+ private <T> OutputColumn(String header, Class<T> cls, Function<OutputRow, T> getter) {
+ this(header, cls, getter, null);
+ }
+
+ @Override
+ public Class<?> getValueClass() {
+ return cls;
+ }
+
+ @Override
+ public Object getValueOf(OutputRow row) {
+ return getter.apply(row);
+ }
+
+ @Override
+ public boolean isEditable(OutputRow row) {
+ return setter != null;
+ }
+
+ @Override
+ public void setValueOf(OutputRow row, Object value) {
+ setter.accept(row, value);
+ }
+
+ @Override
+ public String getHeader() {
+ return header;
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/OutputRow.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/OutputRow.java
new file mode 100644
index 0000000000..6e5bc06bed
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/OutputRow.java
@@ -0,0 +1,31 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import ghidra.program.model.data.DataType;
+import ghidra.program.model.lang.CompilerSpec;
+import ghidra.program.model.lang.Language;
+import ghidra.program.model.listing.Variable;
+
+class OutputRow extends VarRow {
+ static OutputRow fromVariable(Variable v, CompilerSpec cSpec) {
+ return VarRow.fromVariable(OutputRow::new, v, cSpec);
+ }
+
+ OutputRow(Language language, String name, VarStorage storage, DataType type) {
+ super(language, name, storage, type);
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/OutputsTableModel.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/OutputsTableModel.java
new file mode 100644
index 0000000000..084e24ffef
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/OutputsTableModel.java
@@ -0,0 +1,24 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import ghidra.framework.plugintool.ServiceProvider;
+
+public class OutputsTableModel extends VarTableModel<OutputColumn, OutputRow> {
+ public OutputsTableModel(ServiceProvider tool, DebuggerEmulateFunctionDialog dialog) {
+ super(tool, "Outputs", OutputColumn.class, dialog);
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/RawStyle.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/RawStyle.java
new file mode 100644
index 0000000000..e53d80ded8
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/RawStyle.java
@@ -0,0 +1,83 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import java.math.BigInteger;
+import java.util.Arrays;
+
+import ghidra.pcode.utils.Utils;
+import ghidra.program.model.address.AddressSpace;
+import ghidra.program.model.lang.Language;
+import ghidra.util.NumericUtilities;
+
+// LATER: Move this into some utilities and have DefaultWatchRow use it, too?
+enum RawStyle {
+ INTEGER {
+ @Override
+ String toString(byte[] value, Language language) {
+ if (value == null) {
+ return "";
+ }
+ BigInteger asInt =
+ Utils.bytesToBigInteger(value, value.length, language.isBigEndian(), false);
+ return "0x" + asInt.toString(16);
+ }
+
+ @Override
+ byte[] fromString(String string, int length, Language language) {
+ string = string.trim();
+ final BigInteger asInt = string.startsWith("0x")
+ ? new BigInteger(string.substring(2), 16)
+ : new BigInteger(string, 10);
+ return Utils.bigIntegerToBytes(asInt, length, language.isBigEndian());
+ }
+ },
+ BYTES {
+ @Override
+ String toString(byte[] value, Language language) {
+ if (value == null) {
+ return "";
+ }
+ return "{ %s }".formatted(NumericUtilities.convertBytesToString(value, " "));
+ }
+
+ @Override
+ byte[] fromString(String string, int length, Language language) {
+ string = string.trim();
+ if (!string.startsWith("{") && string.endsWith("}")) {
+ throw new IllegalArgumentException(string);
+ }
+ string = string.substring(1, string.length() - 1);
+ byte[] data = NumericUtilities.convertStringToBytes(string);
+ if (data.length == length) {
+ return data;
+ }
+ return Arrays.copyOf(data, length);
+ }
+ };
+
+ static RawStyle defaultForSpace(AddressSpace space) {
+ return space.isMemorySpace() ? BYTES : INTEGER;
+ }
+
+ static RawStyle fromString(String string) {
+ return string.trim().startsWith("{") ? BYTES : INTEGER;
+ }
+
+ abstract String toString(byte[] value, Language language);
+
+ abstract byte[] fromString(String string, int length, Language language);
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/VarDataTypeEditor.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/VarDataTypeEditor.java
new file mode 100644
index 0000000000..d8341c4c87
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/VarDataTypeEditor.java
@@ -0,0 +1,67 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import javax.swing.table.TableModel;
+
+import db.Transaction;
+import ghidra.app.services.DataTypeManagerService;
+import ghidra.base.widgets.table.AbstractDataTypeTableCellEditor;
+import ghidra.program.model.data.DataType;
+import ghidra.program.model.listing.Program;
+
+class VarDataTypeEditor extends AbstractDataTypeTableCellEditor {
+ static final VarDataTypeEditor INSTANCE = new VarDataTypeEditor();
+
+ @Override
+ protected boolean validateSelection(DataType dataType, TableModel model) {
+ if (!(model instanceof VarTableModel<?, ?> vModel)) {
+ return false;
+ }
+
+ VarRow row = vModel.getModelData().get(table.getEditingRow());
+ if (row == null) {
+ return false;
+ }
+ int dtLength = dataType.getLength();
+ if (dtLength != -1 && dtLength != row.length) {
+ vModel.getDialog()
+ .setStatusText("Invalid DataType %s. Length must be %d.".formatted(dataType,
+ row.length));
+ return false;
+ }
+ return true;
+ }
+
+ @Override
+ protected DataTypeManagerService getService(TableModel model) {
+ if (!(model instanceof VarTableModel<?, ?> vModel)) {
+ return null;
+ }
+ return vModel.getServiceProvider().getService(DataTypeManagerService.class);
+ }
+
+ @Override
+ protected DataType resolveSelection(DataType dataType, TableModel model) {
+ if (dataType == null || !(model instanceof VarTableModel<?, ?> vModel)) {
+ return null;
+ }
+ Program program = vModel.getProgram();
+ try (Transaction tx = program.openTransaction("Resolve DataTye")) {
+ return program.getDataTypeManager().resolve(dataType, null);
+ }
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/VarRow.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/VarRow.java
new file mode 100644
index 0000000000..b3ed488342
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/VarRow.java
@@ -0,0 +1,134 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import java.util.Objects;
+
+import ghidra.docking.settings.SettingsImpl;
+import ghidra.program.model.address.Address;
+import ghidra.program.model.data.DataType;
+import ghidra.program.model.lang.CompilerSpec;
+import ghidra.program.model.lang.Language;
+import ghidra.program.model.listing.Variable;
+import ghidra.program.model.listing.VariableStorage;
+import ghidra.program.model.mem.ByteMemBufferImpl;
+import ghidra.program.model.mem.MemBuffer;
+import ghidra.util.Msg;
+
+abstract class VarRow {
+ interface VarRowFactory<T extends VarRow> {
+ T create(Language language, String name, VarStorage storage, DataType type);
+ }
+
+ static <T extends VarRow> T fromVariable(VarRowFactory<T> cons, Variable v,
+ CompilerSpec cSpec) {
+ VariableStorage storage = v.getVariableStorage();
+ return cons.create(cSpec.getLanguage(), v.getName(),
+ VarStorage.fromVariableStorage(storage, cSpec), v.getDataType());
+ }
+
+ final Language language;
+ final String name;
+ final VarStorage storage;
+ final int length;
+ final Address address;
+ final SettingsImpl settings = new SettingsImpl();
+
+ byte[] value;
+ String repr;
+ DataType type;
+
+ RawStyle style;
+
+ VarRow(Language language, String name, VarStorage storage, DataType type) {
+ this.language = language;
+ this.name = name;
+ this.storage = storage;
+ this.length = storage.size();
+ this.address = storage.address();
+
+ this.value = new byte[storage.size()];
+ this.type = type;
+ this.style = RawStyle.defaultForSpace(address.getAddressSpace());
+
+ decodeValue();
+ }
+
+ void decodeValue() {
+ try {
+ if (type == null) {
+ repr = null;
+ return;
+ }
+ MemBuffer buf = new ByteMemBufferImpl(address, value, language.isBigEndian()) {
+ @Override
+ public Language getLanguage() {
+ return language;
+ }
+ };
+ repr = type.getRepresentation(buf, settings, length);
+ }
+ catch (Exception e) {
+ Msg.error(this, e.getMessage());
+ repr = null;
+ }
+ }
+
+ String getName() {
+ return name;
+ }
+
+ VarStorage getStorage() {
+ return storage;
+ }
+
+ void setType(DataType type) {
+ this.type = type;
+ decodeValue();
+ }
+
+ DataType getType() {
+ return type;
+ }
+
+ SettingsImpl getSettings() {
+ return settings;
+ }
+
+ void settingsChanged() {
+ decodeValue();
+ }
+
+ void setValue(byte[] value) {
+ if (value.length != storage.size()) {
+ throw new IllegalArgumentException("Length mismatch");
+ }
+ this.value = value;
+ decodeValue();
+ }
+
+ byte[] getValue() {
+ return value;
+ }
+
+ String getValueStr() {
+ return style.toString(value, language);
+ }
+
+ String getRepr() {
+ return Objects.requireNonNullElse(repr, "");
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/VarStorage.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/VarStorage.java
new file mode 100644
index 0000000000..7cc11b0968
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/VarStorage.java
@@ -0,0 +1,77 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import java.util.List;
+import java.util.stream.Stream;
+
+import ghidra.app.plugin.processors.sleigh.SleighLanguage;
+import ghidra.program.model.address.Address;
+import ghidra.program.model.address.AddressSpace;
+import ghidra.program.model.lang.CompilerSpec;
+import ghidra.program.model.listing.VariableStorage;
+import ghidra.program.model.pcode.Varnode;
+
+record VarStorage(List<VarStorageNode> nodes, int size) {
+ static VarStorage fromPieces(Varnode[] pieces, CompilerSpec cSpec) {
+ return new VarStorage(Stream.of(pieces)
+ .map(vn -> VarStorageNode.fromVarnode(vn, cSpec))
+ .toList());
+ }
+
+ static VarStorage fromVariableStorage(VariableStorage vs, CompilerSpec cSpec) {
+ return fromPieces(vs.getVarnodes(), cSpec);
+ }
+
+ static VarStorage fromExpression(SleighLanguage language, String expression) {
+ // TODO: Could break ValueLocation down into its Varnodes, but what's that buy?
+ return new VarStorage(List.of(VarStorageNode.fromExpression(language, expression)));
+ }
+
+ VarStorage(List<VarStorageNode> nodes) {
+ this(nodes, nodes.stream().mapToInt(VarStorageNode::size).sum());
+ }
+
+ Address address() {
+ return nodes.getFirst().address();
+ }
+
+ @Override
+ public final String toString() {
+ if (nodes.size() == 1) {
+ return nodes.getFirst().toString();
+ }
+ return nodes.toString();
+ }
+
+ public VarStorage deref(SleighLanguage language, AddressSpace space, int length) {
+ if (nodes.size() != 1) {
+ throw new UnsupportedOperationException("Deref of multi-node storage not supported");
+ }
+ return new VarStorage(List.of(nodes.getFirst().deref(language, space, length)), length);
+ }
+
+ public VarStorage deref(SleighLanguage language, AddressSpace space, int offset, int length) {
+ if (offset == 0) {
+ return deref(language, space, length);
+ }
+ if (nodes.size() != 1) {
+ throw new UnsupportedOperationException("Deref of multi-node storage not supported");
+ }
+ return new VarStorage(List.of(nodes.getFirst().deref(language, space, offset, length)),
+ length);
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/VarStorageNode.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/VarStorageNode.java
new file mode 100644
index 0000000000..f3c9118535
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/VarStorageNode.java
@@ -0,0 +1,85 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import ghidra.app.plugin.core.debug.gui.emulation.LocAndVal.LocAndValPcodeExecutorState;
+import ghidra.app.plugin.core.debug.gui.emulation.LocAndVal.LocAndValPcodeExecutorStatePiece;
+import ghidra.app.plugin.processors.sleigh.SleighLanguage;
+import ghidra.pcode.exec.*;
+import ghidra.pcode.exec.PcodeExecutorStatePiece.Reason;
+import ghidra.program.model.address.Address;
+import ghidra.program.model.address.AddressSpace;
+import ghidra.program.model.lang.CompilerSpec;
+import ghidra.program.model.pcode.Varnode;
+
+// TODO: Consider using Varnode with defining op
+// TODO: Consider compiling in the constructor? Would need language.
+record VarStorageNode(String expr, Address address, int size) {
+ static VarStorageNode fromVarnode(Varnode vn, CompilerSpec cSpec) {
+ Address address = vn.getAddress();
+ if (address.isStackAddress()) {
+ return new VarStorageNode("*:%d (%s + 0x%x)".formatted(vn.getSize(),
+ cSpec.getStackPointer(), address.getOffset()),
+ cSpec.getStackBaseSpace().getAddress(0), vn.getSize());
+ }
+ if (address.isMemoryAddress()) {
+ return new VarStorageNode("*:%d 0x%08x".formatted(vn.getSize(), vn.getOffset()),
+ address, vn.getSize());
+ }
+ if (address.isRegisterAddress()) {
+ return new VarStorageNode(vn.toString(cSpec.getLanguage()), address, vn.getSize());
+ }
+ if (address.isUniqueAddress()) {
+ return new VarStorageNode("$Unique", address, vn.getSize());
+ }
+ throw new AssertionError();
+ }
+
+ static VarStorageNode fromExpression(SleighLanguage language, String expression) {
+ PcodeExpression expr = SleighProgramCompiler.compileExpression(language, expression);
+ LocAndValPcodeExecutorState state =
+ new LocAndValPcodeExecutorState(new LocAndValPcodeExecutorStatePiece(
+ new BytesPcodeExecutorState(language, PcodeStateCallbacks.NONE),
+ new LocationPcodeExecutorStatePiece(language)));
+ PcodeExecutor<LocAndVal> exec = new PcodeExecutor<LocAndVal>(state, Reason.INSPECT);
+ ValueLocation loc = expr.evaluate(exec).loc();
+ return new VarStorageNode(expression, loc.getAddress(), loc.size());
+ }
+
+ PcodeExpression compile(SleighLanguage language) {
+ return SleighProgramCompiler.compileExpression(language, expr);
+ }
+
+ @Override
+ public final String toString() {
+ return expr;
+ }
+
+ public VarStorageNode deref(SleighLanguage language, AddressSpace space, int length) {
+ String derefExpr = space == language.getDefaultDataSpace()
+ ? "*:%d (%s)".formatted(length, expr)
+ : "*[%s]:%d (%s)".formatted(space.getName(), length, expr);
+ return new VarStorageNode(derefExpr, space.getAddress(0), length);
+ }
+
+ public VarStorageNode deref(SleighLanguage language, AddressSpace space, int offset,
+ int length) {
+ String derefExpr = space == language.getDefaultDataSpace()
+ ? "*:%d ((%s)+%d)".formatted(length, expr, offset)
+ : "*[%s]:%d ((%s)+%d)".formatted(space.getName(), length, expr, offset);
+ return new VarStorageNode(derefExpr, space.getAddress(0), length);
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/VarTableModel.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/VarTableModel.java
new file mode 100644
index 0000000000..9d37210136
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/emulation/VarTableModel.java
@@ -0,0 +1,69 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import docking.widgets.table.DefaultEnumeratedColumnTableModel;
+import docking.widgets.table.EnumeratedTableColumn;
+import ghidra.framework.plugintool.ServiceProvider;
+import ghidra.program.model.data.DataTypeManager;
+import ghidra.program.model.listing.Function;
+import ghidra.program.model.listing.Program;
+import ghidra.util.MessageType;
+
+class VarTableModel<C extends java.lang.Enum<C> & EnumeratedTableColumn<C, R>, R extends VarRow>
+ extends DefaultEnumeratedColumnTableModel<C, R> {
+
+ protected final DebuggerEmulateFunctionDialog dialog;
+ protected final Function function;
+
+ public VarTableModel(ServiceProvider tool, String name, Class<C> colType,
+ DebuggerEmulateFunctionDialog dialog) {
+ super(tool, name, colType);
+ this.dialog = dialog;
+ this.function = dialog.function;
+ }
+
+ ServiceProvider getServiceProvider() {
+ return serviceProvider;
+ }
+
+ Function getFunction() {
+ return function;
+ }
+
+ Program getProgram() {
+ return function.getProgram();
+ }
+
+ DataTypeManager getDataTypeManager() {
+ return function.getProgram().getDataTypeManager();
+ }
+
+ @Override
+ public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
+ try {
+ super.setValueAt(aValue, rowIndex, columnIndex);
+ dialog.clearStatusText();
+ }
+ catch (Exception e) {
+ dialog.setStatusText(e.getMessage(), MessageType.ERROR);
+ }
+ }
+
+ DebuggerEmulateFunctionDialog getDialog() {
+ return dialog;
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/watch/DefaultWatchRow.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/watch/DefaultWatchRow.java
index 32454897d5..c557659d3d 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/watch/DefaultWatchRow.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/watch/DefaultWatchRow.java
@@ -61,7 +61,7 @@ public class DefaultWatchRow implements WatchRow {
private String expression;
private String typePath;
private DataType dataType;
- private SettingsImpl settings = new SettingsImpl();
+ private final SettingsImpl settings = new SettingsImpl();
private SavedSettings savedSettings = new SavedSettings(settings);
private String comment;
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/breakpoint/ProgramBreakpoint.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/breakpoint/ProgramBreakpoint.java
index 809e7af3d6..2a03ac3cb7 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/breakpoint/ProgramBreakpoint.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/breakpoint/ProgramBreakpoint.java
@@ -48,7 +48,7 @@ public class ProgramBreakpoint {
private static final Gson GSON = new GsonBuilder().create();
/**
- * A class for (de)serializing breakoint properties in the bookmark's comments
+ * A class for (de)serializing breakpoint properties in the bookmark's comments
*/
static class BreakpointProperties {
public String name;
@@ -106,6 +106,25 @@ public class ProgramBreakpoint {
}
}
+ /**
+ * Produce a breakpoint from its bookmark (utility).
+ * <p>
+ * The breakpoint manager does not ordinarily use this, as the path to total construction spans
+ * discovering and indexing of logical breakpoints, and then adding into them information
+ * available from program bookmarks and trace breakpoints. This utility eases the processing of
+ * program-specified bookmarks without depending on the breakpoint service.
+ *
+ * @param program the program containing the bookmark
+ * @param bm the bookmark describing the breakpoint
+ * @return the breakpoint
+ */
+ public static ProgramBreakpoint fromBookmark(Program program, Bookmark bm) {
+ ProgramBreakpoint brk = new ProgramBreakpoint(program,
+ bm.getAddress(), lengthFromBookmark(bm), kindsFromBookmark(bm));
+ brk.add(bm);
+ return brk;
+ }
+
private final Program program;
private final Address address;
private final ProgramLocation location;
@@ -399,10 +418,14 @@ public class ProgramBreakpoint {
*/
public Bookmark getBookmark() {
Bookmark eBookmark = this.eBookmark;
- if (eBookmark != null) {
+ if (eBookmark != null && !eBookmark.isDeleted()) {
return eBookmark;
}
- return dBookmark;
+ Bookmark dBookmark = this.dBookmark;
+ if (dBookmark != null && !dBookmark.isDeleted()) {
+ return dBookmark;
+ }
+ return null;
}
protected String getComment() {
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/DebuggerEmulationIntegration.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/DebuggerEmulationIntegration.java
index a50b26e1a3..636b7b8981 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/DebuggerEmulationIntegration.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/DebuggerEmulationIntegration.java
@@ -23,7 +23,8 @@ import ghidra.pcode.emu.PcodeThread;
import ghidra.pcode.exec.*;
import ghidra.pcode.exec.trace.TraceEmulationIntegration;
import ghidra.pcode.exec.trace.TraceEmulationIntegration.*;
-import ghidra.pcode.exec.trace.data.*;
+import ghidra.pcode.exec.trace.data.PcodeTraceAccess;
+import ghidra.pcode.exec.trace.data.PcodeTraceDataAccess;
import ghidra.program.model.address.*;
import ghidra.trace.model.thread.TraceThread;
@@ -73,13 +74,41 @@ public enum DebuggerEmulationIntegration {
}
/**
- * Create state callbacks that lazily load data and immediately write changes to the given
- * access shim.
+ * Create state callbacks that lazily load data and writes changes to the given access shim.
+ * <p>
+ * Reads may be redirected to the target.
+ * <p>
+ * Use this instead of {@link #bytesImmediateWriteTarget(PcodeDebuggerAccess)} when interfacing
+ * directly with a {@link PcodeExecutorState} vice a {@link PcodeEmulator}.
*
+ * @see TraceEmulationIntegration#bytesImmediateWrite(PcodeTraceAccess, TraceThread, int)
+ * @param access the access shim for loads and stores
+ * @param thread the trace thread for register accesses
+ * @param frame the frame for register accesses, usually 0
+ * @param mode determines whether or not writes affect the target
+ * @return the callbacks
+ */
+ public static Writer bytesWriteMode(PcodeDebuggerAccess access,
+ TraceThread thread, int frame, Mode mode) {
+ Writer writer = new TraceWriter(access) {
+ @Override
+ protected PcodeTraceDataAccess getDataAccess(PcodeTraceAccess access,
+ AddressSpace space, PcodeThread<?> ignored) {
+ return space.isRegisterSpace()
+ ? access.getDataForLocalState(thread, frame)
+ : access.getDataForSharedState();
+ }
+ };
+ writer.putHandler(new TargetBytesPieceHandler(mode));
+ return writer;
+ }
+
+ /**
+ * Create state callbacks that lazily load data and immediately writes changes to the given
+ * access shim.
* <p>
* Reads may be redirected to the target. If redirected, writes are immediately sent to the
* target and presumably stored into the trace at the same snapshot as state is sourced.
- *
* <p>
* Use this instead of {@link #bytesImmediateWriteTarget(PcodeDebuggerAccess)} when interfacing
* directly with a {@link PcodeExecutorState} vice a {@link PcodeEmulator}.
@@ -92,15 +121,7 @@ public enum DebuggerEmulationIntegration {
*/
public static PcodeStateCallbacks bytesImmediateWriteTarget(PcodeDebuggerAccess access,
TraceThread thread, int frame) {
- PcodeDebuggerRegistersAccess regAcc = access.getDataForLocalState(thread, frame);
- Writer writer = new TraceWriter(access) {
- @Override
- protected PcodeTraceRegistersAccess getRegAccess(PcodeThread<?> ignored) {
- return regAcc;
- }
- };
- writer.putHandler(new TargetBytesPieceHandler(Mode.RW));
- return writer.wrapFor(null);
+ return bytesWriteMode(access, thread, frame, Mode.RW).wrapFor(null);
}
protected static <T> T waitTimeout(CompletableFuture<T> future) {
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/DebuggerEmulationServicePlugin.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/DebuggerEmulationServicePlugin.java
index 028826d517..2fef0fda7a 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/DebuggerEmulationServicePlugin.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/DebuggerEmulationServicePlugin.java
@@ -41,6 +41,7 @@ import ghidra.app.plugin.PluginCategoryNames;
import ghidra.app.plugin.core.debug.DebuggerPluginPackage;
import ghidra.app.plugin.core.debug.event.TraceClosedPluginEvent;
import ghidra.app.plugin.core.debug.gui.DebuggerResources;
+import ghidra.app.plugin.core.debug.gui.emulation.DebuggerEmulateFunctionDialog;
import ghidra.app.plugin.core.debug.service.emulation.data.DefaultPcodeDebuggerAccess;
import ghidra.app.services.*;
import ghidra.async.AsyncLazyMap;
@@ -62,6 +63,7 @@ import ghidra.pcode.exec.trace.TraceEmulationIntegration.Writer;
import ghidra.pcode.exec.trace.data.DefaultPcodeTraceAccess;
import ghidra.pcode.exec.trace.data.PcodeTraceAccess;
import ghidra.program.model.address.*;
+import ghidra.program.model.listing.Function;
import ghidra.program.model.listing.Program;
import ghidra.program.util.ProgramLocation;
import ghidra.trace.model.*;
@@ -130,6 +132,27 @@ public class DebuggerEmulationServicePlugin extends Plugin implements DebuggerEm
}
}
+ interface EmulateFunctionAction {
+ String NAME = "Emulate Function";
+ String DESCRIPTION = "Emulate the current function in a new trace";
+ Icon ICON = DebuggerResources.ICON_EMULATE;
+ String GROUP = DebuggerResources.GROUP_GENERAL;
+ String HELP_ANCHOR = "emulate_function";
+
+ static ActionBuilder builder(Plugin owner) {
+ String ownerName = owner.getName();
+ return new ActionBuilder(NAME, ownerName)
+ .description(DESCRIPTION)
+ .menuPath(DebuggerPluginPackage.NAME, NAME)
+ .menuIcon(ICON)
+ .menuGroup(GROUP)
+ .popupMenuPath(NAME)
+ .popupMenuIcon(ICON)
+ .popupMenuGroup(GROUP)
+ .helpLocation(new HelpLocation(ownerName, HELP_ANCHOR));
+ }
+ }
+
interface EmulateAddThreadAction {
String NAME = "Add Emulated Thread to Trace";
String DESCRIPTION = "Add an emulated thread to the current trace starting here";
@@ -374,6 +397,7 @@ public class DebuggerEmulationServicePlugin extends Plugin implements DebuggerEm
private AutoService.Wiring autoServiceWiring;
DockingAction actionEmulateProgram;
+ DockingAction actionEmulateFunction;
DockingAction actionEmulateAddThread;
DockingAction actionInvalidateCache;
Map<Class<? extends EmulatorFactory>, ToggleDockingAction> actionsChooseEmulatorFactory =
@@ -399,6 +423,12 @@ public class DebuggerEmulationServicePlugin extends Plugin implements DebuggerEm
.popupWhen(this::emulateProgramEnabled)
.onAction(this::emulateProgramActivated)
.buildAndInstall(tool);
+ actionEmulateFunction = EmulateFunctionAction.builder(this)
+ .withContext(ProgramLocationActionContext.class)
+ .enabledWhen(this::emulateFunctionEnabled)
+ .popupWhen(this::emulateFunctionEnabled)
+ .onAction(this::emulateFunctionActivated)
+ .buildAndInstall(tool);
actionEmulateAddThread = EmulateAddThreadAction.builder(this)
.withContext(ProgramLocationActionContext.class)
.enabledWhen(this::emulateAddThreadEnabled)
@@ -487,6 +517,30 @@ public class DebuggerEmulationServicePlugin extends Plugin implements DebuggerEm
}
}
+ private boolean emulateFunctionEnabled(ProgramLocationActionContext ctx) {
+ Program program = ctx.getProgram();
+ if (program == null || program instanceof TraceProgramView) {
+ return false;
+ }
+ Function function = program.getFunctionManager().getFunctionContaining(ctx.getAddress());
+ if (function == null) {
+ return false;
+ }
+ return true;
+ }
+
+ private void emulateFunctionActivated(ProgramLocationActionContext ctx) {
+ Program program = ctx.getProgram();
+ if (program == null) {
+ return;
+ }
+ Function function = program.getFunctionManager().getFunctionContaining(ctx.getAddress());
+ if (function == null) {
+ return;
+ }
+ tool.showDialog(new DebuggerEmulateFunctionDialog(tool, function));
+ }
+
private boolean emulateAddThreadEnabled(ProgramLocationActionContext ctx) {
Program programOrView = ctx.getProgram();
if (programOrView instanceof TraceProgramView view) {
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/AbstractPcodeDebuggerAccess.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/AbstractPcodeDebuggerAccess.java
index d16a9e4448..1d616af248 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/AbstractPcodeDebuggerAccess.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/AbstractPcodeDebuggerAccess.java
@@ -17,7 +17,6 @@ package ghidra.app.plugin.core.debug.service.emulation.data;
import ghidra.debug.api.emulation.*;
import ghidra.debug.api.target.Target;
-import ghidra.framework.plugintool.ServiceProvider;
import ghidra.pcode.exec.trace.data.AbstractPcodeTraceAccess;
import ghidra.trace.model.guest.TracePlatform;
@@ -27,41 +26,35 @@ import ghidra.trace.model.guest.TracePlatform;
* @param <S> the type of shared data-access shims provided
* @param <L> the type of thread-local data-access shims provided
*/
-public abstract class AbstractPcodeDebuggerAccess<S extends PcodeDebuggerMemoryAccess, L extends PcodeDebuggerRegistersAccess>
- extends AbstractPcodeTraceAccess<S, L>
+public abstract class AbstractPcodeDebuggerAccess<S extends PcodeDebuggerMemoryAccess,
+ L extends PcodeDebuggerRegistersAccess> extends AbstractPcodeTraceAccess<S, L>
implements PcodeDebuggerAccess {
- protected final ServiceProvider provider;
protected final Target target;
/**
* Construct a shim
*
- * @param provider the service provider (usually the tool)
* @param target the target
* @param platform the associated platform, having the same trace as the recorder
* @param snap the associated snap
*/
- public AbstractPcodeDebuggerAccess(ServiceProvider provider, Target target,
- TracePlatform platform, long snap) {
+ public AbstractPcodeDebuggerAccess(Target target, TracePlatform platform, long snap) {
super(platform, snap);
- this.provider = provider;
this.target = target;
}
/**
* Construct a shim
*
- * @param provider the service provider (usually the tool)
* @param target the target
* @param platform the associated platform, having the same trace as the recorder
* @param snap the associated snap
* @param threadsSnap the snap to use when finding associated threads between trace and emulator
*/
- public AbstractPcodeDebuggerAccess(ServiceProvider provider, Target target,
- TracePlatform platform, long snap, long threadsSnap) {
+ public AbstractPcodeDebuggerAccess(Target target, TracePlatform platform, long snap,
+ long threadsSnap) {
super(platform, snap, threadsSnap);
- this.provider = provider;
this.target = target;
}
}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerAccess.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerAccess.java
index 4922982513..09c4d73326 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerAccess.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerAccess.java
@@ -25,9 +25,10 @@ import ghidra.trace.model.thread.TraceThread;
/**
* The default target-and-trace access shim for a session
*/
-public class DefaultPcodeDebuggerAccess extends
- AbstractPcodeDebuggerAccess //
- <DefaultPcodeDebuggerMemoryAccess, DefaultPcodeDebuggerRegistersAccess> {
+public class DefaultPcodeDebuggerAccess extends AbstractPcodeDebuggerAccess<
+ DefaultPcodeDebuggerMemoryAccess, DefaultPcodeDebuggerRegistersAccess> {
+
+ protected final ServiceProvider provider;
/**
* Construct a shim
@@ -39,7 +40,8 @@ public class DefaultPcodeDebuggerAccess extends
*/
public DefaultPcodeDebuggerAccess(ServiceProvider provider, Target target,
TracePlatform platform, long snap) {
- super(provider, target, platform, snap);
+ super(target, platform, snap);
+ this.provider = provider;
}
/**
@@ -53,7 +55,8 @@ public class DefaultPcodeDebuggerAccess extends
*/
public DefaultPcodeDebuggerAccess(ServiceProvider provider, Target target,
TracePlatform platform, long snap, long threadsSnap) {
- super(provider, target, platform, snap, threadsSnap);
+ super(target, platform, snap, threadsSnap);
+ this.provider = provider;
}
/**
@@ -75,7 +78,7 @@ public class DefaultPcodeDebuggerAccess extends
@Override
protected DefaultPcodeDebuggerRegistersAccess newDataForLocalState(TraceThread thread,
int frame) {
- return new DefaultPcodeDebuggerRegistersAccess(provider, target, platform, snap, thread,
- frame, viewport);
+ return new DefaultPcodeDebuggerRegistersAccess(target, platform, snap, thread, frame,
+ viewport);
}
}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerMemoryAccess.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerMemoryAccess.java
index e2d1ade782..e53d8d6697 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerMemoryAccess.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerMemoryAccess.java
@@ -16,39 +16,25 @@
package ghidra.app.plugin.core.debug.service.emulation.data;
import java.util.Objects;
-import java.util.concurrent.CompletableFuture;
-import ghidra.app.plugin.core.debug.utils.AbstractMappedMemoryBytesVisitor;
import ghidra.app.services.DebuggerStaticMappingService;
-import ghidra.debug.api.emulation.PcodeDebuggerMemoryAccess;
-import ghidra.debug.api.modules.MappedAddressRange;
+import ghidra.debug.api.modules.DebuggerAddressTranslator;
import ghidra.debug.api.target.Target;
import ghidra.framework.plugintool.ServiceProvider;
-import ghidra.pcode.exec.PcodeExecutorStatePiece;
-import ghidra.pcode.exec.trace.data.DefaultPcodeTraceMemoryAccess;
-import ghidra.pcode.exec.trace.data.PcodeTracePropertyAccess;
-import ghidra.program.model.address.*;
-import ghidra.program.model.listing.Program;
-import ghidra.program.model.mem.Memory;
-import ghidra.program.model.mem.MemoryAccessException;
import ghidra.trace.model.TraceTimeViewport;
import ghidra.trace.model.guest.TracePlatform;
-import ghidra.util.Msg;
-import ghidra.util.task.TaskMonitor;
/**
* The default data-and-debugger-access shim for session memory
*/
-public class DefaultPcodeDebuggerMemoryAccess extends DefaultPcodeTraceMemoryAccess
- implements PcodeDebuggerMemoryAccess, InternalPcodeDebuggerDataAccess {
+public class DefaultPcodeDebuggerMemoryAccess extends TranslatedPcodeDebuggerMemoryAccess {
protected final ServiceProvider provider;
- protected final Target target;
/**
* Construct a shim
*
- * @param provider the service provider (usually the tool)
+ * @param provider the service provider (usually the tool) to get the static mapping service
* @param target the target
* @param platform the associated platform, having the same trace as the recorder
* @param snap the associated snap
@@ -56,94 +42,12 @@ public class DefaultPcodeDebuggerMemoryAccess extends DefaultPcodeTraceMemoryAcc
*/
protected DefaultPcodeDebuggerMemoryAccess(ServiceProvider provider, Target target,
TracePlatform platform, long snap, TraceTimeViewport viewport) {
- super(platform, snap, viewport);
+ super(target, platform, snap, viewport);
this.provider = Objects.requireNonNull(provider);
- this.target = target;
}
@Override
- public boolean isLive() {
- return InternalPcodeDebuggerDataAccess.super.isLive();
- }
-
- @Override
- public ServiceProvider getServiceProvider() {
- return provider;
- }
-
- @Override
- public Target getTarget() {
- return target;
- }
-
- @Override
- public CompletableFuture<Boolean> readFromTargetMemory(AddressSetView guestView) {
- if (!isLive()) {
- return CompletableFuture.completedFuture(false);
- }
- AddressSetView hostView = platform.mapGuestToHost(guestView);
- return target.readMemoryAsync(hostView, TaskMonitor.DUMMY).thenApply(__ -> true);
- }
-
- @Override
- public CompletableFuture<Boolean> writeTargetMemory(Address address, byte[] data) {
- if (!isLive()) {
- return CompletableFuture.completedFuture(false);
- }
- return target.writeMemoryAsync(address, data).thenApply(__ -> true);
- }
-
- @Override
- public AddressSetView readFromStaticImages(PcodeExecutorStatePiece<byte[], byte[]> piece,
- AddressSetView guestView) {
- // NOTE: If we expand to block, DON'T OVERWRITE KNOWN!
- DebuggerStaticMappingService mappingService =
- provider.getService(DebuggerStaticMappingService.class);
- if (mappingService == null) {
- return guestView;
- }
-
- AddressSet remains = new AddressSet(guestView);
- try {
- boolean result = new AbstractMappedMemoryBytesVisitor(mappingService, new byte[4096]) {
- @Override
- protected int read(Memory memory, Address addr, byte[] dest, int size)
- throws MemoryAccessException {
- int read = super.read(memory, addr, dest, size);
- if (read < size) {
- Msg.warn(this,
- String.format(" Partial read of %s. Wanted %d bytes. Got %d.",
- addr, size, read));
- }
- return read;
- }
-
- @Override
- protected boolean visitRange(Program program, AddressRange progRng,
- MappedAddressRange mappedRng) throws MemoryAccessException {
- Msg.debug(this,
- "Filling in unknown trace memory in emulator using mapped image: " +
- program + ": " + progRng);
- return super.visitRange(program, progRng, mappedRng);
- }
-
- @Override
- protected void visitData(Address hostAddr, byte[] data, int size) {
- Address guestAddr = platform.mapHostToGuest(hostAddr);
- piece.setVarInternal(guestAddr.getAddressSpace(), guestAddr.getOffset(), size,
- data);
- remains.delete(guestAddr, guestAddr.add(size));
- }
- }.visit(platform.getTrace(), snap, platform.mapGuestToHost(guestView));
- return result ? remains : guestView;
- }
- catch (MemoryAccessException e) {
- throw new AssertionError(e);
- }
- }
-
- @Override
- public <T> PcodeTracePropertyAccess<T> getPropertyAccess(String name, Class<T> type) {
- return new DefaultPcodeDebuggerPropertyAccess<>(this, name, type);
+ public DebuggerAddressTranslator getAddressTranslator() {
+ return provider.getService(DebuggerStaticMappingService.class);
}
}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerPropertyAccess.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerPropertyAccess.java
index 23fc7f0c5d..b07b072f4c 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerPropertyAccess.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerPropertyAccess.java
@@ -4,9 +4,9 @@
* 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.
@@ -15,7 +15,7 @@
*/
package ghidra.app.plugin.core.debug.service.emulation.data;
-import ghidra.app.services.DebuggerStaticMappingService;
+import ghidra.debug.api.modules.DebuggerAddressTranslator;
import ghidra.pcode.exec.trace.data.DefaultPcodeTracePropertyAccess;
import ghidra.program.model.address.Address;
import ghidra.program.model.util.PropertyMap;
@@ -52,12 +52,11 @@ public class DefaultPcodeDebuggerPropertyAccess<T>
@Override
protected T whenNull(Address hostAddress) {
- DebuggerStaticMappingService mappingService =
- data.getServiceProvider().getService(DebuggerStaticMappingService.class);
- if (mappingService == null) {
+ DebuggerAddressTranslator translator = data.getAddressTranslator();
+ if (translator == null) {
return super.whenNull(hostAddress);
}
- ProgramLocation progLoc = mappingService.getOpenMappedLocation(new DefaultTraceLocation(
+ ProgramLocation progLoc = translator.getOpenMappedLocation(new DefaultTraceLocation(
data.getPlatform().getTrace(), null, Lifespan.at(data.getSnap()), hostAddress));
if (progLoc == null) {
return super.whenNull(hostAddress);
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerRegistersAccess.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerRegistersAccess.java
index f001093d03..41c62e892b 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerRegistersAccess.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/DefaultPcodeDebuggerRegistersAccess.java
@@ -4,9 +4,9 @@
* 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.
@@ -18,8 +18,8 @@ package ghidra.app.plugin.core.debug.service.emulation.data;
import java.util.concurrent.CompletableFuture;
import ghidra.debug.api.emulation.PcodeDebuggerRegistersAccess;
+import ghidra.debug.api.modules.DebuggerAddressTranslator;
import ghidra.debug.api.target.Target;
-import ghidra.framework.plugintool.ServiceProvider;
import ghidra.pcode.exec.trace.data.DefaultPcodeTraceRegistersAccess;
import ghidra.program.model.address.Address;
import ghidra.program.model.address.AddressSetView;
@@ -33,13 +33,11 @@ import ghidra.trace.model.thread.TraceThread;
public class DefaultPcodeDebuggerRegistersAccess extends DefaultPcodeTraceRegistersAccess
implements PcodeDebuggerRegistersAccess, InternalPcodeDebuggerDataAccess {
- protected final ServiceProvider provider;
protected final Target target;
/**
* Construct a shim
*
- * @param provider the service provider (usually the tool)
* @param target the target
* @param platform the associated platform, having the same trace as the recorder
* @param snap the associated snap
@@ -47,11 +45,9 @@ public class DefaultPcodeDebuggerRegistersAccess extends DefaultPcodeTraceRegist
* @param frame the associated frame, or 0 if not applicable
* @param viewport the viewport, set to the same snapshot
*/
- protected DefaultPcodeDebuggerRegistersAccess(ServiceProvider provider, Target target,
- TracePlatform platform, long snap, TraceThread thread, int frame,
- TraceTimeViewport viewport) {
+ protected DefaultPcodeDebuggerRegistersAccess(Target target, TracePlatform platform, long snap,
+ TraceThread thread, int frame, TraceTimeViewport viewport) {
super(platform, snap, thread, frame, viewport);
- this.provider = provider;
this.target = target;
}
@@ -61,8 +57,8 @@ public class DefaultPcodeDebuggerRegistersAccess extends DefaultPcodeTraceRegist
}
@Override
- public ServiceProvider getServiceProvider() {
- return provider;
+ public DebuggerAddressTranslator getAddressTranslator() {
+ return null;
}
@Override
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/InternalPcodeDebuggerDataAccess.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/InternalPcodeDebuggerDataAccess.java
index 1bfdd51bcd..e150c0299b 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/InternalPcodeDebuggerDataAccess.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/InternalPcodeDebuggerDataAccess.java
@@ -4,9 +4,9 @@
* 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.
@@ -15,18 +15,34 @@
*/
package ghidra.app.plugin.core.debug.service.emulation.data;
+import ghidra.debug.api.modules.DebuggerAddressTranslator;
import ghidra.debug.api.target.Target;
-import ghidra.framework.plugintool.ServiceProvider;
import ghidra.lifecycle.Internal;
import ghidra.pcode.exec.trace.data.InternalPcodeTraceDataAccess;
import ghidra.trace.model.TraceTimeViewport;
@Internal
public interface InternalPcodeDebuggerDataAccess extends InternalPcodeTraceDataAccess {
- ServiceProvider getServiceProvider();
+ /**
+ * {@return the address translator or null. If null is returned, then bytes cannot be loaded
+ * from mapped images.}
+ */
+ DebuggerAddressTranslator getAddressTranslator();
+ /**
+ * {@return the target or null}
+ */
Target getTarget();
+ /**
+ * Check if the associated trace represents a live target
+ * <p>
+ * To be live, there must be a non-null target, that target must still be valid, i.e., connected
+ * to a live debugger, and the current snapshot must have a viewport incorporating the target's
+ * current snapshot.
+ *
+ * @return true if alive or false if dead/offline
+ */
default boolean isLive() {
Target target = getTarget();
if (target == null || !target.isValid()) {
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/TranslatedPcodeDebuggerAccess.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/TranslatedPcodeDebuggerAccess.java
new file mode 100644
index 0000000000..c49f406b72
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/TranslatedPcodeDebuggerAccess.java
@@ -0,0 +1,92 @@
+/* ###
+ * 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.app.plugin.core.debug.service.emulation.data;
+
+import ghidra.debug.api.modules.DebuggerAddressTranslator;
+import ghidra.debug.api.target.Target;
+import ghidra.pcode.exec.trace.data.DefaultPcodeTraceAccess;
+import ghidra.pcode.exec.trace.data.PcodeTraceAccess;
+import ghidra.trace.model.guest.TracePlatform;
+import ghidra.trace.model.thread.TraceThread;
+
+/**
+ * The default target-and-trace access shim for a session with a provided
+ * {@linkplain DebuggerAddressTranslator address translator}.
+ */
+public abstract class TranslatedPcodeDebuggerAccess extends AbstractPcodeDebuggerAccess<
+ TranslatedPcodeDebuggerMemoryAccess, DefaultPcodeDebuggerRegistersAccess> {
+
+ /**
+ * Construct a shim
+ *
+ * @param target the target
+ * @param platform the associated platform, having the same trace as the recorder
+ * @param snap the associated snap
+ */
+ public TranslatedPcodeDebuggerAccess(Target target,
+ TracePlatform platform, long snap) {
+ super(target, platform, snap);
+ }
+
+ /**
+ * Construct a shim
+ *
+ * @param target the target
+ * @param platform the associated platform, having the same trace as the recorder
+ * @param snap the associated snap
+ * @param threadsSnap the snap to use when finding associated threads between trace and emulator
+ */
+ public TranslatedPcodeDebuggerAccess(Target target, TracePlatform platform, long snap,
+ long threadsSnap) {
+ super(target, platform, snap, threadsSnap);
+ }
+
+ /**
+ * {@return the address translator or null. If null is returned, then bytes cannot be loaded
+ * from mapped images.}
+ *
+ * @see InternalPcodeDebuggerDataAccess#getAddressTranslator()
+ */
+ public abstract DebuggerAddressTranslator getAddressTranslator();
+
+ /**
+ * {@inheritDoc}
+ *
+ * @implNote This does <em>not</em> return a Debugger access shim, but a Trace one, since we
+ * never expect a delayed write to affect the target.
+ */
+ @Override
+ public PcodeTraceAccess deriveForWrite(long snap) {
+ return new DefaultPcodeTraceAccess(platform, snap, threadsSnap);
+ }
+
+ @Override
+ protected TranslatedPcodeDebuggerMemoryAccess newDataForSharedState() {
+ return new TranslatedPcodeDebuggerMemoryAccess(target, platform, snap, viewport) {
+ @Override
+ public DebuggerAddressTranslator getAddressTranslator() {
+ return TranslatedPcodeDebuggerAccess.this.getAddressTranslator();
+ }
+ };
+ }
+
+ @Override
+ protected DefaultPcodeDebuggerRegistersAccess newDataForLocalState(TraceThread thread,
+ int frame) {
+ return new DefaultPcodeDebuggerRegistersAccess(target, platform, snap, thread, frame,
+ viewport);
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/TranslatedPcodeDebuggerMemoryAccess.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/TranslatedPcodeDebuggerMemoryAccess.java
new file mode 100644
index 0000000000..b6041a62ec
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/data/TranslatedPcodeDebuggerMemoryAccess.java
@@ -0,0 +1,139 @@
+/* ###
+ * 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.app.plugin.core.debug.service.emulation.data;
+
+import java.util.concurrent.CompletableFuture;
+
+import ghidra.app.plugin.core.debug.utils.AbstractMappedMemoryBytesVisitor;
+import ghidra.debug.api.emulation.PcodeDebuggerMemoryAccess;
+import ghidra.debug.api.modules.DebuggerAddressTranslator;
+import ghidra.debug.api.modules.MappedAddressRange;
+import ghidra.debug.api.target.Target;
+import ghidra.pcode.exec.PcodeExecutorStatePiece;
+import ghidra.pcode.exec.trace.data.DefaultPcodeTraceMemoryAccess;
+import ghidra.pcode.exec.trace.data.PcodeTracePropertyAccess;
+import ghidra.program.model.address.*;
+import ghidra.program.model.listing.Program;
+import ghidra.program.model.mem.Memory;
+import ghidra.program.model.mem.MemoryAccessException;
+import ghidra.trace.model.TraceTimeViewport;
+import ghidra.trace.model.guest.TracePlatform;
+import ghidra.util.Msg;
+import ghidra.util.task.TaskMonitor;
+
+/**
+ * A data-and-debugger-access shim for memory with a provided {@linkplain DebuggerAddressTranslator
+ * address translator}.
+ */
+public abstract class TranslatedPcodeDebuggerMemoryAccess extends DefaultPcodeTraceMemoryAccess
+ implements PcodeDebuggerMemoryAccess, InternalPcodeDebuggerDataAccess {
+
+ protected final Target target;
+
+ /**
+ * Construct a shim
+ *
+ * @param target the target
+ * @param platform the associated platform, having the same trace as the recorder
+ * @param snap the associated snap
+ * @param viewport the viewport, set to the same snapshot
+ */
+ protected TranslatedPcodeDebuggerMemoryAccess(Target target, TracePlatform platform, long snap,
+ TraceTimeViewport viewport) {
+ super(platform, snap, viewport);
+ this.target = target;
+ }
+
+ @Override
+ public boolean isLive() {
+ return InternalPcodeDebuggerDataAccess.super.isLive();
+ }
+
+ @Override
+ public Target getTarget() {
+ return target;
+ }
+
+ @Override
+ public CompletableFuture<Boolean> readFromTargetMemory(AddressSetView guestView) {
+ if (!isLive()) {
+ return CompletableFuture.completedFuture(false);
+ }
+ AddressSetView hostView = platform.mapGuestToHost(guestView);
+ return target.readMemoryAsync(hostView, TaskMonitor.DUMMY).thenApply(__ -> true);
+ }
+
+ @Override
+ public CompletableFuture<Boolean> writeTargetMemory(Address address, byte[] data) {
+ if (!isLive()) {
+ return CompletableFuture.completedFuture(false);
+ }
+ return target.writeMemoryAsync(address, data).thenApply(__ -> true);
+ }
+
+ @Override
+ public AddressSetView readFromStaticImages(PcodeExecutorStatePiece<byte[], byte[]> piece,
+ AddressSetView guestView) {
+ // NOTE: If we expand to block, DON'T OVERWRITE KNOWN!
+ DebuggerAddressTranslator translator = getAddressTranslator();
+ if (translator == null) {
+ return guestView;
+ }
+
+ AddressSet remains = new AddressSet(guestView);
+ try {
+ boolean result = new AbstractMappedMemoryBytesVisitor(translator, new byte[4096]) {
+ @Override
+ protected int read(Memory memory, Address addr, byte[] dest, int size)
+ throws MemoryAccessException {
+ int read = super.read(memory, addr, dest, size);
+ if (read < size) {
+ Msg.warn(this,
+ String.format(" Partial read of %s. Wanted %d bytes. Got %d.",
+ addr, size, read));
+ }
+ return read;
+ }
+
+ @Override
+ protected boolean visitRange(Program program, AddressRange progRng,
+ MappedAddressRange mappedRng) throws MemoryAccessException {
+ Msg.debug(this,
+ "Filling in unknown trace memory in emulator using mapped image: " +
+ program + ": " + progRng);
+ return super.visitRange(program, progRng, mappedRng);
+ }
+
+ @Override
+ protected void visitData(Address hostAddr, byte[] data, int size) {
+ Address guestAddr = platform.mapHostToGuest(hostAddr);
+ piece.setVarInternal(guestAddr.getAddressSpace(), guestAddr.getOffset(), size,
+ data);
+ remains.delete(guestAddr, guestAddr.add(size));
+ }
+ }.visit(platform.getTrace(), snap, platform.mapGuestToHost(guestView));
+ return result ? remains : guestView;
+ }
+ catch (MemoryAccessException e) {
+ throw new AssertionError(e);
+ }
+ }
+
+ @Override
+ public <T> PcodeTracePropertyAccess<T> getPropertyAccess(String name, Class<T> type) {
+ return new DefaultPcodeDebuggerPropertyAccess<>(this, name, type);
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/modules/DebuggerStaticMappingContext.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/modules/DebuggerStaticMappingContext.java
index af28f96c6a..460538f158 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/modules/DebuggerStaticMappingContext.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/modules/DebuggerStaticMappingContext.java
@@ -33,7 +33,7 @@ import ghidra.util.datastruct.ListenerSet;
public class DebuggerStaticMappingContext implements DebuggerAddressTranslator {
- record ChangeCollector(DebuggerStaticMappingContext ctx, Set<Trace> traces,
+ public record ChangeCollector(DebuggerStaticMappingContext ctx, Set<Trace> traces,
Set<Program> programs) implements AutoCloseable {
static <T> Set<T> subtract(Set<T> a, Set<T> b) {
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/stack/SymPcodeExecutor.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/stack/SymPcodeExecutor.java
index cc61556d29..a77f83771b 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/stack/SymPcodeExecutor.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/stack/SymPcodeExecutor.java
@@ -406,8 +406,15 @@ public class SymPcodeExecutor extends PcodeExecutor<Sym> {
// This should always end a basic block, so just do nothing
}
+ /**
+ * {@inheritDoc}
+ * <p>
+ * This could be a {@link PcodeOp#RETURN return} and the slaspec does not always set PC
+ * explicitly, so do it here, but don't perform any actual control transfer.
+ */
@Override
protected void doExecuteIndirectBranch(PcodeOp op, PcodeFrame frame) {
- // This should always end a basic block, so just do nothing
+ Sym offset = state.getVar(getIndirectBranchTarget(op), reason);
+ branchToOffset(op, offset, frame);
}
}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/stack/SymPcodeExecutorState.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/stack/SymPcodeExecutorState.java
index a5cca4703e..c0171546bb 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/stack/SymPcodeExecutorState.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/stack/SymPcodeExecutorState.java
@@ -240,9 +240,10 @@ public class SymPcodeExecutorState implements PcodeExecutorState<Sym> {
* @return the address (stack offset or register) of the return address
*/
public Address computeAddressOfReturn() {
- return switch (getVar(language.getProgramCounter(), Reason.INSPECT)) {
+ Register pc = language.getProgramCounter();
+ return switch (getVar(pc, Reason.INSPECT)) {
case StackDerefSym stackVar -> cSpec.getStackSpace().getAddress(stackVar.offset());
- case RegisterSym regVar -> regVar.register().getAddress();
+ case RegisterSym regVar when regVar.register() != pc -> regVar.register().getAddress();
default -> null;
};
}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/utils/AbstractMappedMemoryBytesVisitor.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/utils/AbstractMappedMemoryBytesVisitor.java
index f31b5345bc..0d43e3235d 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/utils/AbstractMappedMemoryBytesVisitor.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/utils/AbstractMappedMemoryBytesVisitor.java
@@ -19,7 +19,7 @@ import java.util.Collection;
import java.util.Map.Entry;
import java.util.Objects;
-import ghidra.app.services.DebuggerStaticMappingService;
+import ghidra.debug.api.modules.DebuggerAddressTranslator;
import ghidra.debug.api.modules.MappedAddressRange;
import ghidra.program.model.address.*;
import ghidra.program.model.listing.Program;
@@ -39,20 +39,20 @@ import ghidra.util.MathUtilities;
* bytes from the mapped programs, along with the trace address where they apply.
*/
public abstract class AbstractMappedMemoryBytesVisitor {
- private final DebuggerStaticMappingService mappingService;
+ private final DebuggerAddressTranslator translator;
private final byte[] buffer;
/**
* Construct a visitor object
*
- * @param mappingService the mapping service
+ * @param translator the address translator
* @param buffer a buffer for the data. This is passed directly into
* {@link #visitData(Address, byte[], int)}. If a mapped range exceeds the buffer
* size, the range is broken down into smaller pieces.
*/
- public AbstractMappedMemoryBytesVisitor(DebuggerStaticMappingService mappingService,
+ public AbstractMappedMemoryBytesVisitor(DebuggerAddressTranslator translator,
byte[] buffer) {
- this.mappingService = Objects.requireNonNull(mappingService);
+ this.translator = Objects.requireNonNull(translator);
this.buffer = buffer;
}
@@ -100,7 +100,7 @@ public abstract class AbstractMappedMemoryBytesVisitor {
public boolean visit(Trace trace, long snap, AddressSetView hostView)
throws MemoryAccessException {
boolean result = false;
- for (Entry<Program, Collection<MappedAddressRange>> ent : mappingService
+ for (Entry<Program, Collection<MappedAddressRange>> ent : translator
.getOpenMappedViews(trace, hostView, snap)
.entrySet()) {
result |= visitProgram(ent.getKey(), ent.getValue());
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/utils/ManagedDomainObject.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/utils/ManagedDomainObject.java
index 38cc076786..d1423faea1 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/utils/ManagedDomainObject.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/utils/ManagedDomainObject.java
@@ -4,9 +4,9 @@
* 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.
@@ -23,12 +23,13 @@ import ghidra.framework.model.DomainObject;
import ghidra.util.exception.CancelledException;
import ghidra.util.exception.VersionException;
import ghidra.util.task.TaskMonitor;
+import utility.function.ExceptionalFunction;
-public class ManagedDomainObject implements AutoCloseable {
+public class ManagedDomainObject<T extends DomainObject> implements AutoCloseable {
public static final Cleaner CLEANER = Cleaner.create();
- private static class ObjectState implements Runnable {
- private DomainObject obj;
+ private static class ObjectState<T extends DomainObject> implements Runnable {
+ private T obj;
@Override
public synchronized void run() {
@@ -37,7 +38,7 @@ public class ManagedDomainObject implements AutoCloseable {
}
}
- public synchronized DomainObject get() {
+ public synchronized T get() {
if (!obj.getConsumerList().contains(this)) {
throw new IllegalStateException("Domain object is closed");
}
@@ -45,20 +46,26 @@ public class ManagedDomainObject implements AutoCloseable {
}
}
- private final ObjectState state = new ObjectState();
+ private final ObjectState<T> state = new ObjectState<>();
+
+ public ManagedDomainObject(DomainFile file, Class<T> type, TaskMonitor monitor)
+ throws VersionException, CancelledException, IOException {
+ state.obj = type.cast(file.getDomainObject(state, false, false, monitor));
+ CLEANER.register(this, state);
+ }
- public ManagedDomainObject(DomainFile file, boolean okToUpgrade, boolean okToRecover,
- TaskMonitor monitor) throws VersionException, CancelledException, IOException {
- state.obj = file.getDomainObject(state, okToUpgrade, okToRecover, monitor);
+ public <E extends Exception> ManagedDomainObject(ExceptionalFunction<Object, T, E> supplier)
+ throws E {
+ state.obj = supplier.apply(state);
CLEANER.register(this, state);
}
@Override
- public void close() throws Exception {
+ public void close() {
state.run();
}
- public DomainObject get() {
+ public T get() {
return state.get();
}
}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/pcode/exec/DebuggerPcodeUtils.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/pcode/exec/DebuggerPcodeUtils.java
index fc81e09d8c..1519b1607d 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/pcode/exec/DebuggerPcodeUtils.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/pcode/exec/DebuggerPcodeUtils.java
@@ -25,6 +25,7 @@ import org.antlr.runtime.tree.CommonTreeNodeStream;
import ghidra.app.nav.NavigationUtils;
import ghidra.app.plugin.core.debug.service.emulation.DebuggerEmulationIntegration;
+import ghidra.app.plugin.core.debug.service.emulation.Mode;
import ghidra.app.plugin.core.debug.service.emulation.data.DefaultPcodeDebuggerAccess;
import ghidra.app.plugin.processors.sleigh.SleighException;
import ghidra.app.plugin.processors.sleigh.SleighLanguage;
@@ -36,6 +37,7 @@ import ghidra.pcode.exec.PcodeExecutorStatePiece.Reason;
import ghidra.pcode.exec.SleighProgramCompiler.ErrorCollectingPcodeParser;
import ghidra.pcode.exec.SleighUtils.LitIdMode;
import ghidra.pcode.exec.trace.*;
+import ghidra.pcode.exec.trace.TraceEmulationIntegration.Writer;
import ghidra.pcode.exec.trace.data.DefaultPcodeTraceAccess;
import ghidra.pcode.exec.trace.data.PcodeTraceDataAccess;
import ghidra.pcode.utils.Utils;
@@ -320,6 +322,8 @@ public enum DebuggerPcodeUtils {
return compileExpression(provider, coordinates, current, source, LitIdMode.NORMAL);
}
+ public record WriterAndState(Writer writer, PcodeExecutorState<byte[]> state) {}
+
/**
* Get a p-code executor state for the given coordinates
*
@@ -329,10 +333,11 @@ public enum DebuggerPcodeUtils {
*
* @param provider the service provider (usually the tool)
* @param coordinates the coordinates
+ * @param mode determines whether or not writes affect the target
* @return the state
*/
- public static PcodeExecutorState<byte[]> executorStateForCoordinates(ServiceProvider provider,
- DebuggerCoordinates coordinates) {
+ public static WriterAndState executorStateForCoordinates(ServiceProvider provider,
+ DebuggerCoordinates coordinates, Mode mode) {
Trace trace = coordinates.getTrace();
if (trace == null) {
throw new IllegalArgumentException("Coordinates have no trace");
@@ -344,9 +349,26 @@ public enum DebuggerPcodeUtils {
}
DefaultPcodeDebuggerAccess access = new DefaultPcodeDebuggerAccess(provider,
coordinates.getTarget(), platform, coordinates.getViewSnap());
- PcodeStateCallbacks cb = DebuggerEmulationIntegration.bytesImmediateWriteTarget(access,
- coordinates.getThread(), coordinates.getFrame());
- return new BytesPcodeExecutorState(language, cb);
+ Writer writer = DebuggerEmulationIntegration.bytesWriteMode(access,
+ coordinates.getThread(), coordinates.getFrame(), mode);
+ return new WriterAndState(writer,
+ new BytesPcodeExecutorState(language, writer.wrapFor(null)));
+ }
+
+ /**
+ * Get a p-code executor state for the given coordinates
+ *
+ * <p>
+ * If a thread is included, the executor state will have access to both the memory and registers
+ * in the context of that thread. Otherwise, only memory access is permitted.
+ *
+ * @param provider the service provider (usually the tool)
+ * @param coordinates the coordinates
+ * @return the state
+ */
+ public static PcodeExecutorState<byte[]> executorStateForCoordinates(ServiceProvider provider,
+ DebuggerCoordinates coordinates) {
+ return executorStateForCoordinates(provider, coordinates, Mode.RW).state;
}
/**
diff --git a/Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/service/emulation/DebuggerEmulationServicePluginScreenShots.java b/Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/service/emulation/DebuggerEmulationServicePluginScreenShots.java
new file mode 100644
index 0000000000..bf95664191
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/screen/java/ghidra/app/plugin/core/debug/service/emulation/DebuggerEmulationServicePluginScreenShots.java
@@ -0,0 +1,145 @@
+/* ###
+ * 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.app.plugin.core.debug.service.emulation;
+
+import java.io.IOException;
+import java.util.List;
+
+import org.junit.*;
+
+import db.Transaction;
+import ghidra.app.plugin.core.debug.gui.emulation.DebuggerEmulateFunctionDialog;
+import ghidra.app.plugin.core.progmgr.ProgramManagerPlugin;
+import ghidra.app.services.ProgramManager;
+import ghidra.framework.model.DomainFolder;
+import ghidra.framework.model.DomainObject;
+import ghidra.program.model.address.*;
+import ghidra.program.model.data.*;
+import ghidra.program.model.listing.*;
+import ghidra.program.model.listing.Function.FunctionUpdateType;
+import ghidra.program.model.symbol.SourceType;
+import ghidra.test.ToyProgramBuilder;
+import ghidra.util.InvalidNameException;
+import ghidra.util.exception.CancelledException;
+import ghidra.util.task.ConsoleTaskMonitor;
+import ghidra.util.task.TaskMonitor;
+import help.screenshot.GhidraScreenShotGenerator;
+
+public class DebuggerEmulationServicePluginScreenShots extends GhidraScreenShotGenerator {
+ private static final TaskMonitor MONITOR = new ConsoleTaskMonitor();
+
+ private static Address addr(Program program, long offset) {
+ return program.getAddressFactory().getDefaultAddressSpace().getAddress(offset);
+ }
+
+ private static AddressSetView set(Program program, long min, long max) {
+ return new AddressSet(addr(program, min), addr(program, max));
+ }
+
+ ProgramManager programManager;
+ DebuggerEmulationServicePlugin emuService;
+ Function function;
+ Program progam;
+ DataTypeManager dtm;
+
+ DataType dtInt;
+ DataType dtCharPtrPtr;
+ DataType dtStructPtr;
+
+ @Before
+ public void setUpMine() throws Throwable {
+ programManager = addPlugin(tool, ProgramManagerPlugin.class);
+ emuService = addPlugin(tool, DebuggerEmulationServicePlugin.class);
+ }
+
+ @After
+ public void tearDownMine() {
+ if (program != null) {
+ program.release(this);
+ }
+ }
+
+ // TODO: Propose this replace waitForProgram
+ public static void waitForDomainObject(DomainObject object) {
+ object.flushEvents();
+ waitForSwing();
+ }
+
+ protected void intoProject(DomainObject obj) {
+ waitForDomainObject(obj);
+ DomainFolder rootFolder = tool.getProject().getProjectData().getRootFolder();
+ waitForCondition(() -> {
+ try {
+ rootFolder.createFile(obj.getName(), obj, MONITOR);
+ return true;
+ }
+ catch (InvalidNameException | CancelledException e) {
+ throw new AssertionError(e);
+ }
+ catch (IOException e) {
+ // Usually "object is busy". Try again.
+ return false;
+ }
+ });
+ }
+
+ @SuppressWarnings("unchecked")
+ <T extends DataType> T resolve(T dt) {
+ try (Transaction tx = program.openTransaction("Resolved %s".formatted(dt))) {
+ DataTypeConflictHandler handler = DataTypeConflictHandler.DEFAULT_HANDLER;
+ return (T) dtm.resolve(dt, handler);
+ }
+ }
+
+ @Test
+ public void testCaptureDebuggerEmulateFunctionDialog() throws Throwable {
+ program = createDefaultProgram("game", ToyProgramBuilder._X64, this);
+ intoProject(program);
+ dtm = program.getDataTypeManager();
+ try (Transaction tx = program.openTransaction("Create Function")) {
+ program.getMemory()
+ .createInitializedBlock(".text", addr(program, 0x00400000), 0x10000, (byte) 0,
+ MONITOR, false);
+ function = program.getFunctionManager()
+ .createFunction("parse_opts", addr(program, 0x00401000),
+ set(program, 0x00401000, 0x00401100), SourceType.USER_DEFINED);
+
+ dtInt = resolve(IntegerDataType.dataType);
+ dtCharPtrPtr = resolve(new PointerDataType(new PointerDataType(CharDataType.dataType)));
+
+ Structure st = new StructureDataType("Options", 0, dtm);
+ st.add(dtInt, "width", "");
+ st.add(dtInt, "height", "");
+ dtStructPtr = resolve(new PointerDataType(st));
+
+ Variable returnVar = new ReturnParameterImpl(dtStructPtr, program);
+ Variable param1 = new ParameterImpl("argc", dtInt, program);
+ Variable param2 = new ParameterImpl("argv", dtCharPtrPtr, program);
+
+ function.updateFunction("default", returnVar, List.of(param1, param2),
+ FunctionUpdateType.DYNAMIC_STORAGE_ALL_PARAMS, false, SourceType.ANALYSIS);
+ }
+ programManager.openProgram(program);
+ goTo(tool, progam, function.getEntryPoint());
+ performAction(emuService.actionEmulateFunction, false);
+
+ DebuggerEmulateFunctionDialog dialog =
+ waitForDialogComponent(DebuggerEmulateFunctionDialog.class);
+
+ runSwing(() -> dialog.getComponent().requestFocus());
+ captureDialog(dialog);
+ }
+}
diff --git a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/pcode/exec/trace/TraceEmulationIntegration.java b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/pcode/exec/trace/TraceEmulationIntegration.java
index 7026fa9e5d..2c747e0d50 100644
--- a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/pcode/exec/trace/TraceEmulationIntegration.java
+++ b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/pcode/exec/trace/TraceEmulationIntegration.java
@@ -93,8 +93,11 @@ public enum TraceEmulationIntegration {
TraceThread thread, int frame) {
Writer writer = new TraceWriter(access) {
@Override
- protected PcodeTraceRegistersAccess getRegAccess(PcodeThread<?> ignored) {
- return access.getDataForLocalState(thread, frame);
+ protected PcodeTraceDataAccess getDataAccess(PcodeTraceAccess access,
+ AddressSpace space, PcodeThread<?> ignored) {
+ return space.isRegisterSpace()
+ ? access.getDataForLocalState(thread, frame)
+ : access.getDataForSharedState();
}
};
writer.putHandler(new ImmediateBytesPieceHandler());
@@ -310,12 +313,13 @@ public enum TraceEmulationIntegration {
* also have state assigned to abstract addresses. In such cases, it is up to the handler to
* track what has been written.
*
+ * @param writer the writer
* @param into the destination trace access
* @param thread the thread associated with the piece's state
* @param piece the source state piece
* @param written the portion that is known to have been written
*/
- void writeDown(PcodeTraceDataAccess into, PcodeThread<?> thread,
+ void writeDown(TraceWriter writer, PcodeTraceAccess into, PcodeThread<?> thread,
PcodeExecutorStatePiece<A, T> piece, AddressSetView written);
}
@@ -346,7 +350,7 @@ public enum TraceEmulationIntegration {
}
@Override
- public void writeDown(PcodeTraceDataAccess into, PcodeThread<?> thread,
+ public void writeDown(TraceWriter writer, PcodeTraceAccess into, PcodeThread<?> thread,
PcodeExecutorStatePiece<Void, Void> piece, AddressSetView written) {
}
}
@@ -398,20 +402,21 @@ public enum TraceEmulationIntegration {
}
@Override
- public void writeDown(PcodeTraceDataAccess into, PcodeThread<?> thread,
+ public void writeDown(TraceWriter writer, PcodeTraceAccess into, PcodeThread<?> thread,
PcodeExecutorStatePiece<byte[], byte[]> piece, AddressSetView written) {
for (AddressRange range : written) {
AddressSpace space = range.getAddressSpace();
if (space.isUniqueSpace()) {
continue;
}
+ PcodeTraceDataAccess acc = writer.getDataAccess(into, space, thread);
long lower = range.getMinAddress().getOffset();
long fullLen = range.getLength();
while (fullLen > 0) {
int len = MathUtilities.unsignedMin(CHUNK_SIZE, fullLen);
// NOTE: Would prefer less copying and less heap garbage....
byte[] bytes = piece.getVarInternal(space, lower, len, Reason.INSPECT);
- into.putBytes(space.getAddress(lower), ByteBuffer.wrap(bytes));
+ acc.putBytes(space.getAddress(lower), ByteBuffer.wrap(bytes));
lower += bytes.length;
fullLen -= bytes.length;
@@ -564,14 +569,15 @@ public enum TraceEmulationIntegration {
* portion.
*/
@Override
- public void writeDown(PcodeTraceDataAccess into, PcodeThread<?> thread,
+ public void writeDown(TraceWriter writer, PcodeTraceAccess into, PcodeThread<?> thread,
PcodeExecutorStatePiece<A, T> piece, AddressSetView written) {
- PcodeTracePropertyAccess<P> property =
- into.getPropertyAccess(getPropertyName(), getPropertyType());
AddressSet remains = new AddressSet(written);
while (!remains.isEmpty()) {
Address cur = remains.getMinAddress();
AddressSpace space = cur.getAddressSpace();
+ PcodeTraceDataAccess acc = writer.getDataAccess(into, space, thread);
+ PcodeTracePropertyAccess<P> property =
+ acc.getPropertyAccess(getPropertyName(), getPropertyType());
Entry<Long, T> entry = piece.getNextEntryInternal(space, cur.getOffset());
if (entry == null) {
remains.delete(space.getMinAddress(), space.getMaxAddress());
@@ -662,18 +668,19 @@ public enum TraceEmulationIntegration {
protected final PcodeTraceMemoryAccess memAccess;
protected final Map<PcodeThread<?>, PcodeTraceRegistersAccess> regAccess = new HashMap<>();
+ record PieceInfo(PcodeThread<?> thread, AddressSet written) {}
+
/**
* An address set to track what has actually been written. It's not enough to just use the
* {@link SemisparseByteArray}'s initialized set, as that may be caching bytes from the
* trace which are still {@link TraceMemoryState#UNKNOWN}.
*/
- protected final AddressSet memWritten = new AddressSet();
- protected final Map<PcodeThread<?>, AddressSet> regsWritten = new HashMap<>();
+ //protected final AddressSet memWritten = new AddressSet();
+ //protected final Map<PcodeThread<?>, AddressSet> regsWritten = new HashMap<>();
+ protected final Map<PcodeExecutorStatePiece<?, ?>, PieceInfo> pieces = new HashMap<>();
protected final Map<PieceType<?, ?>, PieceHandler<?, ?>> handlers = new HashMap<>();
- private PcodeMachine<?> emulator;
-
/**
* Construct a writer which sources state from the given access shim
*
@@ -689,11 +696,6 @@ public enum TraceEmulationIntegration {
handlers.put(PieceType.forHandler(handler), handler);
}
- @Override
- public void emulatorCreated(PcodeMachine<Object> emulator) {
- this.emulator = emulator;
- }
-
@Override
public void threadCreated(PcodeThread<Object> thread) {
access.getDataForLocalState(thread, 0).initializeThreadContext(thread);
@@ -715,28 +717,17 @@ public enum TraceEmulationIntegration {
* @param piece the piece
* @param written the logged portions written
*/
- protected <B, U> void writePieceDown(PcodeTraceDataAccess into, PcodeThread<?> thread,
+ protected <B, U> void writePieceDown(PcodeTraceAccess into, PcodeThread<?> thread,
PcodeExecutorStatePiece<B, U> piece, AddressSetView written) {
PieceHandler<B, U> handler = handlerFor(piece);
- handler.writeDown(into, thread, piece, written);
+ handler.writeDown(this, into, thread, piece, written);
}
@Override
public void writeDown(PcodeTraceAccess into) {
- PcodeTraceMemoryAccess memInto = into.getDataForSharedState();
- for (PcodeExecutorStatePiece<?, ?> piece : emulator.getSharedState()
- .streamPieces()
- .toList()) {
- writePieceDown(memInto, null, piece, memWritten);
- }
- for (PcodeThread<?> thread : emulator.getAllThreads()) {
- PcodeTraceRegistersAccess regInto = into.getDataForLocalState(thread, 0);
- AddressSetView written = regsWritten.getOrDefault(thread, new AddressSet());
- for (PcodeExecutorStatePiece<?, ?> piece : thread.getState()
- .streamPieces()
- .toList()) {
- writePieceDown(regInto, thread, piece, written);
- }
+ for (Entry<PcodeExecutorStatePiece<?, ?>, PieceInfo> ent : pieces.entrySet()) {
+ PieceInfo info = ent.getValue();
+ writePieceDown(into, info.thread, ent.getKey(), info.written);
}
}
@@ -745,22 +736,20 @@ public enum TraceEmulationIntegration {
writeDown(access.deriveForWrite(snap));
}
- protected PcodeTraceRegistersAccess getRegAccess(PcodeThread<?> thread) {
- // Always use frame 0
- return regAccess.computeIfAbsent(thread, t -> access.getDataForLocalState(t, 0));
+ protected PcodeTraceDataAccess getDataAccess(PcodeTraceAccess access, AddressSpace space,
+ PcodeThread<?> thread) {
+ return space.isRegisterSpace()
+ ? access.getDataForLocalState(thread, 0)
+ : access.getDataForSharedState();
}
@Override
public <B, U> void dataWritten(PcodeThread<Object> thread,
- PcodeExecutorStatePiece<B, U> piece,
- Address address, int length, U value) {
- PcodeTraceDataAccess acc = address.isRegisterAddress()
- ? getRegAccess(thread)
- : memAccess;
- AddressSet written = address.isRegisterAddress()
- ? regsWritten.computeIfAbsent(thread, t -> new AddressSet())
- : memWritten;
- if (handlerFor(piece).dataWritten(acc, written, thread, piece, address, length,
+ PcodeExecutorStatePiece<B, U> piece, Address address, int length, U value) {
+ PcodeTraceDataAccess acc = getDataAccess(access, address.getAddressSpace(), thread);
+ PieceInfo info =
+ pieces.computeIfAbsent(piece, p -> new PieceInfo(thread, new AddressSet()));
+ if (handlerFor(piece).dataWritten(acc, info.written, thread, piece, address, length,
value)) {
return;
}
@@ -769,12 +758,12 @@ public enum TraceEmulationIntegration {
}
Address end = address.addWrap(length - 1);
if (address.compareTo(end) <= 0) {
- written.add(address, end);
+ info.written.add(address, end);
}
else {
AddressSpace space = address.getAddressSpace();
- written.add(address, space.getMaxAddress());
- written.add(space.getMinAddress(), end);
+ info.written.add(address, space.getMaxAddress());
+ info.written.add(space.getMinAddress(), end);
}
}
@@ -782,19 +771,18 @@ public enum TraceEmulationIntegration {
public <B, U> void dataWritten(PcodeThread<Object> thread,
PcodeExecutorStatePiece<B, U> piece, AddressSpace space, B offset, int length,
U value) {
- PcodeTraceDataAccess acc = space.isRegisterSpace() ? getRegAccess(thread) : memAccess;
- AddressSet written = space.isRegisterSpace()
- ? regsWritten.computeIfAbsent(thread, t -> new AddressSet())
- : memWritten;
- handlerFor(piece).abstractWritten(acc, written, thread, piece, space, offset, length,
- value);
+ PcodeTraceDataAccess acc = getDataAccess(access, space, thread);
+ PieceInfo info =
+ pieces.computeIfAbsent(piece, p -> new PieceInfo(thread, new AddressSet()));
+ handlerFor(piece).abstractWritten(acc, info.written, thread, piece, space, offset,
+ length, value);
}
@Override
public <B, U> int readUninitialized(PcodeThread<Object> thread,
PcodeExecutorStatePiece<B, U> piece, AddressSpace space, B offset, int length,
Reason reason) {
- PcodeTraceDataAccess acc = space.isRegisterSpace() ? getRegAccess(thread) : memAccess;
+ PcodeTraceDataAccess acc = getDataAccess(access, space, thread);
return handlerFor(piece).abstractReadUninit(acc, thread, piece, space, offset, length,
reason);
}
@@ -809,7 +797,7 @@ public enum TraceEmulationIntegration {
if (space.isUniqueSpace()) {
return set;
}
- PcodeTraceDataAccess acc = space.isRegisterSpace() ? getRegAccess(thread) : memAccess;
+ PcodeTraceDataAccess acc = getDataAccess(access, space, thread);
return handlerFor(piece).readUninitialized(acc, thread, piece, set);
}
}
diff --git a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/pcode/exec/trace/data/AbstractPcodeTraceDataAccess.java b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/pcode/exec/trace/data/AbstractPcodeTraceDataAccess.java
index 91604854f5..2b2050d375 100644
--- a/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/pcode/exec/trace/data/AbstractPcodeTraceDataAccess.java
+++ b/Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/pcode/exec/trace/data/AbstractPcodeTraceDataAccess.java
@@ -16,6 +16,8 @@
package ghidra.pcode.exec.trace.data;
import java.nio.ByteBuffer;
+import java.util.HashMap;
+import java.util.Map;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.Language;
@@ -36,6 +38,8 @@ public abstract class AbstractPcodeTraceDataAccess implements InternalPcodeTrace
protected final TraceMemoryManager mm;
+ protected final Map<String, PcodeTracePropertyAccess<?>> properties = new HashMap<>();
+
/**
* Construct a shim
*
@@ -204,7 +208,11 @@ public abstract class AbstractPcodeTraceDataAccess implements InternalPcodeTrace
}
@Override
+ @SuppressWarnings("unchecked")
public <T> PcodeTracePropertyAccess<T> getPropertyAccess(String name, Class<T> type) {
- return new DefaultPcodeTracePropertyAccess<>(this, name, type);
+ synchronized (properties) {
+ return (PcodeTracePropertyAccess<T>) properties.computeIfAbsent(name,
+ n -> new DefaultPcodeTracePropertyAccess<>(this, n, type));
+ }
}
}
diff --git a/Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/pcode/exec/trace/BytesTracePcodeEmulatorTest.java b/Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/pcode/exec/trace/BytesTracePcodeEmulatorTest.java
index 92d3194c55..4475ca17f2 100644
--- a/Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/pcode/exec/trace/BytesTracePcodeEmulatorTest.java
+++ b/Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/pcode/exec/trace/BytesTracePcodeEmulatorTest.java
@@ -26,6 +26,7 @@ import java.util.List;
import org.junit.Test;
import db.Transaction;
+import generic.Unique;
import ghidra.app.plugin.assembler.*;
import ghidra.app.plugin.assembler.sleigh.sem.AssemblyPatternBlock;
import ghidra.pcode.emu.PcodeEmulator;
@@ -68,7 +69,7 @@ public class BytesTracePcodeEmulatorTest extends AbstractTracePcodeEmulatorTest
emu.getSharedState().setVar(tb.addr(0x00400000), 0, false, tb.arr());
TraceWriter tw = (TraceWriter) writer;
- assertEquals(tb.set(), tw.memWritten);
+ assertEquals(tb.set(), Unique.assertOne(tw.pieces.entrySet()).getValue().written());
}
}
diff --git a/Ghidra/Extensions/SymbolicSummaryZ3/src/main/java/ghidra/pcode/emu/symz3/state/SymZ3PieceHandler.java b/Ghidra/Extensions/SymbolicSummaryZ3/src/main/java/ghidra/pcode/emu/symz3/state/SymZ3PieceHandler.java
index 59814327f4..410b5a6a90 100644
--- a/Ghidra/Extensions/SymbolicSummaryZ3/src/main/java/ghidra/pcode/emu/symz3/state/SymZ3PieceHandler.java
+++ b/Ghidra/Extensions/SymbolicSummaryZ3/src/main/java/ghidra/pcode/emu/symz3/state/SymZ3PieceHandler.java
@@ -26,8 +26,8 @@ import ghidra.pcode.exec.PcodeArithmetic.Purpose;
import ghidra.pcode.exec.PcodeExecutorStatePiece;
import ghidra.pcode.exec.PcodeExecutorStatePiece.Reason;
import ghidra.pcode.exec.trace.TraceEmulationIntegration.AbstractPropertyBasedPieceHandler;
-import ghidra.pcode.exec.trace.data.PcodeTraceDataAccess;
-import ghidra.pcode.exec.trace.data.PcodeTracePropertyAccess;
+import ghidra.pcode.exec.trace.TraceEmulationIntegration.TraceWriter;
+import ghidra.pcode.exec.trace.data.*;
import ghidra.program.model.address.*;
import ghidra.symz3.model.SymValueZ3;
@@ -105,9 +105,9 @@ public class SymZ3PieceHandler
}
@Override
- public void writeDown(PcodeTraceDataAccess into, PcodeThread<?> thread,
+ public void writeDown(TraceWriter writer, PcodeTraceAccess into, PcodeThread<?> thread,
PcodeExecutorStatePiece<SymValueZ3, SymValueZ3> piece, AddressSetView written) {
- super.writeDown(into, thread, piece, written);
+ super.writeDown(writer, into, thread, piece, written);
Set<SymZ3Varnode> symWritten = abstractWritten.get(thread);
if (symWritten == null) {
return;
@@ -128,7 +128,9 @@ public class SymZ3PieceHandler
* abstractly?
*/
String val = buf.isEmpty() ? null : buf.toString();
- into.getPropertyAccess(NAME, String.class).put(Address.NO_ADDRESS, val);
+ into.getDataForSharedState()
+ .getPropertyAccess(NAME, String.class)
+ .put(Address.NO_ADDRESS, val);
}
@Override
diff --git a/Ghidra/Features/Base/src/test/java/ghidra/app/plugin/core/datamgr/util/DataTypeChooserDialogTestHelper.java b/Ghidra/Features/Base/src/test/java/ghidra/app/plugin/core/datamgr/util/DataTypeChooserDialogTestHelper.java
new file mode 100644
index 0000000000..d95ac48b90
--- /dev/null
+++ b/Ghidra/Features/Base/src/test/java/ghidra/app/plugin/core/datamgr/util/DataTypeChooserDialogTestHelper.java
@@ -0,0 +1,24 @@
+/* ###
+ * 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.app.plugin.core.datamgr.util;
+
+import ghidra.util.Swing;
+
+public class DataTypeChooserDialogTestHelper {
+ public static void clickOk(DataTypeChooserDialog dialog) {
+ Swing.runNow(dialog::okCallback);
+ }
+}
diff --git a/Ghidra/Framework/Docking/src/main/java/docking/menu/DialogToolbarButton.java b/Ghidra/Framework/Docking/src/main/java/docking/menu/DialogToolbarButton.java
index bbbefffa90..b9f8e1f39d 100644
--- a/Ghidra/Framework/Docking/src/main/java/docking/menu/DialogToolbarButton.java
+++ b/Ghidra/Framework/Docking/src/main/java/docking/menu/DialogToolbarButton.java
@@ -71,6 +71,7 @@ public class DialogToolbarButton extends EmptyBorderToggleButton {
context.setSourceObject(e.getSource());
context.setContextProvider(contextProvider);
+ context.setEventClickModifiers(e.getModifiers());
dockingAction.actionPerformed(context);
});
diff --git a/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/emu/AbstractPcodeMachine.java b/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/emu/AbstractPcodeMachine.java
index ea8ceae914..18a4bdb928 100644
--- a/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/emu/AbstractPcodeMachine.java
+++ b/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/emu/AbstractPcodeMachine.java
@@ -324,12 +324,8 @@ public abstract class AbstractPcodeMachine<T> implements PcodeMachine<T> {
* addressed by formalizing and better exposing the notion of p-code stacks (of p-code
* frames)
*/
- PcodeProgram pcode = compileSleigh("breakpoint:" + address, String.format("""
- if (!(%s)) goto <nobreak>;
- emu_swi();
- <nobreak>
- emu_exec_decoded();
- """, sleighCondition));
+ PcodeProgram pcode = compileSleigh("breakpoint:" + address,
+ SleighUtils.sleighForConditionalBreak(sleighCondition));
injects.put(address, pcode);
}
diff --git a/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/emu/stdoplib/TrigPcodeUseropLibraryFactory.java b/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/emu/stdoplib/TrigPcodeUseropLibraryFactory.java
index 7948ba8f4f..7e79354dbd 100644
--- a/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/emu/stdoplib/TrigPcodeUseropLibraryFactory.java
+++ b/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/emu/stdoplib/TrigPcodeUseropLibraryFactory.java
@@ -20,7 +20,7 @@ import ghidra.pcode.exec.*;
import ghidra.pcode.exec.PcodeUseropLibraryFactory.UseropLibrary;
// This treads on GP-4240 a bit. Still, enough to demonstrate the framework can support it.
-@UseropLibrary("trig")
+@UseropLibrary(id = "trig")
public class TrigPcodeUseropLibraryFactory implements PcodeUseropLibraryFactory {
@Override
diff --git a/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/DiagnosticsPcodeUseropLibraryFactory.java b/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/DiagnosticsPcodeUseropLibraryFactory.java
new file mode 100644
index 0000000000..4dbfae93eb
--- /dev/null
+++ b/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/DiagnosticsPcodeUseropLibraryFactory.java
@@ -0,0 +1,72 @@
+/* ###
+ * 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.pcode.exec;
+
+import ghidra.app.plugin.processors.sleigh.SleighLanguage;
+import ghidra.pcode.exec.PcodeArithmetic.Purpose;
+import ghidra.pcode.exec.PcodeExecutorStatePiece.Reason;
+import ghidra.pcode.exec.PcodeUseropLibraryFactory.UseropLibrary;
+import ghidra.pcode.utils.Utils;
+import ghidra.program.model.pcode.Varnode;
+import ghidra.util.Msg;
+import ghidra.util.NumericUtilities;
+
+@UseropLibrary(id = "diagnostics", includeAlways = true)
+public class DiagnosticsPcodeUseropLibraryFactory implements PcodeUseropLibraryFactory {
+
+ @Override
+ @SuppressWarnings("unchecked")
+ public <T> PcodeUseropLibrary<T> create(SleighLanguage language,
+ PcodeArithmetic<T> arithmetic) {
+ return (PcodeUseropLibrary<T>) DiagnosticsPcodeUseropLibrary.INSTANCE;
+ }
+
+ public static class DiagnosticsPcodeUseropLibrary<T> extends AnnotatedPcodeUseropLibrary<T> {
+ public static final DiagnosticsPcodeUseropLibrary<?> INSTANCE =
+ new DiagnosticsPcodeUseropLibrary<>();
+
+ private DiagnosticsPcodeUseropLibrary() {
+ }
+
+ @PcodeUserop
+ public void emu_probe(@OpExecutor PcodeExecutor<T> exec, Varnode in) {
+ SleighLanguage language = exec.getLanguage();
+ String name = in.toString(language);
+ T value = exec.getState().getVar(in, Reason.INSPECT);
+ byte[] concrete;
+ try {
+ concrete = exec.getArithmetic().toConcrete(value, Purpose.INSPECT);
+ }
+ catch (ConcretionError e) {
+ concrete = null;
+ }
+ String concreteString = concrete == null ? null
+ : "%s (%s)".formatted(
+ NumericUtilities.convertBytesToString(concrete, ":"),
+ Utils.bytesToBigInteger(concrete, in.getSize(), language.isBigEndian(),
+ false));
+ if (value == concrete) {
+ Msg.debug(this, "%s = %s".formatted(name, concreteString));
+ }
+ else if (concrete != null) {
+ Msg.debug(this, "%s = %s => %s (%s)".formatted(name, value, concreteString));
+ }
+ else {
+ Msg.debug(this, "%s = %s".formatted(name, value));
+ }
+ }
+ }
+}
diff --git a/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/PcodeExecutor.java b/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/PcodeExecutor.java
index 1136dacdb8..e9496896d0 100644
--- a/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/PcodeExecutor.java
+++ b/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/PcodeExecutor.java
@@ -67,6 +67,16 @@ public class PcodeExecutor<T> {
this.pcSize = pc != null ? pc.getNumBytes() : language.getDefaultSpace().getPointerSize();
}
+ /**
+ * Construct an executor with the given bindings
+ *
+ * @param state the state, providing arithmetic and storage
+ * @param reason a reason for reading the state with this executor
+ */
+ public PcodeExecutor(PcodeExecutorState<T> state, Reason reason) {
+ this((SleighLanguage) state.getLanguage(), state.getArithmetic(), state, reason);
+ }
+
/**
* Get the executor's Sleigh language (processor model)
*
diff --git a/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/PcodeUseropLibraryFactory.java b/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/PcodeUseropLibraryFactory.java
index e1f09d3b79..8e793a9a48 100644
--- a/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/PcodeUseropLibraryFactory.java
+++ b/Ghidra/Framework/Emulation/src/main/java/ghidra/pcode/exec/PcodeUseropLibraryFactory.java
@@ -17,7 +17,6 @@ package ghidra.pcode.exec;
import java.lang.annotation.*;
import java.util.*;
-import java.util.stream.Collectors;
import ghidra.app.plugin.processors.sleigh.SleighLanguage;
import ghidra.program.model.lang.GhidraLanguagePropertyKeys;
@@ -33,6 +32,7 @@ import ghidra.util.classfinder.ExtensionPoint;
* The factory must have a public default constructor.
*/
public interface PcodeUseropLibraryFactory extends ExtensionPoint {
+ public static final int DEFAULT_ORDER = 100;
/** The property key for useropLib ids in pspec files */
public static final String KEY_USEROP_LIBS = GhidraLanguagePropertyKeys.USEROP_LIBS;
@@ -53,7 +53,23 @@ public interface PcodeUseropLibraryFactory extends ExtensionPoint {
*
* @return the id
*/
- String value();
+ String id();
+
+ /**
+ * Specifies whether this library is always included, regardless of the id
+ *
+ * @return true to include always
+ */
+ boolean includeAlways() default false;
+
+ /**
+ * Determines in what order overrides are applied
+ * <p>
+ * Higher values are applied later, and thus take precedence.
+ *
+ * @return the override order
+ */
+ int order() default DEFAULT_ORDER;
}
/**
@@ -109,8 +125,10 @@ public interface PcodeUseropLibraryFactory extends ExtensionPoint {
*
* <p>
* This composes all of the libraries named in the language's pspec file in the
- * {@value #KEY_USEROP_LIBS} property. That property is a comma-separated list of the ids to
- * compose.
+ * {@value #KEY_USEROP_LIBS} property. That property is a comma-separated list of the
+ * {@link UseropLibrary#id() ids} to compose. The composition also includes libraries marked as
+ * {@link UseropLibrary#includeAlways}. Once all included libraries are identified, they are
+ * sorted by {@link UseropLibrary#order()} and composed, overriding duplicate userops.
*
* <p>
* See the caveats in
@@ -121,48 +139,71 @@ public interface PcodeUseropLibraryFactory extends ExtensionPoint {
* @param language the language
* @param arithmetic the arithmetic
* @return the userop library
- * @implNote currently, duplicate userops (by name) are not permitted. This may change in future
- * versions. Thus, we compose libraries in the order listed, in case of that change,
- * as it would matter.
*/
static <T> PcodeUseropLibrary<T> createUseropLibraryForLanguage(SleighLanguage language,
PcodeArithmetic<T> arithmetic) {
List<String> libIds = List.of(language.getProperty(KEY_USEROP_LIBS, "").split(","));
- Map<String, PcodeUseropLibraryFactory> matches =
- ClassSearcher.getInstances((PcodeUseropLibraryFactory.class))
+ List<PcodeUseropLibraryFactory> matches =
+ ClassSearcher.getInstances(PcodeUseropLibraryFactory.class)
.stream()
- .filter(f -> libIds.contains(f.getId()))
- .collect(Collectors.toMap(f -> f.getId(), f -> f));
+ .filter(f -> f.isIncludeAlways() || libIds.contains(f.getId()))
+ .sorted(Comparator.comparing(f -> f.getOrder()))
+ .toList();
PcodeUseropLibrary<T> result = PcodeUseropLibrary.nil();
- for (String id : libIds) {
- PcodeUseropLibraryFactory factory = matches.get(id);
- if (factory == null) {
- continue;
- }
- result = result.compose(factory.create(language, arithmetic));
+ for (PcodeUseropLibraryFactory factory : matches) {
+ result = result.compose(factory.create(language, arithmetic), true);
}
return result;
}
+ default UseropLibrary getAnnotation() {
+ UseropLibrary annot = this.getClass().getAnnotation(UseropLibrary.class);
+ if (annot == null) {
+ Msg.warn(this,
+ "%s %s is missing @%s annotation".formatted(
+ PcodeUseropLibraryFactory.class.getSimpleName(), this.getClass(),
+ UseropLibrary.class.getSimpleName()));
+ }
+ return annot;
+ }
+
/**
* Get the id of this factory
- *
* <p>
- * This gets the id from the {@link UseropLibrary} annotation. You should not override this
+ * This gets {@link UseropLibrary#id()} from the annotation. You should not override this
* function without a good reason.
*
* @return the id
*/
default String getId() {
- UseropLibrary annot = this.getClass().getAnnotation(UseropLibrary.class);
- if (annot == null) {
- Msg.warn(this,
- "%s %s is missing @%s annotation".formatted(
- PcodeUseropLibraryFactory.class.getSimpleName(), this.getClass(),
- UseropLibrary.class.getSimpleName()));
- return null;
- }
- return annot.value();
+ UseropLibrary annot = getAnnotation();
+ return annot == null ? null : annot.id();
+ }
+
+ /**
+ * Check if this factory's library should always be included.
+ * <p>
+ * This gets {@link UseropLibrary#includeAlways()} from the annotation. You should not override
+ * this function without a good reason.
+ *
+ * @return true if always included
+ */
+ default boolean isIncludeAlways() {
+ UseropLibrary annot = getAnnotation();
+ return annot == null ? false : annot.includeAlways();
+ }
+
+ /**
+ * Get the override order of this library.
+ * <p>
+ * This gets {@link UseropLibrary#order()} from the annotation. You should not override this
+ * function without a good reason.
+ *
+ * @return the order
+ */
+ default int getOrder() {
+ UseropLibrary annot = getAnnotation();
+ return annot == null ? DEFAULT_ORDER : annot.order();
}
/**
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDB.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDB.java
index 818f5382f3..78f72906cd 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDB.java
+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/bookmark/BookmarkDB.java
@@ -176,4 +176,8 @@ public class BookmarkDB extends DbObject implements Bookmark {
super.checkDeleted();
}
+ @Override
+ public boolean isDeleted() {
+ return isDeleted(mgr.lock);
+ }
}
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/PointerDataType.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/PointerDataType.java
index be8be30fc6..5552253b9d 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/PointerDataType.java
+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/data/PointerDataType.java
@@ -21,12 +21,12 @@ import java.util.function.Consumer;
import ghidra.docking.settings.Settings;
import ghidra.program.database.data.DataTypeUtilities;
import ghidra.program.model.address.*;
+import ghidra.program.model.lang.Language;
import ghidra.program.model.listing.*;
import ghidra.program.model.mem.*;
import ghidra.program.model.symbol.*;
import ghidra.util.DataConverter;
import ghidra.util.StringUtilities;
-import ghidra.util.exception.DuplicateNameException;
/**
* Basic implementation for a pointer dataType
@@ -521,10 +521,23 @@ public class PointerDataType extends BuiltIn implements Pointer {
"Address space not defined: " + spaceName + ":" + formatOffset(addrOffset));
return null;
}
+ if (targetSpace.isNonLoadedMemorySpace()) {
+ errorHandler.accept("Address space is non-loaded: " + spaceName + ":" +
+ formatOffset(addrOffset));
+ return null;
+ }
}
if (targetSpace == null) {
targetSpace = buf.getAddress().getAddressSpace();
}
+ if (targetSpace.isRegisterSpace()) {
+ Language language = buf.getLanguage();
+ if (language == null) {
+ errorHandler.accept("Language not specified");
+ return null;
+ }
+ targetSpace = language.getDefaultDataSpace();
+ }
if (targetSpace instanceof SegmentedAddressSpace) {
if (size != 2 && size != 4) {
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/listing/Bookmark.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/listing/Bookmark.java
index 09037c870b..b097c9d44b 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/listing/Bookmark.java
+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/listing/Bookmark.java
@@ -1,13 +1,12 @@
/* ###
* IP: GHIDRA
- * REVIEWED: YES
*
* 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.
@@ -60,4 +59,9 @@ public interface Bookmark extends Comparable<Bookmark> {
* @param comment single line comment
*/
void set(String category, String comment);
+
+ /**
+ * {@return true if this bookmark has been deleted and is no longer valid.}
+ */
+ boolean isDeleted();
}
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/mem/MemBuffer.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/mem/MemBuffer.java
index fd71af2756..48e80cb1cd 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/mem/MemBuffer.java
+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/model/mem/MemBuffer.java
@@ -17,8 +17,11 @@ package ghidra.program.model.mem;
import java.io.InputStream;
import java.math.BigInteger;
+import java.util.Optional;
import ghidra.program.model.address.Address;
+import ghidra.program.model.lang.Language;
+import ghidra.program.model.listing.Program;
/**
* MemBuffer provides an array like interface into memory at a
@@ -119,6 +122,17 @@ public interface MemBuffer {
*/
public Memory getMemory();
+ /**
+ * {@return the Language defining the addresses in this buffer. This may be null, and the
+ * default implementation returns null if the memory or its program is null.}
+ */
+ public default Language getLanguage() {
+ return Optional.ofNullable(getMemory())
+ .map(Memory::getProgram)
+ .map(Program::getLanguage)
+ .orElse(null);
+ }
+
/**
* Returns true if the underlying bytes are in big-endian order, false if they are little endian.
* @return true if the underlying bytes are in big-endian order, false if they are little endian.
diff --git a/Ghidra/Processors/68000/src/main/java/ghidra/program/emulation/M68kPcodeUseropLibraryFactory.java b/Ghidra/Processors/68000/src/main/java/ghidra/program/emulation/M68kPcodeUseropLibraryFactory.java
index a89fef3963..47d68b8ae6 100644
--- a/Ghidra/Processors/68000/src/main/java/ghidra/program/emulation/M68kPcodeUseropLibraryFactory.java
+++ b/Ghidra/Processors/68000/src/main/java/ghidra/program/emulation/M68kPcodeUseropLibraryFactory.java
@@ -19,7 +19,7 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage;
import ghidra.pcode.exec.*;
import ghidra.pcode.exec.PcodeUseropLibraryFactory.UseropLibrary;
-@UseropLibrary("m68k")
+@UseropLibrary(id = "m68k")
public class M68kPcodeUseropLibraryFactory implements PcodeUseropLibraryFactory {
@Override
public <T> PcodeUseropLibrary<T> create(SleighLanguage language,
diff --git a/Ghidra/Processors/AARCH64/src/main/java/ghidra/program/emulation/Aarch64PcodeUseropLibraryFactory.java b/Ghidra/Processors/AARCH64/src/main/java/ghidra/program/emulation/Aarch64PcodeUseropLibraryFactory.java
index 67876a556a..582ea9a189 100644
--- a/Ghidra/Processors/AARCH64/src/main/java/ghidra/program/emulation/Aarch64PcodeUseropLibraryFactory.java
+++ b/Ghidra/Processors/AARCH64/src/main/java/ghidra/program/emulation/Aarch64PcodeUseropLibraryFactory.java
@@ -26,7 +26,7 @@ import ghidra.program.model.pcode.Varnode;
* For the TBL and TBX instructions, see
* https://developer.arm.com/documentation/ddi0602/2024-12/SIMD-FP-Instructions/TBL--Table-vector-lookup-
*/
-@UseropLibrary("aarch64")
+@UseropLibrary(id = "aarch64")
public class Aarch64PcodeUseropLibraryFactory implements PcodeUseropLibraryFactory {
@Override
public <T> PcodeUseropLibrary<T> create(SleighLanguage language,
diff --git a/Ghidra/Processors/ARM/src/main/java/ghidra/program/emulation/ArmPcodeUseropLibraryFactory.java b/Ghidra/Processors/ARM/src/main/java/ghidra/program/emulation/ArmPcodeUseropLibraryFactory.java
index cb29cbe441..e71d591753 100644
--- a/Ghidra/Processors/ARM/src/main/java/ghidra/program/emulation/ArmPcodeUseropLibraryFactory.java
+++ b/Ghidra/Processors/ARM/src/main/java/ghidra/program/emulation/ArmPcodeUseropLibraryFactory.java
@@ -27,7 +27,7 @@ import ghidra.program.model.lang.RegisterValue;
import ghidra.program.model.pcode.Varnode;
import ghidra.util.Msg;
-@UseropLibrary("arm")
+@UseropLibrary(id = "arm")
public class ArmPcodeUseropLibraryFactory implements PcodeUseropLibraryFactory {
@Override
public <T> PcodeUseropLibrary<T> create(SleighLanguage language,
diff --git a/Ghidra/Processors/Hexagon/src/main/java/ghidra/program/emulation/HexagonPcodeUseropLibraryFactory.java b/Ghidra/Processors/Hexagon/src/main/java/ghidra/program/emulation/HexagonPcodeUseropLibraryFactory.java
index eea13a06d9..cfa6d1d82f 100644
--- a/Ghidra/Processors/Hexagon/src/main/java/ghidra/program/emulation/HexagonPcodeUseropLibraryFactory.java
+++ b/Ghidra/Processors/Hexagon/src/main/java/ghidra/program/emulation/HexagonPcodeUseropLibraryFactory.java
@@ -23,7 +23,7 @@ import ghidra.pcode.exec.*;
import ghidra.pcode.exec.PcodeUseropLibraryFactory.UseropLibrary;
import ghidra.program.model.pcode.Varnode;
-@UseropLibrary("hexagon")
+@UseropLibrary(id = "hexagon")
public class HexagonPcodeUseropLibraryFactory implements PcodeUseropLibraryFactory {
@Override
public <T> PcodeUseropLibrary<T> create(SleighLanguage language,
diff --git a/Ghidra/Processors/MIPS/src/main/java/ghidra/program/emulation/MipsPcodeUseropLibraryFactory.java b/Ghidra/Processors/MIPS/src/main/java/ghidra/program/emulation/MipsPcodeUseropLibraryFactory.java
index b4736866dd..acbc45081f 100644
--- a/Ghidra/Processors/MIPS/src/main/java/ghidra/program/emulation/MipsPcodeUseropLibraryFactory.java
+++ b/Ghidra/Processors/MIPS/src/main/java/ghidra/program/emulation/MipsPcodeUseropLibraryFactory.java
@@ -23,7 +23,7 @@ import ghidra.pcode.exec.*;
import ghidra.pcode.exec.PcodeUseropLibraryFactory.UseropLibrary;
import ghidra.program.model.lang.*;
-@UseropLibrary("mips")
+@UseropLibrary(id = "mips")
public class MipsPcodeUseropLibraryFactory implements PcodeUseropLibraryFactory {
@Override
public <T> PcodeUseropLibrary<T> create(SleighLanguage language,
diff --git a/Ghidra/Processors/PowerPC/src/main/java/ghidra/program/emulation/PpcPcodeUseropLibraryFactory.java b/Ghidra/Processors/PowerPC/src/main/java/ghidra/program/emulation/PpcPcodeUseropLibraryFactory.java
index 23a038860d..b8f153f4c5 100644
--- a/Ghidra/Processors/PowerPC/src/main/java/ghidra/program/emulation/PpcPcodeUseropLibraryFactory.java
+++ b/Ghidra/Processors/PowerPC/src/main/java/ghidra/program/emulation/PpcPcodeUseropLibraryFactory.java
@@ -19,7 +19,7 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage;
import ghidra.pcode.exec.*;
import ghidra.pcode.exec.PcodeUseropLibraryFactory.UseropLibrary;
-@UseropLibrary("ppc")
+@UseropLibrary(id = "ppc")
public class PpcPcodeUseropLibraryFactory implements PcodeUseropLibraryFactory {
@Override
public <T> PcodeUseropLibrary<T> create(SleighLanguage language,
diff --git a/Ghidra/Processors/Xtensa/src/main/java/ghidra/program/emulation/XtensaPcodeUseropLibraryFactory.java b/Ghidra/Processors/Xtensa/src/main/java/ghidra/program/emulation/XtensaPcodeUseropLibraryFactory.java
index 11e6a63953..77a3c0a336 100644
--- a/Ghidra/Processors/Xtensa/src/main/java/ghidra/program/emulation/XtensaPcodeUseropLibraryFactory.java
+++ b/Ghidra/Processors/Xtensa/src/main/java/ghidra/program/emulation/XtensaPcodeUseropLibraryFactory.java
@@ -20,7 +20,7 @@ import ghidra.pcode.error.LowlevelError;
import ghidra.pcode.exec.*;
import ghidra.pcode.exec.PcodeUseropLibraryFactory.UseropLibrary;
-@UseropLibrary("xtensa")
+@UseropLibrary(id = "xtensa")
public class XtensaPcodeUseropLibraryFactory implements PcodeUseropLibraryFactory {
@Override
public <T> PcodeUseropLibrary<T> create(SleighLanguage language,
diff --git a/Ghidra/Processors/tricore/src/main/java/ghidra/program/emulation/TricorePcodeUseropLibraryFactory.java b/Ghidra/Processors/tricore/src/main/java/ghidra/program/emulation/TricorePcodeUseropLibraryFactory.java
index bc416798d3..4409245160 100644
--- a/Ghidra/Processors/tricore/src/main/java/ghidra/program/emulation/TricorePcodeUseropLibraryFactory.java
+++ b/Ghidra/Processors/tricore/src/main/java/ghidra/program/emulation/TricorePcodeUseropLibraryFactory.java
@@ -19,7 +19,7 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage;
import ghidra.pcode.exec.*;
import ghidra.pcode.exec.PcodeUseropLibraryFactory.UseropLibrary;
-@UseropLibrary("tricore")
+@UseropLibrary(id = "tricore")
public class TricorePcodeUseropLibraryFactory implements PcodeUseropLibraryFactory {
@Override
public <T> PcodeUseropLibrary<T> create(SleighLanguage language,
diff --git a/Ghidra/Processors/x86/src/main/java/ghidra/program/emulation/X86PcodeUseropLibraryFactory.java b/Ghidra/Processors/x86/src/main/java/ghidra/program/emulation/X86PcodeUseropLibraryFactory.java
index 4bee10029d..a24b86cf0c 100644
--- a/Ghidra/Processors/x86/src/main/java/ghidra/program/emulation/X86PcodeUseropLibraryFactory.java
+++ b/Ghidra/Processors/x86/src/main/java/ghidra/program/emulation/X86PcodeUseropLibraryFactory.java
@@ -19,7 +19,7 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage;
import ghidra.pcode.exec.*;
import ghidra.pcode.exec.PcodeUseropLibraryFactory.UseropLibrary;
-@UseropLibrary("x86")
+@UseropLibrary(id = "x86")
public class X86PcodeUseropLibraryFactory implements PcodeUseropLibraryFactory {
@Override
public <T> PcodeUseropLibrary<T> create(SleighLanguage language,
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/TraceRmiPythonClientTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/TraceRmiPythonClientTest.java
index 23a45009ab..461ed715eb 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/TraceRmiPythonClientTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/TraceRmiPythonClientTest.java
@@ -314,19 +314,19 @@ public class TraceRmiPythonClientTest extends AbstractGhidraHeadedDebuggerTest {
return stdout;
}
- protected ManagedDomainObject openDomainObject(String path) throws Exception {
+ protected ManagedDomainObject<Trace> openTrace(String path) throws Exception {
DomainFile df = env.getProject().getProjectData().getFile(path);
assertNotNull(df);
- return new ManagedDomainObject(df, false, false, monitor);
+ return new ManagedDomainObject<>(df, Trace.class, monitor);
}
- protected ManagedDomainObject waitDomainObject(String path) throws Exception {
+ protected ManagedDomainObject<Trace> waitTrace(String path) throws Exception {
DomainFile df;
long start = System.currentTimeMillis();
while (true) {
df = env.getProject().getProjectData().getFile(path);
if (df != null) {
- return new ManagedDomainObject(df, false, false, monitor);
+ return new ManagedDomainObject<>(df, Trace.class, monitor);
}
Thread.sleep(1000);
if (System.currentTimeMillis() - start > 30000) {
@@ -373,12 +373,8 @@ public class TraceRmiPythonClientTest extends AbstractGhidraHeadedDebuggerTest {
print(trace)
exit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject obj = openDomainObject("/New Traces/test")) {
- switch (obj.get()) {
- case Trace trace -> {
- }
- default -> fail("Wrong type");
- }
+ try (ManagedDomainObject<Trace> obj = openTrace("/New Traces/test")) {
+ // it worked and has the correct type
}
}
@@ -543,8 +539,8 @@ public class TraceRmiPythonClientTest extends AbstractGhidraHeadedDebuggerTest {
exit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject obj = openDomainObject("/New Traces/test")) {
- Trace trace = (Trace) obj.get();
+ try (ManagedDomainObject<Trace> obj = openTrace("/New Traces/test")) {
+ Trace trace = obj.get();
TraceSnapshot snapshot = trace.getTimeManager().getSnapshot(0, false);
assertEquals("Test", snapshot.getDescription());
}
@@ -562,8 +558,8 @@ public class TraceRmiPythonClientTest extends AbstractGhidraHeadedDebuggerTest {
exit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject obj = openDomainObject("/New Traces/test")) {
- Trace trace = (Trace) obj.get();
+ try (ManagedDomainObject<Trace> obj = openTrace("/New Traces/test")) {
+ Trace trace = obj.get();
TraceSnapshot snapshot = trace.getTimeManager().getSnapshot(10, false);
assertEquals("Test", snapshot.getDescription());
}
@@ -589,8 +585,8 @@ public class TraceRmiPythonClientTest extends AbstractGhidraHeadedDebuggerTest {
long snap = Long.parseLong(matchOne(out, Pattern.compile("---SNAP:(-?\\d*)---")).group(1));
assertThat(snap, Matchers.lessThan(0L));
- try (ManagedDomainObject obj = openDomainObject("/New Traces/test")) {
- Trace trace = (Trace) obj.get();
+ try (ManagedDomainObject<Trace> obj = openTrace("/New Traces/test")) {
+ Trace trace = obj.get();
TraceSnapshot snapshot = trace.getTimeManager().getSnapshot(snap, false);
assertEquals("Test", snapshot.getDescription());
}
@@ -613,8 +609,8 @@ public class TraceRmiPythonClientTest extends AbstractGhidraHeadedDebuggerTest {
long snap = Long.parseLong(matchOne(out, Pattern.compile("---SNAP:(-?\\d*)---")).group(1));
assertThat(snap, Matchers.lessThan(0L));
- try (ManagedDomainObject obj = openDomainObject("/New Traces/test")) {
- Trace trace = (Trace) obj.get();
+ try (ManagedDomainObject<Trace> obj = openTrace("/New Traces/test")) {
+ Trace trace = obj.get();
TraceSnapshot snapshot = trace.getTimeManager().getSnapshot(snap, false);
assertEquals("Test", snapshot.getDescription());
}
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/AbstractDbgEngTraceRmiTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/AbstractDbgEngTraceRmiTest.java
index 12ab937987..b3a0b47a4e 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/AbstractDbgEngTraceRmiTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/AbstractDbgEngTraceRmiTest.java
@@ -16,7 +16,7 @@
package agent.dbgeng.rmi;
import static org.junit.Assert.*;
-import static org.junit.Assume.*;
+import static org.junit.Assume.assumeTrue;
import java.io.*;
import java.net.*;
@@ -44,6 +44,7 @@ import ghidra.program.model.address.Address;
import ghidra.program.model.address.AddressRangeImpl;
import ghidra.pty.testutil.DummyProc;
import ghidra.trace.model.Lifespan;
+import ghidra.trace.model.Trace;
import ghidra.trace.model.breakpoint.TraceBreakpointKind;
import ghidra.trace.model.breakpoint.TraceBreakpointKind.TraceBreakpointKindSet;
import ghidra.trace.model.target.TraceObject;
@@ -458,19 +459,19 @@ public abstract class AbstractDbgEngTraceRmiTest extends AbstractGhidraHeadedDeb
return new RegDump();
}
- protected ManagedDomainObject openDomainObject(String path) throws Exception {
+ protected ManagedDomainObject<Trace> openTrace(String path) throws Exception {
DomainFile df = env.getProject().getProjectData().getFile(path);
assertNotNull(df);
- return new ManagedDomainObject(df, false, false, monitor);
+ return new ManagedDomainObject<>(df, Trace.class, monitor);
}
- protected ManagedDomainObject waitDomainObject(String path) throws Exception {
+ protected ManagedDomainObject<Trace> waitTrace(String path) throws Exception {
DomainFile df;
long start = System.currentTimeMillis();
while (true) {
df = env.getProject().getProjectData().getFile(path);
if (df != null) {
- return new ManagedDomainObject(df, false, false, monitor);
+ return new ManagedDomainObject<>(df, Trace.class, monitor);
}
Thread.sleep(1000);
if (System.currentTimeMillis() - start > 30000) {
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngCommandsTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngCommandsTest.java
index 213ca5b3c0..d8235cc6c7 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngCommandsTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngCommandsTest.java
@@ -112,8 +112,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_create('notepad.exe', wait=True)
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("x86:LE:64:default",
tb.trace.getBaseLanguage().getLanguageID().getIdAsString());
assertEquals("windows",
@@ -129,7 +129,7 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_start()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/noname")) {
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/noname")) {
assertThat(mdo.get(), instanceOf(Trace.class));
}
}
@@ -149,8 +149,9 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
.formatted(PREAMBLE, addr));
DomainFile dfMyToy = env.getProject().getProjectData().getFile("/New Traces/pydbg/myToy");
assertNotNull(dfMyToy);
- try (ManagedDomainObject mdo = new ManagedDomainObject(dfMyToy, false, false, monitor)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo =
+ new ManagedDomainObject<>(dfMyToy, Trace.class, monitor)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("Toy:BE:64:default",
tb.trace.getBaseLanguage().getLanguageID().getIdAsString());
assertEquals("default",
@@ -276,8 +277,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_stop()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals(0, tb.trace.getTimeManager().getAllSnapshots().size());
}
@@ -291,8 +292,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_save()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals(1, tb.trace.getTimeManager().getAllSnapshots().size());
}
}
@@ -308,8 +309,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceSnapshot snapshot = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots());
assertEquals(0, snapshot.getKey());
assertEquals("Scripted snapshot", snapshot.getDescription());
@@ -333,8 +334,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
MemDump dump = parseHexDump(extractOutSection(out, "---Dump---"));
@@ -362,8 +363,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
String eval = extractOutSection(out, "---Start---");
@@ -395,8 +396,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
MemDump dump = parseHexDump(extractOutSection(out, "---Dump---"));
@@ -426,8 +427,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr, count));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
List<TraceObjectValue> regVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
@@ -474,8 +475,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
quit()
""".formatted(PREAMBLE, addr, count));
// The spaces will be left over, but the values should be zeroed
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
List<TraceObjectValue> regVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
@@ -505,8 +506,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -530,8 +531,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -557,8 +558,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -583,8 +584,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr, extra, pydbgExpr, gtype));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -737,8 +738,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -768,8 +769,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
print('---')
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -815,8 +816,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("""
Parent Key Span Value Type
Test.Objects[1] vaddr [0,+inf) ram:deadbeef ADDRESS
@@ -855,8 +856,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("""
Parent Key Span Value Type
Test.Objects[1] vaddr [0,+inf) ram:deadbeef ADDRESS""",
@@ -879,7 +880,7 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
// NB: we're losing a race here, regularly
//assertSame(mdo.get(), traceManager.getCurrentTrace());
assertEquals("Test.Objects[1]",
@@ -903,8 +904,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Not concerned about specifics, so long as disassembly occurs
long total = 0;
for (CodeUnit cu : tb.trace.getCodeManager().definedUnits().get(0, true)) {
@@ -928,8 +929,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<TraceObject> processes = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0), PathFilter.parse("Processes[]"))
@@ -950,8 +951,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<TraceObject> available = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0), PathFilter.parse("Sessions[].Available[]"))
@@ -976,8 +977,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
List<TraceObjectValue> procBreakLocVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
PathFilter.parse("Sessions[].Processes[].Debug.Breakpoints[]"))
@@ -1012,8 +1013,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
List<TraceObjectValue> procBreakVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
PathFilter.parse("Sessions[].Processes[].Debug.Breakpoints[]"))
@@ -1052,8 +1053,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Assumes LLDB on Linux amd64
TraceObject env =
Objects.requireNonNull(
@@ -1077,8 +1078,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<? extends TraceMemoryRegion> all =
tb.trace.getMemoryManager().getAllRegions();
@@ -1098,8 +1099,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<? extends TraceModule> all = tb.trace.getModuleManager().getAllModules();
TraceModule modBash =
@@ -1120,8 +1121,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<? extends TraceThread> threads = tb.trace.getThreadManager().getAllThreads();
assertThat(threads.size(), greaterThan(2));
@@ -1140,8 +1141,8 @@ public class DbgEngCommandsTest extends AbstractDbgEngTraceRmiTest {
ghidra_trace_kill()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
List<TraceObject> stack = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngHooksTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngHooksTest.java
index 36692903ed..5ec396ff1a 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngHooksTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngHooksTest.java
@@ -15,9 +15,11 @@
*/
package agent.dbgeng.rmi;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.instanceOf;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
import java.util.*;
@@ -40,7 +42,7 @@ public class DbgEngHooksTest extends AbstractDbgEngTraceRmiTest {
private static final long RUN_TIMEOUT_MS = 5000;
private static final long RETRY_MS = 500;
- record PythonAndTrace(PythonAndConnection conn, ManagedDomainObject mdo)
+ record PythonAndTrace(PythonAndConnection conn, ManagedDomainObject<Trace> mdo)
implements AutoCloseable {
public void execute(String cmd) {
conn.execute(cmd);
@@ -61,19 +63,19 @@ public class DbgEngHooksTest extends AbstractDbgEngTraceRmiTest {
protected PythonAndTrace startAndSyncPython(String exec) throws Exception {
PythonAndConnection conn = startAndConnectPython();
try {
- ManagedDomainObject mdo;
+ ManagedDomainObject<Trace> mdo;
conn.execute("from ghidradbg.commands import *");
conn.execute(
"util.set_convenience_variable('ghidra-language', 'x86:LE:64:default')");
if (exec != null) {
start(conn, exec);
- mdo = waitDomainObject("/New Traces/pydbg/" + exec);
+ mdo = waitTrace("/New Traces/pydbg/" + exec);
}
else {
conn.execute("ghidra_trace_start()");
- mdo = waitDomainObject("/New Traces/pydbg/noname");
+ mdo = waitTrace("/New Traces/pydbg/noname");
}
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ tb = new ToyDBTraceBuilder(mdo.get());
return new PythonAndTrace(conn, mdo);
}
catch (Exception e) {
@@ -215,6 +217,8 @@ public class DbgEngHooksTest extends AbstractDbgEngTraceRmiTest {
* For the moment, we favor option (2), as we'd prefer never to display inaccurate data,
* especially as non-stale. The lost observations are a small price to pay, since they're not
* particularly important for the interactive use case.
+ *
+ * @throws Exception because
*/
@Test
public void testOnMemoryChanged() throws Exception {
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngMethodsTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngMethodsTest.java
index 5a6110108d..c57c6eb76c 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngMethodsTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngMethodsTest.java
@@ -15,6 +15,7 @@
*/
package agent.dbgeng.rmi;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.containsString;
import static org.hamcrest.Matchers.greaterThan;
import static org.junit.Assert.*;
@@ -58,8 +59,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
start(conn, null);
RemoteMethod evaluate = conn.getMethod("evaluate");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("11",
evaluate.invoke(Map.ofEntries(
Map.entry("session", tb.obj("Sessions[0]")),
@@ -84,7 +85,7 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
start(conn, "notepad.exe");
conn.execute("ghidra_trace_kill()");
}
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
// Just confirm it's present
}
}
@@ -97,8 +98,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txCreate(conn, "Sessions[0].Available");
RemoteMethod refreshAvailable = conn.getMethod("refresh_available");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject available = Objects.requireNonNull(tb.objAny0("Sessions[].Available"));
refreshAvailable.invoke(Map.of("node", available));
@@ -120,8 +121,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod refreshBreakpoints = conn.getMethod("refresh_breakpoints");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
conn.execute("pc = util.get_pc()");
conn.execute("util.dbg.bp(expr=pc)");
@@ -157,8 +158,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "all");
RemoteMethod refreshProcWatchpoints = conn.getMethod("refresh_breakpoints");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
conn.execute("pc = util.get_pc()");
conn.execute("util.dbg.ba(expr=pc, access=DbgEng.DEBUG_BREAK_EXECUTE)");
@@ -202,8 +203,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txCreate(conn, "Sessions[0].Processes");
RemoteMethod refreshProcesses = conn.getMethod("refresh_processes");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject processes = Objects.requireNonNull(tb.objAny0("Sessions[].Processes"));
refreshProcesses.invoke(Map.of("node", processes));
@@ -225,8 +226,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "all");
RemoteMethod refreshEnvironment = conn.getMethod("refresh_environment");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject env =
Objects.requireNonNull(tb.objAny0("Sessions[].Processes[].Environment"));
@@ -248,8 +249,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod refreshThreads = conn.getMethod("refresh_threads");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = tb.objAny0("Sessions[].Processes[]");
TraceObject threads = fakeEmpty(proc, "Threads");
@@ -269,8 +270,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod refreshStack = conn.getMethod("refresh_stack");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "frames");
TraceObject stack = Objects.requireNonNull(
@@ -298,8 +299,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
conn.execute("ghidra_trace_txcommit()");
RemoteMethod refreshRegisters = conn.getMethod("refresh_registers");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
conn.execute("util.dbg.cmd('r rax=0xdeadbeef')");
@@ -323,8 +324,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod refreshMappings = conn.getMethod("refresh_mappings");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = tb.objAny0("Sessions[].Processes[]");
TraceObject memory = fakeEmpty(proc, "Memory");
@@ -355,8 +356,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod refreshModules = conn.getMethod("refresh_modules");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = tb.objAny0("Sessions[].Processes[]");
TraceObject modules = fakeEmpty(proc, "Modules");
@@ -378,8 +379,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod activateThread = conn.getMethod("activate_thread");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "threads");
@@ -408,8 +409,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod removeProcess = conn.getMethod("remove_process");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/netstat.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/netstat.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc2 = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
removeProcess.invoke(Map.of("process", proc2));
@@ -428,8 +429,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "available");
RemoteMethod attachObj = conn.getMethod("attach_obj");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject target = Objects.requireNonNull(tb.obj(
"Sessions[0].Available[%d]".formatted(dproc.pid)));
attachObj.invoke(Map.ofEntries(
@@ -450,8 +451,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "available");
RemoteMethod attachPid = conn.getMethod("attach_pid");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
Objects.requireNonNull(tb.obj(
"Sessions[0].Available[%d]".formatted(dproc.pid)));
attachPid.invoke(Map.ofEntries(
@@ -472,8 +473,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod detach = conn.getMethod("detach");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/netstat.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/netstat.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
detach.invoke(Map.of("process", proc));
@@ -491,8 +492,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod launch = conn.getMethod("launch_loader");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
launch.invoke(Map.ofEntries(
Map.entry("session", tb.obj("Sessions[0]")),
@@ -512,8 +513,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod launch = conn.getMethod("launch");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
launch.invoke(Map.ofEntries(
Map.entry("session", tb.obj("Sessions[0]")),
@@ -536,8 +537,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod kill = conn.getMethod("kill");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped("Missed initial stop");
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
@@ -559,8 +560,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
RemoteMethod go = conn.getMethod("go");
RemoteMethod interrupt = conn.getMethod("interrupt");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped("Missed initial stop");
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
@@ -584,8 +585,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod stepInto = conn.getMethod("step_into");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped("Missed initial stop");
txPut(conn, "threads");
@@ -619,8 +620,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod stepOver = conn.getMethod("step_over");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped("Missed initial stop");
txPut(conn, "threads");
@@ -649,8 +650,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
RemoteMethod stepInto = conn.getMethod("step_into");
RemoteMethod stepTo = conn.getMethod("step_to");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "threads");
TraceObject thread =
@@ -682,8 +683,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
RemoteMethod stepInto = conn.getMethod("step_into");
RemoteMethod stepOut = conn.getMethod("step_out");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped("Missed initial stop");
txPut(conn, "threads");
@@ -712,8 +713,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakAddress = conn.getMethod("break_address");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
@@ -733,8 +734,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExpression = conn.getMethod("break_expression");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped("Missed initial stop");
breakExpression.invoke(Map.of("expression", "entry"));
@@ -752,8 +753,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakAddress = conn.getMethod("break_hw_address");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
@@ -773,8 +774,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExpression = conn.getMethod("break_hw_expression");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped("Missed initial stop");
breakExpression.invoke(Map.of("expression", "entry"));
@@ -792,8 +793,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakRange = conn.getMethod("break_read_range");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped("Missed initial stop");
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
@@ -816,8 +817,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExpression = conn.getMethod("break_read_expression");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
breakExpression.invoke(Map.of("expression", "ntdll!LdrInitShimEngineDynamic"));
long address = getAddressAtOffset(conn, 0);
@@ -837,8 +838,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakRange = conn.getMethod("break_write_range");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped("Missed initial stop");
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
@@ -861,8 +862,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExpression = conn.getMethod("break_write_expression");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
breakExpression.invoke(Map.of("expression", "ntdll!LdrInitShimEngineDynamic"));
long address = getAddressAtOffset(conn, 0);
@@ -882,8 +883,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakRange = conn.getMethod("break_access_range");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped("Missed initial stop");
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
@@ -906,8 +907,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExpression = conn.getMethod("break_access_expression");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
breakExpression.invoke(Map.of("expression", "ntdll!LdrInitShimEngineDynamic"));
long address = getAddressAtOffset(conn, 0);
@@ -928,8 +929,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
RemoteMethod breakAddress = conn.getMethod("break_address");
RemoteMethod toggleBreakpoint = conn.getMethod("toggle_breakpoint");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long address = getAddressAtOffset(conn, 0);
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
@@ -955,8 +956,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
RemoteMethod breakAddress = conn.getMethod("break_address");
RemoteMethod deleteBreakpoint = conn.getMethod("delete_breakpoint");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long address = getAddressAtOffset(conn, 0);
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
@@ -1015,8 +1016,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
try (PythonAndConnection conn = startAndConnectPython()) {
openTtdTrace(conn);
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/cmd01.run")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/cmd01.run")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
}
}
}
@@ -1033,8 +1034,8 @@ public class DbgEngMethodsTest extends AbstractDbgEngTraceRmiTest {
txPut(conn, "events");
RemoteMethod activate = conn.getMethod("activate_frame");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/pydbg/cmd01.run")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/pydbg/cmd01.run")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
traceManager.openTrace(tb.trace);
traceManager.activateTrace(tb.trace);
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngStackUnwindTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngStackUnwindTest.java
index f0daffb95f..4e20baec33 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngStackUnwindTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/dbgeng/rmi/DbgEngStackUnwindTest.java
@@ -15,7 +15,8 @@
*/
package agent.dbgeng.rmi;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
import java.io.File;
import java.io.IOException;
@@ -87,7 +88,7 @@ public class DbgEngStackUnwindTest extends AbstractDbgEngTraceRmiTest {
DecompilerProvider decompilerProvider;
DecompilerPanel decompilerPanel;
- record PythonAndTrace(PythonAndConnection conn, ManagedDomainObject mdo)
+ record PythonAndTrace(PythonAndConnection conn, ManagedDomainObject<Trace> mdo)
implements AutoCloseable {
public void execute(String cmd) {
conn.execute(cmd);
@@ -119,10 +120,10 @@ public class DbgEngStackUnwindTest extends AbstractDbgEngTraceRmiTest {
}
@SuppressWarnings("resource")
- protected PythonAndTrace startAndSyncPython(ManagedDomainObject mdo) throws Exception {
+ protected PythonAndTrace startAndSyncPython(ManagedDomainObject<Trace> mdo) throws Exception {
PythonAndConnection conn = startAndConnectPython();
try {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ tb = new ToyDBTraceBuilder(mdo.get());
return new PythonAndTrace(conn, mdo);
}
catch (Exception e) {
@@ -145,8 +146,8 @@ public class DbgEngStackUnwindTest extends AbstractDbgEngTraceRmiTest {
tool.acceptDomainFiles(dfs);
DomainFile traceDF = getDomainFile("expSpin_dbgeng");
- ManagedDomainObject mdo = new ManagedDomainObject(traceDF, false, false, monitor);
- resyncMappings((Trace) mdo.get());
+ ManagedDomainObject<Trace> mdo = new ManagedDomainObject<>(traceDF, Trace.class, monitor);
+ resyncMappings(mdo.get());
tool.acceptDomainFiles(new DomainFile[] { traceDF });
programs = openPrograms(dfs);
@@ -173,8 +174,8 @@ public class DbgEngStackUnwindTest extends AbstractDbgEngTraceRmiTest {
tool.acceptDomainFiles(dfs);
DomainFile traceDF = getDomainFile("expSpin_dbgeng");
- ManagedDomainObject mdo = new ManagedDomainObject(traceDF, false, false, monitor);
- resyncMappings((Trace) mdo.get());
+ ManagedDomainObject<Trace> mdo = new ManagedDomainObject<>(traceDF, Trace.class, monitor);
+ resyncMappings(mdo.get());
tool.acceptDomainFiles(new DomainFile[] { traceDF });
programs = openPrograms(dfs);
@@ -203,8 +204,8 @@ public class DbgEngStackUnwindTest extends AbstractDbgEngTraceRmiTest {
tool.acceptDomainFiles(dfs);
DomainFile traceDF = getDomainFile("expSpin_dbgeng");
- ManagedDomainObject mdo = new ManagedDomainObject(traceDF, false, false, monitor);
- resyncMappings((Trace) mdo.get());
+ ManagedDomainObject<Trace> mdo = new ManagedDomainObject<>(traceDF, Trace.class, monitor);
+ resyncMappings(mdo.get());
tool.acceptDomainFiles(new DomainFile[] { traceDF });
programs = openPrograms(dfs);
@@ -233,8 +234,8 @@ public class DbgEngStackUnwindTest extends AbstractDbgEngTraceRmiTest {
tool.acceptDomainFiles(dfs);
DomainFile traceDF = getDomainFile("expSpin_dbgeng");
- ManagedDomainObject mdo = new ManagedDomainObject(traceDF, false, false, monitor);
- resyncMappings((Trace) mdo.get());
+ ManagedDomainObject<Trace> mdo = new ManagedDomainObject<>(traceDF, Trace.class, monitor);
+ resyncMappings(mdo.get());
tool.acceptDomainFiles(new DomainFile[] { traceDF });
programs = openPrograms(dfs);
@@ -260,8 +261,8 @@ public class DbgEngStackUnwindTest extends AbstractDbgEngTraceRmiTest {
tool.acceptDomainFiles(dfs);
DomainFile traceDF = getDomainFile("expSpin_dbgeng");
- ManagedDomainObject mdo = new ManagedDomainObject(traceDF, false, false, monitor);
- resyncMappings((Trace) mdo.get());
+ ManagedDomainObject<Trace> mdo = new ManagedDomainObject<>(traceDF, Trace.class, monitor);
+ resyncMappings(mdo.get());
tool.acceptDomainFiles(new DomainFile[] { traceDF });
programs = openPrograms(dfs);
@@ -287,8 +288,8 @@ public class DbgEngStackUnwindTest extends AbstractDbgEngTraceRmiTest {
tool.acceptDomainFiles(dfs);
DomainFile traceDF = getDomainFile("expSpin_dbgeng");
- ManagedDomainObject mdo = new ManagedDomainObject(traceDF, false, false, monitor);
- resyncMappings((Trace) mdo.get());
+ ManagedDomainObject<Trace> mdo = new ManagedDomainObject<>(traceDF, Trace.class, monitor);
+ resyncMappings(mdo.get());
tool.acceptDomainFiles(new DomainFile[] { traceDF });
programs = openPrograms(dfs);
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/drgn/rmi/AbstractDrgnTraceRmiTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/drgn/rmi/AbstractDrgnTraceRmiTest.java
index fcac0d7779..7afeca207e 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/drgn/rmi/AbstractDrgnTraceRmiTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/drgn/rmi/AbstractDrgnTraceRmiTest.java
@@ -46,6 +46,7 @@ import ghidra.framework.plugintool.Plugin;
import ghidra.framework.plugintool.PluginsConfiguration;
import ghidra.framework.plugintool.util.*;
import ghidra.pty.testutil.DummyProc;
+import ghidra.trace.model.Trace;
import ghidra.util.Msg;
import ghidra.util.SystemUtilities;
import junit.framework.AssertionFailedError;
@@ -320,19 +321,19 @@ public abstract class AbstractDrgnTraceRmiTest extends AbstractGhidraHeadedDebug
return xout.split(head)[1].split("---")[0].replace("(python)", "").trim();
}
- protected ManagedDomainObject openDomainObject(String path) throws Exception {
+ protected ManagedDomainObject<Trace> openTrace(String path) throws Exception {
DomainFile df = env.getProject().getProjectData().getFile(path);
assertNotNull(df);
- return new ManagedDomainObject(df, false, false, monitor);
+ return new ManagedDomainObject<>(df, Trace.class, monitor);
}
- protected ManagedDomainObject waitDomainObject(String path) throws Exception {
+ protected ManagedDomainObject<Trace> waitTrace(String path) throws Exception {
DomainFile df;
long start = System.currentTimeMillis();
while (true) {
df = env.getProject().getProjectData().getFile(path);
if (df != null) {
- return new ManagedDomainObject(df, false, false, monitor);
+ return new ManagedDomainObject<>(df, Trace.class, monitor);
}
Thread.sleep(1000);
if (System.currentTimeMillis() - start > 30000) {
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/drgn/rmi/DrgnCommandsTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/drgn/rmi/DrgnCommandsTest.java
index d4e30c0db0..25b6b60f4d 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/drgn/rmi/DrgnCommandsTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/drgn/rmi/DrgnCommandsTest.java
@@ -15,6 +15,7 @@
*/
package agent.drgn.rmi;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*;
import static org.junit.Assume.assumeFalse;
@@ -110,8 +111,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
ghidra_trace_create()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("x86:LE:64:default",
tb.trace.getBaseLanguage().getLanguageID().getIdAsString());
assertEquals("gcc",
@@ -127,7 +128,7 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
ghidra_trace_start()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/drgn/noname")) {
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/drgn/noname")) {
assertThat(mdo.get(), instanceOf(Trace.class));
}
}
@@ -147,8 +148,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
.formatted(PREAMBLE, addr));
DomainFile df = env.getProject().getProjectData().getFile("/New Traces/myToy");
assertNotNull(df);
- try (ManagedDomainObject mdo = new ManagedDomainObject(df, false, false, monitor)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = new ManagedDomainObject<>(df, Trace.class, monitor)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("Toy:BE:64:default",
tb.trace.getBaseLanguage().getLanguageID().getIdAsString());
assertEquals("default",
@@ -266,8 +267,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceSnapshot snapshot = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots());
assertEquals(0, snapshot.getKey());
assertEquals("Scripted snapshot", snapshot.getDescription());
@@ -289,8 +290,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr, count));
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
List<TraceObjectValue> regVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
@@ -330,8 +331,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
quit()
""".formatted(PREAMBLE, addr, count));
// The spaces will be left over, but the values should be zeroed
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
List<TraceObjectValue> regVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
@@ -361,8 +362,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/drgn/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/drgn/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -386,8 +387,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/drgn/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/drgn/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -412,8 +413,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -437,8 +438,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr, extra, drgnExpr, gtype));
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -590,8 +591,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -621,8 +622,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
print('---')
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/drgn/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/drgn/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -667,8 +668,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
print('---')
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("""
Parent Key Span Value Type
Test.Objects[1] vaddr [0,+inf) ram:deadbeef ADDRESS
@@ -706,8 +707,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
print('---')
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("""
Parent Key Span Value Type
Test.Objects[1] vaddr [0,+inf) ram:deadbeef ADDRESS""",
@@ -729,7 +730,7 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
ghidra_trace_activate('Test.Objects[1]')
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
assertSame(mdo.get(), traceManager.getCurrentTrace());
assertEquals("Test.Objects[1]",
traceManager.getCurrentObject().getCanonicalPath().toString());
@@ -751,8 +752,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Not concerned about specifics, so long as disassembly occurs
long total = 0;
for (CodeUnit cu : tb.trace.getCodeManager().definedUnits().get(0, true)) {
@@ -776,8 +777,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/drgn/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/drgn/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<TraceObject> processes = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0), PathFilter.parse("Processes[]"))
@@ -798,8 +799,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Assumes LLDB on Linux amd64
TraceObject envobj =
Objects.requireNonNull(tb.objAny("Processes[].Environment", Lifespan.at(0)));
@@ -825,8 +826,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
quit()
""".formatted(PREAMBLE, addr));
assumeFalse(stdout.contains("IGNOREME"));
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<? extends TraceMemoryRegion> all =
tb.trace.getMemoryManager().getAllRegions();
@@ -849,8 +850,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
quit()
""".formatted(PREAMBLE, addr));
assumeFalse(stdout.contains("IGNOREME"));
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<? extends TraceModule> all = tb.trace.getModuleManager().getAllModules();
TraceModule modBash =
@@ -870,8 +871,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<? extends TraceThread> threads = tb.trace.getThreadManager().getAllThreads();
assertEquals(1, threads.size());
@@ -889,8 +890,8 @@ public class DrgnCommandsTest extends AbstractDrgnTraceRmiTest {
ghidra_trace_txcommit()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
List<TraceObject> stack = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/drgn/rmi/DrgnMethodsTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/drgn/rmi/DrgnMethodsTest.java
index 4486990ab5..3a1902a99c 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/drgn/rmi/DrgnMethodsTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/drgn/rmi/DrgnMethodsTest.java
@@ -15,6 +15,7 @@
*/
package agent.drgn.rmi;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.greaterThan;
import static org.junit.Assert.*;
import static org.junit.Assume.assumeFalse;
@@ -59,7 +60,7 @@ public class DrgnMethodsTest extends AbstractDrgnTraceRmiTest {
try (PythonAndConnection conn = startAndConnectDrgn()) {
start(conn, null);
}
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
// Just confirm it's present
}
}
@@ -72,8 +73,8 @@ public class DrgnMethodsTest extends AbstractDrgnTraceRmiTest {
RemoteMethod attachCore = conn.getMethod("attach_core");
RemoteMethod refreshProcesses = conn.getMethod("refresh_processes");
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject processes = Objects.requireNonNull(tb.objAny0("Processes"));
refreshProcesses.invoke(Map.of("node", processes));
@@ -106,8 +107,8 @@ public class DrgnMethodsTest extends AbstractDrgnTraceRmiTest {
txPut(conn, "all");
RemoteMethod refreshEnvironment = conn.getMethod("refresh_environment");
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject envobj = Objects.requireNonNull(tb.objAny0(path));
refreshEnvironment.invoke(Map.of("node", envobj));
@@ -128,8 +129,8 @@ public class DrgnMethodsTest extends AbstractDrgnTraceRmiTest {
txCreate(conn, path);
RemoteMethod refreshThreads = conn.getMethod("refresh_threads");
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject threads = Objects.requireNonNull(tb.objAny0(path));
refreshThreads.invoke(Map.of("node", threads));
@@ -148,8 +149,8 @@ public class DrgnMethodsTest extends AbstractDrgnTraceRmiTest {
txPut(conn, "processes");
RemoteMethod refreshStack = conn.getMethod("refresh_stack");
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "frames");
TraceObject stack = Objects.requireNonNull(tb.objAny0(path));
@@ -177,8 +178,8 @@ public class DrgnMethodsTest extends AbstractDrgnTraceRmiTest {
conn.execute("ghidra_trace_txcommit()");
RemoteMethod refreshRegisters = conn.getMethod("refresh_registers");
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject registers = Objects.requireNonNull(tb.objAny(path, Lifespan.at(0)));
refreshRegisters.invoke(Map.of("node", registers));
@@ -204,8 +205,8 @@ public class DrgnMethodsTest extends AbstractDrgnTraceRmiTest {
assumeFalse(out.equals("False"));
RemoteMethod refreshMappings = conn.getMethod("refresh_mappings");
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject memory = Objects.requireNonNull(tb.objAny0(path));
refreshMappings.invoke(Map.of("node", memory));
@@ -229,8 +230,8 @@ public class DrgnMethodsTest extends AbstractDrgnTraceRmiTest {
assumeFalse(out.equals("False"));
RemoteMethod refreshModules = conn.getMethod("refresh_modules");
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject modules = Objects.requireNonNull(tb.objAny0(path));
refreshModules.invoke(Map.of("node", modules));
@@ -251,8 +252,8 @@ public class DrgnMethodsTest extends AbstractDrgnTraceRmiTest {
txPut(conn, "processes");
RemoteMethod activateThread = conn.getMethod("activate_thread");
- try (ManagedDomainObject mdo = openDomainObject(MDO)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(MDO)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "threads");
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/AbstractGdbTraceRmiTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/AbstractGdbTraceRmiTest.java
index 84fb8db08f..1c618cc500 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/AbstractGdbTraceRmiTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/AbstractGdbTraceRmiTest.java
@@ -46,6 +46,7 @@ import ghidra.framework.plugintool.util.*;
import ghidra.program.model.address.Address;
import ghidra.program.model.address.AddressRangeImpl;
import ghidra.pty.testutil.DummyProc;
+import ghidra.trace.model.Trace;
import ghidra.trace.model.TraceExecutionState;
import ghidra.trace.model.breakpoint.TraceBreakpointKind;
import ghidra.trace.model.breakpoint.TraceBreakpointKind.TraceBreakpointKindSet;
@@ -446,19 +447,19 @@ public abstract class AbstractGdbTraceRmiTest extends AbstractGhidraHeadedDebugg
waitForPass(() -> assertFalse(df.isOpen()));
}
- protected ManagedDomainObject openDomainObject(String path) throws Exception {
+ protected ManagedDomainObject<Trace> openTrace(String path) throws Exception {
DomainFile df = env.getProject().getProjectData().getFile(path);
assertNotNull(df);
- return new ManagedDomainObject(df, false, false, monitor);
+ return new ManagedDomainObject<>(df, Trace.class, monitor);
}
- protected ManagedDomainObject waitDomainObject(String path) throws Exception {
+ protected ManagedDomainObject<Trace> waitTrace(String path) throws Exception {
DomainFile df;
long start = System.currentTimeMillis();
while (true) {
df = env.getProject().getProjectData().getFile(path);
if (df != null) {
- return new ManagedDomainObject(df, false, false, monitor);
+ return new ManagedDomainObject<>(df, Trace.class, monitor);
}
Thread.sleep(1000);
if (System.currentTimeMillis() - start > 30000) {
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/GdbCommandsTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/GdbCommandsTest.java
index 0115cc5c71..a80e80bb65 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/GdbCommandsTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/GdbCommandsTest.java
@@ -116,8 +116,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
ghidra trace start
quit
""".formatted(PREAMBLE, addr, target));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals(PLAT.lang(),
tb.trace.getBaseLanguage().getLanguageID().getIdAsString());
String id = tb.trace.getBaseCompilerSpec().getCompilerSpecID().getIdAsString();
@@ -133,7 +133,7 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
ghidra trace start
quit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
assertThat(mdo.get(), instanceOf(Trace.class));
}
}
@@ -152,8 +152,9 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
""".formatted(PREAMBLE, addr, target));
DomainFile dfMyToy = env.getProject().getProjectData().getFile("/New Traces/myToy");
assertNotNull(dfMyToy);
- try (ManagedDomainObject mdo = new ManagedDomainObject(dfMyToy, false, false, monitor)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo =
+ new ManagedDomainObject<>(dfMyToy, Trace.class, monitor)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("Toy:BE:64:default",
tb.trace.getBaseLanguage().getLanguageID().getIdAsString());
assertEquals("default",
@@ -285,8 +286,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
quit
""".formatted(PREAMBLE, addr, target));
waitDomainObjectClosed("/New Traces/no-save");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/no-save")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/no-save")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals(0, tb.trace.getTimeManager().getAllSnapshots().size());
}
@@ -302,8 +303,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
quit
""".formatted(PREAMBLE, addr, target));
waitDomainObjectClosed("/New Traces/save");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/save")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/save")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals(1, tb.trace.getTimeManager().getAllSnapshots().size());
}
}
@@ -321,8 +322,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
ghidra trace tx-commit
quit
""".formatted(PREAMBLE, addr, target));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceSnapshot snapshot = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots());
assertEquals(0, snapshot.getKey());
assertEquals("Scripted snapshot", snapshot.getDescription());
@@ -348,8 +349,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, target, PLAT.startCmd()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
MemDump dump = parseHexDump(extractOutSection(out, "---Dump---"));
@@ -381,8 +382,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, target, PLAT.startCmd()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
AddressSpace ram2 = tb.trace.getBaseAddressFactory().getAddressSpace("ram2");
assertNotNull(ram2);
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
@@ -414,8 +415,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, target, PLAT.startCmd()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
String eval = extractOutSection(out, "---Start---");
@@ -448,8 +449,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, target, PLAT.startCmd()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
MemDump dump = parseHexDump(extractOutSection(out, "---Dump---"));
@@ -482,8 +483,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, target, PLAT.startCmd(), count));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
AddressSpace t1f0 = tb.trace.getBaseAddressFactory()
.getAddressSpace("Inferiors[1].Threads[1].Stack[0].Registers");
@@ -527,8 +528,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
quit
""".formatted(PREAMBLE, addr, target, PLAT.startCmd(), count));
// The spaces will be left over, but the values should be zeroed
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
AddressSpace t1f0 = tb.trace.getBaseAddressFactory()
.getAddressSpace("Inferiors[1].Threads[1].Stack[0].Registers");
@@ -560,8 +561,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
ghidra trace tx-commit
quit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -585,8 +586,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
ghidra trace tx-commit
quit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -612,8 +613,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
ghidra trace tx-commit
quit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -641,8 +642,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, expPrint, PLAT.startCmd(), extra, gdbExpr, gtype));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -802,8 +803,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, target, PLAT.startCmd()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -833,8 +834,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
echo \\n---
quit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -879,8 +880,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, expPrint, PLAT.startCmd()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("""
Parent Key Span Value Type
Test.Objects[1] vaddr [0,+inf) ram:deadbeef ADDRESS
@@ -923,8 +924,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, target, PLAT.startCmd()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("""
Parent Key Span Value Type
Test.Objects[1] vaddr [0,+inf) ram:deadbeef ADDRESS""",
@@ -950,7 +951,7 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, target, PLAT.startCmd()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
assertSame(mdo.get(), traceManager.getCurrentTrace());
assertEquals("Test.Objects[1]",
traceManager.getCurrentObject().getCanonicalPath().toString());
@@ -976,8 +977,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, target, PLAT.startCmd()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Not concerned about specifics, so long as disassembly occurs
long total = 0;
for (CodeUnit cu : tb.trace.getCodeManager().definedUnits().get(0, true)) {
@@ -1000,8 +1001,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
ghidra trace tx-commit
quit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<TraceObject> inferiors = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0), PathFilter.parse("Inferiors[]"))
@@ -1025,8 +1026,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
ghidra trace tx-commit
quit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<TraceObject> available = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0), PathFilter.parse("Available[]"))
@@ -1056,8 +1057,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, target));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
List<TraceObjectValue> infBreakLocVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
PathFilter.parse("Inferiors[1].Breakpoints[]"))
@@ -1098,8 +1099,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, target, PLAT.startCmd()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Assumes GDB on Linux amd64
TraceObject env = Objects.requireNonNull(tb.obj("Inferiors[1].Environment"));
assertEquals("gdb", env.getValue(0, "_debugger").getValue());
@@ -1124,8 +1125,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, target, PLAT.startCmd()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<? extends TraceMemoryRegion> all =
tb.trace.getMemoryManager().getAllRegions();
@@ -1148,8 +1149,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, target, PLAT.startCmd()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<? extends TraceModule> all = tb.trace.getModuleManager().getAllModules();
TraceModule modExpPrint =
@@ -1173,8 +1174,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, target, PLAT.startCmd()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Unique.assertOne(tb.trace.getThreadManager().getAllThreads());
}
@@ -1197,8 +1198,8 @@ public class GdbCommandsTest extends AbstractGdbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, target, PLAT.startCmd()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expRead"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expRead"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
List<TraceObject> stack = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/GdbHooksTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/GdbHooksTest.java
index 08606d8b9d..c67f374cc8 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/GdbHooksTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/GdbHooksTest.java
@@ -45,7 +45,8 @@ public class GdbHooksTest extends AbstractGdbTraceRmiTest {
private static final long RUN_TIMEOUT_MS = 20000;
private static final long RETRY_MS = 500;
- record GdbAndTrace(GdbAndConnection conn, ManagedDomainObject mdo) implements AutoCloseable {
+ record GdbAndTrace(GdbAndConnection conn, ManagedDomainObject<Trace> mdo)
+ implements AutoCloseable {
public void execute(String cmd) {
conn.execute(cmd);
}
@@ -84,8 +85,8 @@ public class GdbHooksTest extends AbstractGdbTraceRmiTest {
set ghidra-language x86:LE:64:default
ghidra trace start
ghidra trace sync-enable""");
- ManagedDomainObject mdo = waitDomainObject("/New Traces/gdb/noname");
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ ManagedDomainObject<Trace> mdo = waitTrace("/New Traces/gdb/noname");
+ tb = new ToyDBTraceBuilder(mdo.get());
return new GdbAndTrace(conn, mdo);
}
catch (Exception e) {
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/GdbMethodsTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/GdbMethodsTest.java
index 09925c7f4f..b38317eedc 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/GdbMethodsTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/gdb/rmi/GdbMethodsTest.java
@@ -79,7 +79,7 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
ghidra trace start
kill""".formatted(target, PLAT.startCmd())));
}
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
// Just confirm it's present
}
}
@@ -93,8 +93,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
ghidra trace start
ghidra trace tx-open "Fake" 'ghidra trace create-obj Available'""");
RemoteMethod refreshAvailable = conn.getMethod("refresh_available");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject available = Objects.requireNonNull(tb.obj("Available"));
refreshAvailable.invoke(Map.of("node", available));
@@ -120,8 +120,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
starti"""
.formatted(target, INSTRUMENT_STOPPED));
RemoteMethod refreshBreakpoints = conn.getMethod("refresh_breakpoints");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
conn.execute("""
@@ -171,8 +171,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
starti"""
.formatted(target, INSTRUMENT_STOPPED));
RemoteMethod refreshInfBreakpoints = conn.getMethod("refresh_inf_breakpoints");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
TraceObject locations = Objects.requireNonNull(tb.obj("Inferiors[1].Breakpoints"));
@@ -218,8 +218,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
ghidra trace start
ghidra trace tx-open "Fake" 'ghidra trace create-obj Inferiors'""");
RemoteMethod refreshInferiors = conn.getMethod("refresh_inferiors");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject inferiors = Objects.requireNonNull(tb.obj("Inferiors"));
refreshInferiors.invoke(Map.of("node", inferiors));
@@ -246,8 +246,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
ghidra trace tx-open "Fake" 'ghidra trace create-obj %s'""".formatted(target,
path));
RemoteMethod refreshEnvironment = conn.getMethod("refresh_environment");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject env = Objects.requireNonNull(tb.obj(path));
refreshEnvironment.invoke(Map.of("node", env));
@@ -273,8 +273,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
ghidra trace tx-open "Fake" 'ghidra trace create-obj %s'""".formatted(target,
path));
RemoteMethod refreshThreads = conn.getMethod("refresh_threads");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject threads = Objects.requireNonNull(tb.obj(path));
refreshThreads.invoke(Map.of("node", threads));
@@ -299,8 +299,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
run"""
.formatted(target, INSTRUMENT_STOPPED, path));
RemoteMethod refreshStack = conn.getMethod("refresh_stack");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expRead"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expRead"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
TraceObject stack = Objects.requireNonNull(tb.obj(path));
@@ -333,8 +333,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
start"""
.formatted(target, INSTRUMENT_STOPPED, path));
RemoteMethod refreshRegisters = conn.getMethod("refresh_registers");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
conn.execute("""
@@ -380,8 +380,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
ghidra trace tx-open "Fake" 'ghidra trace create-obj %s'""".formatted(target,
PLAT.startCmd(), path));
RemoteMethod refreshMappings = conn.getMethod("refresh_mappings");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject memory = Objects.requireNonNull(tb.obj(path));
refreshMappings.invoke(Map.of("node", memory));
@@ -412,8 +412,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
ghidra trace tx-open "Fake" 'ghidra trace create-obj %s'""".formatted(target,
path));
RemoteMethod refreshModules = conn.getMethod("refresh_modules");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject modules = Objects.requireNonNull(tb.obj(path));
refreshModules.invoke(Map.of("node", modules));
@@ -436,8 +436,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
ghidra trace start
ghidra trace tx-open Init 'ghidra trace put-inferiors'""");
RemoteMethod activateInferior = conn.getMethod("activate_inferior");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
List<TraceObject> list = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0), PathFilter.parse("Inferiors[]"))
@@ -474,8 +474,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
ghidra trace tx-open Start2 'ghidra trace put-threads'""".formatted(target,
PLAT.startCmd(), target, PLAT.startCmd()));
RemoteMethod activateThread = conn.getMethod("activate_thread");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
PathPattern pattern =
PathFilter.parse("Inferiors[].Threads[]").getSingletonPattern();
@@ -508,8 +508,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
run"""
.formatted(target, INSTRUMENT_STOPPED));
RemoteMethod activateFrame = conn.getMethod("activate_frame");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expRead"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expRead"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
conn.execute("ghidra trace tx-open Init 'ghidra trace put-frames'");
@@ -539,8 +539,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
ghidra trace start
ghidra trace tx-open Init 'ghidra trace put-inferiors'""");
RemoteMethod deleteInferior = conn.getMethod("delete_inferior");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject inf2 = Objects.requireNonNull(tb.obj("Inferiors[2]"));
deleteInferior.invoke(Map.of("inferior", inf2));
@@ -564,8 +564,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
ghidra trace tx-open Init 'ghidra trace put-available'
ghidra trace tx-open Init 'ghidra trace put-inferiors'""");
RemoteMethod attachObj = conn.getMethod("attach_obj");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject target =
Objects.requireNonNull(tb.obj("Available[%d]".formatted(proc.pid)));
attachObj.invoke(Map.of("target", target));
@@ -589,8 +589,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
ghidra trace start
ghidra trace tx-open Init 'ghidra trace put-inferiors'""");
RemoteMethod attachPid = conn.getMethod("attach_pid");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject inf = Objects.requireNonNull(tb.obj("Inferiors[1]"));
attachPid.invoke(Map.of("inferior", inf, "pid", proc.pid));
@@ -616,8 +616,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
attach %d"""
.formatted(INSTRUMENT_STOPPED, proc.pid));
RemoteMethod detach = conn.getMethod("detach");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
TraceObject inf = Objects.requireNonNull(tb.obj("Inferiors[1]"));
@@ -639,8 +639,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
ghidra trace tx-open Init 'ghidra trace put-inferiors'"""
.formatted(INSTRUMENT_STOPPED));
RemoteMethod launchMain = conn.getMethod("launch_main");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject inf = Objects.requireNonNull(tb.obj("Inferiors[1]"));
launchMain.invoke(Map.ofEntries(
@@ -663,8 +663,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
ghidra trace tx-open Init 'ghidra trace put-inferiors'"""
.formatted(INSTRUMENT_STOPPED));
RemoteMethod launchLoader = conn.getMethod("launch_loader");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject inf = Objects.requireNonNull(tb.obj("Inferiors[1]"));
launchLoader.invoke(Map.ofEntries(
@@ -693,8 +693,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
ghidra trace tx-open Init 'ghidra trace put-inferiors'"""
.formatted(INSTRUMENT_STOPPED, INSTRUMENT_RUNNING));
RemoteMethod launchRun = conn.getMethod("launch_run");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/gdb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/gdb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject inf = Objects.requireNonNull(tb.obj("Inferiors[1]"));
launchRun.invoke(Map.ofEntries(
@@ -729,8 +729,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod kill = conn.getMethod("kill");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
TraceObject inf = Objects.requireNonNull(tb.obj("Inferiors[1]"));
@@ -765,8 +765,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s
start"""
.formatted(target, INSTRUMENT_STOPPED, INSTRUMENT_RUNNING));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expSpin"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expSpin"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
conn.execute("ghidra trace tx-open Before do-put-before");
@@ -804,8 +804,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod stepInto = conn.getMethod("step_into");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
conn.execute("ghidra trace tx-open Init 'ghidra trace put-threads'");
@@ -836,8 +836,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod step_over = conn.getMethod("step_over");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
conn.execute("ghidra trace tx-open Init 'ghidra trace put-threads'");
@@ -883,8 +883,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod stepOut = conn.getMethod("step_out");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
conn.execute("ghidra trace tx-open Init 'ghidra trace put-threads'");
@@ -912,8 +912,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod stepAdvance = conn.getMethod("step_advance");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
conn.execute("ghidra trace tx-open Init 'ghidra trace put-threads'");
@@ -941,8 +941,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod stepReturn = conn.getMethod("step_return");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
conn.execute("ghidra trace tx-open Init 'ghidra trace put-threads'");
@@ -969,8 +969,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod breakSwExecuteAddress = conn.getMethod("break_sw_execute_address");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
TraceObject inf = Objects.requireNonNull(tb.obj("Inferiors[1]"));
@@ -994,8 +994,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod breakSwExecuteExpression = conn.getMethod("break_sw_execute_expression");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
// Use *main instead of main, because some gdb will instead do <main+8>
@@ -1018,8 +1018,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod breakHwExecuteAddress = conn.getMethod("break_hw_execute_address");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
TraceObject inf = Objects.requireNonNull(tb.obj("Inferiors[1]"));
@@ -1044,8 +1044,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod breakHwExecuteExpression = conn.getMethod("break_hw_execute_expression");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
breakHwExecuteExpression.invoke(Map.of("expression", "*main"));
@@ -1068,8 +1068,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod breakReadRange = conn.getMethod("break_read_range");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
TraceObject inf = Objects.requireNonNull(tb.obj("Inferiors[1]"));
@@ -1096,8 +1096,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod breakReadExpression = conn.getMethod("break_read_expression");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
breakReadExpression.invoke(Map.of("expression", "main"));
@@ -1120,8 +1120,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod breakWriteRange = conn.getMethod("break_write_range");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
TraceObject inf = Objects.requireNonNull(tb.obj("Inferiors[1]"));
@@ -1148,8 +1148,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod breakWriteExpression = conn.getMethod("break_write_expression");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
breakWriteExpression.invoke(Map.of("expression", "main"));
@@ -1172,8 +1172,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod breakAccessRange = conn.getMethod("break_access_range");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
TraceObject inf = Objects.requireNonNull(tb.obj("Inferiors[1]"));
@@ -1200,8 +1200,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod breakAccessExpression = conn.getMethod("break_access_expression");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
breakAccessExpression.invoke(Map.of("expression", "main"));
@@ -1224,8 +1224,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
%s"""
.formatted(target, INSTRUMENT_STOPPED, PLAT.startCmd()));
RemoteMethod breakEvent = conn.getMethod("break_ext_event");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
TraceObject inf = Objects.requireNonNull(tb.obj("Inferiors[1]"));
@@ -1252,8 +1252,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
run"""
.formatted(target, INSTRUMENT_STOPPED));
RemoteMethod toggleBreakpoint = conn.getMethod("toggle_breakpoint");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
conn.execute("ghidra trace tx-open Init 'ghidra trace put-breakpoints'");
TraceObject bpt = Objects.requireNonNull(tb.obj("Breakpoints[1]"));
@@ -1279,8 +1279,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
run"""
.formatted(target, INSTRUMENT_STOPPED));
RemoteMethod toggleBreakpointLocation = conn.getMethod("toggle_breakpoint_location");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
conn.execute("ghidra trace tx-open Init 'ghidra trace put-breakpoints'");
// NB. Requires canonical path. Inf[1].Brk[1] is a link
@@ -1322,8 +1322,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
run"""
.formatted(target, INSTRUMENT_STOPPED));
RemoteMethod deleteBreakpoint = conn.getMethod("delete_breakpoint");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
conn.execute("ghidra trace tx-open Init 'ghidra trace put-breakpoints'");
TraceObject bpt = Objects.requireNonNull(tb.obj("Breakpoints[1]"));
@@ -1348,8 +1348,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
run"""
.formatted(target, INSTRUMENT_STOPPED));
RemoteMethod readMem = conn.getMethod("read_mem");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
long snap = 0;
long pcOff = Long.decode(conn.executeCapture("print/x $pc").split("=")[1].strip());
@@ -1381,8 +1381,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
run"""
.formatted(target, INSTRUMENT_STOPPED));
RemoteMethod writeMem = conn.getMethod("write_mem");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
long pcOff = Long.decode(conn.executeCapture("print/x $pc").split("=")[1].strip());
TraceObject inf1 = Objects.requireNonNull(tb.obj("Inferiors[1]"));
@@ -1411,8 +1411,8 @@ public class GdbMethodsTest extends AbstractGdbTraceRmiTest {
run"""
.formatted(target, INSTRUMENT_STOPPED));
RemoteMethod writeReg = conn.getMethod("write_reg");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped();
conn.execute("ghidra trace tx-open Init 'ghidra trace putreg'");
TraceObject frame =
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/AbstractJavaTraceRmiTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/AbstractJavaTraceRmiTest.java
index af16da241e..2a79acc9bf 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/AbstractJavaTraceRmiTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/AbstractJavaTraceRmiTest.java
@@ -45,6 +45,7 @@ import ghidra.framework.plugintool.PluginsConfiguration;
import ghidra.framework.plugintool.util.*;
import ghidra.program.model.address.Address;
import ghidra.trace.model.Lifespan;
+import ghidra.trace.model.Trace;
import ghidra.trace.model.target.TraceObject;
import ghidra.trace.model.target.TraceObjectValue;
import ghidra.trace.model.target.path.PathFilter;
@@ -401,22 +402,22 @@ public abstract class AbstractJavaTraceRmiTest extends AbstractGhidraHeadedDebug
return new MemDump(address, buf.toByteArray());
}
- protected ManagedDomainObject openDomainObject(String path) throws Exception {
+ protected ManagedDomainObject<Trace> openTrace(String path) throws Exception {
DomainFile dfx = waitForPass(() -> {
DomainFile df = env.getProject().getProjectData().getFile(path);
assertNotNull(df);
return df;
}, TIMEOUT_SECONDS * 1000, 500);
- return new ManagedDomainObject(dfx, false, false, monitor);
+ return new ManagedDomainObject<>(dfx, Trace.class, monitor);
}
- protected ManagedDomainObject waitDomainObject(String path) throws Exception {
+ protected ManagedDomainObject<Trace> waitTrace(String path) throws Exception {
DomainFile df;
long start = System.currentTimeMillis();
while (true) {
df = env.getProject().getProjectData().getFile(path);
if (df != null) {
- return new ManagedDomainObject(df, false, false, monitor);
+ return new ManagedDomainObject<Trace>(df, Trace.class, monitor);
}
Thread.sleep(1000);
if (System.currentTimeMillis() - start > 30000) {
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/JavaCommandsTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/JavaCommandsTest.java
index 13a401783c..c8d0a45d6e 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/JavaCommandsTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/JavaCommandsTest.java
@@ -15,6 +15,7 @@
*/
package agent.java.rmi;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.greaterThan;
import static org.hamcrest.Matchers.instanceOf;
import static org.junit.Assert.*;
@@ -123,8 +124,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceStart("HelloWorld.class");
/exit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("JVM:BE:32:default",
tb.trace.getBaseLanguage().getLanguageID().getIdAsString());
assertEquals("default",
@@ -140,7 +141,7 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceStart(null);
/exit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/jdi/noname")) {
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/jdi/noname")) {
assertThat(mdo.get(), instanceOf(Trace.class));
}
}
@@ -241,8 +242,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceDisconnect();
/exit
""".formatted(PREAMBLE, addr, HWSETUP));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals(0, tb.trace.getTimeManager().getAllSnapshots().size());
}
finally {
@@ -264,8 +265,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceDisconnect();
/exit
""".formatted(PREAMBLE, addr, HWSETUP));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertNotEquals(0, tb.trace.getTimeManager().getAllSnapshots().size());
}
}
@@ -280,8 +281,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceSave();
/exit
""".formatted(PREAMBLE, addr, HWSETUP));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals(2, tb.trace.getTimeManager().getAllSnapshots().size());
TraceSnapshot snapshot = getLastSnapshot();
assertEquals(1, snapshot.getKey());
@@ -306,8 +307,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceDisconnect();
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = getLastSnapshot().getKey();
MemDump dump = parseHexDump(extractOutSection(out, "---Dump---"));
ByteBuffer buf = ByteBuffer.allocate(dump.data().length);
@@ -334,8 +335,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceDisconnect();
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = getLastSnapshot().getKey();
String eval = extractOutSection(out, "---Start---");
List<String> lines = List.of(eval.split("\n"));
@@ -366,8 +367,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceDisconnect();
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = getLastSnapshot().getKey();
MemDump dump = parseHexDump(extractOutSection(out, "---Dump---"));
Arrays.fill(dump.data(), 0, 8, (byte) 0);
@@ -390,8 +391,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceDisconnect();
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = getLastSnapshot().getKey();
List<TraceObjectValue> regVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(snap),
@@ -423,8 +424,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
// The spaces will be left over, but the values should be zeroed
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = getLastSnapshot().getKey();
List<TraceObjectValue> regVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(snap),
@@ -452,8 +453,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceSave();
/exit
""".formatted(PREAMBLE, addr, TESTSETUP));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/Test")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/Test")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1].Bob"));
assertNotNull(object);
@@ -475,8 +476,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceSave();
/exit
""".formatted(PREAMBLE, addr, TESTSETUP));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/Test")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/Test")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1].Bob"));
assertNotNull(object);
@@ -501,8 +502,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceDisconnect();
/exit
""".formatted(PREAMBLE, addr, TESTSETUP));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/Test")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/Test")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -526,8 +527,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceDisconnect();
/exit
""".formatted(PREAMBLE, addr, TESTSETUP, extra, value, schema));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/Test")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/Test")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = getLastSnapshot().getKey();
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
@@ -626,8 +627,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceDisconnect();
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = getLastSnapshot().getKey();
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("VMs"));
@@ -654,8 +655,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
/exit
"""
.formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = getLastSnapshot().getKey();
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("VMs"));
@@ -687,8 +688,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceDisconnect();
/exit
""".formatted(PREAMBLE, addr, TESTSETUP));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/Test")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/Test")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -721,8 +722,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceSave();
/exit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/jdi/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/jdi/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -762,8 +763,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceDisconnect();
/exit
""".formatted(PREAMBLE, addr, TESTSETUP));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/Test")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/Test")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals(
"Parent Key Span Value Type \n" +
"Test.Objects[1] [0..+inf) vbool true BOOL \n" +
@@ -803,7 +804,7 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceSave();
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
assertEquals("VMs[OpenJDK 64-Bit Server VM].Threads[Finalizer]",
traceManager.getCurrentObject().getCanonicalPath().toString());
}
@@ -822,8 +823,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceSave();
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = getLastSnapshot().getKey();
// Not concerned about specifics, so long as disassembly occurs
long total = 0;
@@ -848,8 +849,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceSave();
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = getLastSnapshot().getKey();
Collection<TraceObject> vms = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(snap), PathFilter.parse("VMs[]"))
@@ -870,8 +871,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceSave();
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = getLastSnapshot().getKey();
Collection<TraceObject> processes = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(snap), PathFilter.parse("VMs[].Processes"))
@@ -892,8 +893,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceSave();
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
Collection<? extends TraceModule> all = tb.trace.getModuleManager().getAllModules();
TraceModule mod = Unique.assertOne(
all.stream().filter(m -> m.getName(SNAP).contains("Thread.class")));
@@ -913,8 +914,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceDisconnect();
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
Collection<? extends TraceThread> threads = tb.trace.getThreadManager().getAllThreads();
assertEquals(4, threads.size());
Set<String> names = new HashSet<>();
@@ -941,8 +942,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceDisconnect();
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = getLastSnapshot().getKey();
List<TraceObject> stack = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(snap),
@@ -964,8 +965,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceSave();
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
Collection<? extends TraceMemoryRegion> all =
tb.trace.getMemoryManager().getAllRegions();
assertThat(all.size(), greaterThan(90));
@@ -984,8 +985,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceSave();
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = getLastSnapshot().getKey();
List<TraceObjectValue> events = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(snap),
@@ -1010,8 +1011,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
cmds.ghidraTraceSave();
/exit
""".formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = getLastSnapshot().getKey();
List<TraceObjectValue> breaks = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(snap),
@@ -1044,8 +1045,8 @@ public class JavaCommandsTest extends AbstractJavaTraceRmiTest {
/exit
"""
.formatted(PREAMBLE, addr, HWSETUP_W_STATE));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = getLastSnapshot().getKey();
List<TraceObjectValue> breaks = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(snap),
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/JavaHooksTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/JavaHooksTest.java
index 109d754de1..16dab68eef 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/JavaHooksTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/JavaHooksTest.java
@@ -42,8 +42,8 @@ public class JavaHooksTest extends AbstractJavaTraceRmiTest {
start(conn, "HelloWorld.class");
RemoteMethod refreshMethod = conn.getMethod("refresh_method");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
conn.execute("VirtualMachine vm = manager.getCurrentVM();");
conn.execute("ThreadReference thread = manager.getCurrentThread();");
conn.execute("EventRequestManager mgr = vm.eventRequestManager();");
@@ -85,8 +85,8 @@ public class JavaHooksTest extends AbstractJavaTraceRmiTest {
RemoteMethod resume = conn.getMethod("resume_thread");
RemoteMethod breakOnEnter = conn.getMethod("break_enter_thread");
RemoteMethod refreshMethod = conn.getMethod("refresh_method");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -135,8 +135,8 @@ public class JavaHooksTest extends AbstractJavaTraceRmiTest {
RemoteMethod resume = conn.getMethod("resume_thread");
RemoteMethod breakOnExit = conn.getMethod("break_exit_thread");
RemoteMethod refreshMethod = conn.getMethod("refresh_method");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -184,8 +184,8 @@ public class JavaHooksTest extends AbstractJavaTraceRmiTest {
RemoteMethod stepInto = conn.getMethod("step_into");
RemoteMethod resume = conn.getMethod("resume_thread");
RemoteMethod breakLoad = conn.getMethod("break_load_container");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -216,8 +216,8 @@ public class JavaHooksTest extends AbstractJavaTraceRmiTest {
RemoteMethod resume = conn.getMethod("resume_thread");
RemoteMethod breakStart = conn.getMethod("break_started_container");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -245,8 +245,8 @@ public class JavaHooksTest extends AbstractJavaTraceRmiTest {
RemoteMethod stepInto = conn.getMethod("step_into");
RemoteMethod resume = conn.getMethod("resume_thread");
RemoteMethod breakDeath = conn.getMethod("break_death_container");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -280,8 +280,8 @@ public class JavaHooksTest extends AbstractJavaTraceRmiTest {
RemoteMethod refreshMethod = conn.getMethod("refresh_method");
RemoteMethod refreshLocations = conn.getMethod("refresh_locations");
RemoteMethod breakOnExecute = conn.getMethod("break_location");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -328,8 +328,8 @@ public class JavaHooksTest extends AbstractJavaTraceRmiTest {
RemoteMethod resume = conn.getMethod("resume_thread");
RemoteMethod refreshFields = conn.getMethod("refresh_canonical_fields");
RemoteMethod breakOnAccess = conn.getMethod("break_access");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/JavaMethodsTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/JavaMethodsTest.java
index 03d45b55ee..070cb2e6f0 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/JavaMethodsTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/java/rmi/JavaMethodsTest.java
@@ -68,7 +68,7 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
public void testExecute() throws Exception {
try (JshellAndConnection conn = startAndConnectJshell()) {
start(conn, "HelloWorld.class");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
// Just confirm it's present
}
}
@@ -81,8 +81,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod refreshEvents = conn.getMethod("refresh_events");
RemoteMethod stepInto = conn.getMethod("step_into");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -120,8 +120,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod refreshBreakpoints = conn.getMethod("refresh_breakpoints");
RemoteMethod stepInto = conn.getMethod("step_into");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -169,8 +169,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod refreshVM = conn.getMethod("refresh_vm");
RemoteMethod refreshProcess = conn.getMethod("refresh_process");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "VMs");
TraceObject vm = waitForObject("VMs[]");
@@ -198,8 +198,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
start(conn, "HelloWorld.class");
RemoteMethod refreshThreads = conn.getMethod("refresh_threads");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "VMs");
TraceObject threads = waitForObject("VMs[].Threads");
@@ -221,8 +221,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod resume = conn.getMethod("resume_thread");
RemoteMethod stepInto = conn.getMethod("step_into");
RemoteMethod refreshStack = conn.getMethod("refresh_stack");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject events = waitForObject("VMs[].Events");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -272,8 +272,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod refreshRegisters = conn.getMethod("refresh_registers");
RemoteMethod stepInto = conn.getMethod("step_into");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -309,8 +309,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod refreshMemory = conn.getMethod("refresh_memory");
RemoteMethod stepInto = conn.getMethod("step_into");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -335,8 +335,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod refreshClasses = conn.getMethod("refresh_reference_types");
RemoteMethod stepInto = conn.getMethod("step_into");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -361,8 +361,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod refreshModules = conn.getMethod("refresh_modules");
RemoteMethod stepInto = conn.getMethod("step_into");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -387,8 +387,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
start(conn, "HelloWorld.class");
RemoteMethod refreshThreads = conn.getMethod("refresh_threads");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "VMs");
TraceObject threads = waitForObject("VMs[].Threads");
@@ -422,8 +422,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
start(conn, "HelloWorld.class");
RemoteMethod kill = conn.getMethod("kill");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "VMs");
TraceObject vm = waitForObject("VMs[]");
@@ -450,8 +450,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod setClsFilt = conn.getMethod("set_class_filter");
RemoteMethod resume = conn.getMethod("resume_thread");
RemoteMethod stepInto = conn.getMethod("step_into");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject events = waitForObject("VMs[].Events");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -498,8 +498,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod setClsFilt = conn.getMethod("set_class_filter");
RemoteMethod resume = conn.getMethod("resume_thread");
RemoteMethod stepOver = conn.getMethod("step_over");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject events = waitForObject("VMs[].Events");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -541,8 +541,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod resume = conn.getMethod("resume_thread");
RemoteMethod stepInto = conn.getMethod("step_into");
RemoteMethod stepOut = conn.getMethod("step_out");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject events = waitForObject("VMs[].Events");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -586,8 +586,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod stepInto = conn.getMethod("step_into");
RemoteMethod resume = conn.getMethod("resume_thread");
RemoteMethod breakOnEnter = conn.getMethod("break_enter_thread");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -622,8 +622,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod refreshMethod = conn.getMethod("refresh_method");
RemoteMethod refreshLocations = conn.getMethod("refresh_locations");
RemoteMethod breakOnExecute = conn.getMethod("break_location");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -668,8 +668,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod resume = conn.getMethod("resume_thread");
RemoteMethod refreshFields = conn.getMethod("refresh_canonical_fields");
RemoteMethod breakOnAccess = conn.getMethod("break_access");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -708,8 +708,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod refreshBreakpoints = conn.getMethod("refresh_breakpoints");
RemoteMethod toggleBreakpoint = conn.getMethod("toggle_breakpoint");
RemoteMethod stepInto = conn.getMethod("step_into");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
@@ -750,8 +750,8 @@ public class JavaMethodsTest extends AbstractJavaTraceRmiTest {
RemoteMethod refreshBreakpoints = conn.getMethod("refresh_breakpoints");
RemoteMethod deleteBreakpoint = conn.getMethod("delete_breakpoint");
RemoteMethod stepInto = conn.getMethod("step_into");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/HelloWorld.class")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/HelloWorld.class")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "Threads");
TraceObject thread = waitForObject("VMs[].Threads[main]");
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 e99dfc4245..ec3e0adf9f 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
@@ -15,7 +15,8 @@
*/
package agent.lldb.rmi;
-import static org.hamcrest.Matchers.*;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.startsWith;
import static org.junit.Assert.*;
import java.io.*;
@@ -51,6 +52,7 @@ import ghidra.pty.*;
import ghidra.pty.testutil.DummyProc;
import ghidra.pty.windows.AnsiBufferedInputStream;
import ghidra.trace.model.Lifespan;
+import ghidra.trace.model.Trace;
import ghidra.trace.model.breakpoint.TraceBreakpointKind;
import ghidra.trace.model.breakpoint.TraceBreakpointKind.TraceBreakpointKindSet;
import ghidra.trace.model.target.TraceObject;
@@ -501,19 +503,19 @@ public abstract class AbstractLldbTraceRmiTest extends AbstractGhidraHeadedDebug
waitForPass(() -> assertFalse(df.isOpen()));
}
- protected ManagedDomainObject openDomainObject(String path) throws Exception {
+ protected ManagedDomainObject<Trace> openTrace(String path) throws Exception {
DomainFile df = env.getProject().getProjectData().getFile(path);
assertNotNull(df);
- return new ManagedDomainObject(df, false, false, monitor);
+ return new ManagedDomainObject<>(df, Trace.class, monitor);
}
- protected ManagedDomainObject waitDomainObject(String path) throws Exception {
+ protected ManagedDomainObject<Trace> waitTrace(String path) throws Exception {
DomainFile df;
long start = System.currentTimeMillis();
while (true) {
df = env.getProject().getProjectData().getFile(path);
if (df != null) {
- return new ManagedDomainObject(df, false, false, monitor);
+ return new ManagedDomainObject<>(df, Trace.class, monitor);
}
Thread.sleep(1000);
if (System.currentTimeMillis() - start > 30000) {
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 0767f7084d..ff3dbe1d37 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
@@ -113,8 +113,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
ghidra trace start
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals(PLAT.lang(),
tb.trace.getBaseLanguage().getLanguageID().getIdAsString());
assertEquals(PLAT.cSpec(),
@@ -130,7 +130,7 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
ghidra trace start
quit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) {
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/lldb/noname")) {
assertThat(mdo.get(), instanceOf(Trace.class));
}
}
@@ -150,8 +150,9 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
.formatted(PREAMBLE, addr, getSpecimenPrint()));
DomainFile dfMyToy = env.getProject().getProjectData().getFile("/New Traces/myToy");
assertNotNull(dfMyToy);
- try (ManagedDomainObject mdo = new ManagedDomainObject(dfMyToy, false, false, monitor)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo =
+ new ManagedDomainObject<>(dfMyToy, Trace.class, monitor)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("Toy:BE:64:default",
tb.trace.getBaseLanguage().getLanguageID().getIdAsString());
assertEquals("default",
@@ -274,8 +275,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
waitDomainObjectClosed("/New Traces/no-save");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/no-save")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/no-save")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals(0, tb.trace.getTimeManager().getAllSnapshots().size());
}
@@ -291,8 +292,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
waitDomainObjectClosed("/New Traces/save");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/save")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/save")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals(1, tb.trace.getTimeManager().getAllSnapshots().size());
}
}
@@ -310,8 +311,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
ghidra trace save
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceSnapshot snapshot = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots());
assertEquals(0, snapshot.getKey());
assertEquals("Scripted snapshot", snapshot.getDescription());
@@ -337,8 +338,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
MemDump dump = parseHexDump(extractOutSection(out, "---Dump---"));
@@ -371,8 +372,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
String eval = extractOutSectionWithPrompt(out, "---Start---");
@@ -409,8 +410,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
String xout = extractOutSectionWithPrompt(out, "---Dump---");
@@ -442,8 +443,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint(), PLAT.intReg(), PLAT.floatReg()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
List<TraceObjectValue> regVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
@@ -503,8 +504,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint(), PLAT.intReg(), PLAT.floatReg()));
// The spaces will be left over, but the values should be zeroed
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
List<TraceObjectValue> regVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
@@ -552,8 +553,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
ghidra trace save
quit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/lldb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -578,8 +579,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
ghidra trace save
quit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/lldb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -608,8 +609,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -637,8 +638,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint(), extra, lldbExpr, gtype));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -828,8 +829,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -860,8 +861,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
script print("---")
quit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/lldb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -899,8 +900,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("""
Parent Key Span Value Type
Test.Objects[1] vaddr [0,+inf) ram:0000dead ADDRESS
@@ -937,8 +938,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertTrue(extractOutSectionWithPrompt(out, "---GetValues---").contains("""
Parent Key Span Value Type
Test.Objects[1] vaddr [0,+inf) ram:0000dead ADDRESS\
@@ -962,7 +963,7 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
assertSame(mdo.get(), traceManager.getCurrentTrace());
assertEquals("Test.Objects[1]",
traceManager.getCurrentObject().getCanonicalPath().toString());
@@ -987,8 +988,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Not concerned about specifics, so long as disassembly occurs
long total = 0;
for (CodeUnit cu : tb.trace.getCodeManager().definedUnits().get(0, true)) {
@@ -1011,8 +1012,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
ghidra trace save
quit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/lldb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<TraceObject> processes = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0), PathFilter.parse("Processes[]"))
@@ -1034,8 +1035,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
ghidra trace save
quit
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/lldb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<TraceObject> available = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0), PathFilter.parse("Available[]"))
@@ -1062,8 +1063,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
List<TraceObjectValue> procBreakLocVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
PathFilter.parse("Processes[].Breakpoints[][1]"))
@@ -1100,8 +1101,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
List<TraceObjectValue> procWatchLocVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
PathFilter.parse("Processes[].Watchpoints[]"))
@@ -1143,8 +1144,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Assumes LLDB on Linux amd64
TraceObject env =
Objects.requireNonNull(tb.objAny("Processes[].Environment", Lifespan.at(0)));
@@ -1170,8 +1171,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<? extends TraceMemoryRegion> all =
tb.trace.getMemoryManager().getAllRegions();
@@ -1194,8 +1195,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<? extends TraceModule> all = tb.trace.getModuleManager().getAllModules();
TraceModule modExpPrint =
@@ -1219,8 +1220,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
kill
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Unique.assertOne(tb.trace.getThreadManager().getAllThreads());
}
@@ -1246,8 +1247,8 @@ public class LldbCommandsTest extends AbstractLldbTraceRmiTest {
quit
""".formatted(PREAMBLE, addr, getSpecimenPrint()));
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
List<TraceObject> stack = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
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 dbe4a95844..b2aed3d959 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
@@ -43,7 +43,8 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest {
private static final long RUN_TIMEOUT_MS = 5000;
private static final long RETRY_MS = 500;
- record LldbAndTrace(LldbAndConnection conn, ManagedDomainObject mdo) implements AutoCloseable {
+ record LldbAndTrace(LldbAndConnection conn, ManagedDomainObject<Trace> mdo)
+ implements AutoCloseable {
public void execute(String cmd) {
conn.execute(cmd);
}
@@ -82,8 +83,8 @@ public class LldbHooksTest extends AbstractLldbTraceRmiTest {
LldbAndConnection conn = startAndConnectLldb();
try {
conn.execute("ghidra trace start");
- ManagedDomainObject mdo = waitDomainObject("/New Traces/lldb/noname");
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ ManagedDomainObject<Trace> mdo = waitTrace("/New Traces/lldb/noname");
+ tb = new ToyDBTraceBuilder(mdo.get());
return new LldbAndTrace(conn, mdo);
}
catch (Exception e) {
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 af42d81888..1c850e2687 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
@@ -70,7 +70,7 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
conn.execute("kill");
conn.success();
}
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
// Just confirm it's present
}
}
@@ -82,8 +82,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txCreate(conn, "Available");
RemoteMethod refreshAvailable = conn.getMethod("refresh_available");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/lldb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject available = Objects.requireNonNull(tb.objAny0("Available"));
refreshAvailable.invoke(Map.of("node", available));
@@ -107,8 +107,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "breakpoints");
RemoteMethod refreshProcBreakpoints = conn.getMethod("refresh_proc_breakpoints");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
TraceObject locations =
@@ -144,8 +144,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "all");
RemoteMethod refreshProcWatchpoints = conn.getMethod("refresh_proc_watchpoints");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
TraceObject locations =
@@ -192,8 +192,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txCreate(conn, "Processes[1]");
RemoteMethod refreshProcesses = conn.getMethod("refresh_processes");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/lldb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject processes = Objects.requireNonNull(tb.objAny0("Processes"));
refreshProcesses.invoke(Map.of("node", processes));
@@ -217,8 +217,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "all");
RemoteMethod refreshEnvironment = conn.getMethod("refresh_environment");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject env = Objects.requireNonNull(tb.objAny0(path));
refreshEnvironment.invoke(Map.of("node", env));
@@ -240,8 +240,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txCreate(conn, path);
RemoteMethod refreshThreads = conn.getMethod("refresh_threads");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject threads = Objects.requireNonNull(tb.objAny0(path));
refreshThreads.invoke(Map.of("node", threads));
@@ -263,8 +263,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
breakAt(conn, "wrapputs");
RemoteMethod refreshStack = conn.getMethod("refresh_stack");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
waitTxDone();
@@ -294,8 +294,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
conn.execute("ghidra trace tx-commit");
RemoteMethod refreshRegisters = conn.getMethod("refresh_registers");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
conn.execute("expr $%s = 0xdeadbeef".formatted(PLAT.intReg()));
@@ -322,8 +322,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txCreate(conn, path);
RemoteMethod refreshMappings = conn.getMethod("refresh_mappings");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject memory = Objects.requireNonNull(tb.objAny0(path));
refreshMappings.invoke(Map.of("node", memory));
@@ -345,8 +345,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txCreate(conn, path);
RemoteMethod refreshModules = conn.getMethod("refresh_modules");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject modules = Objects.requireNonNull(tb.objAny0(path));
refreshModules.invoke(Map.of("node", modules));
@@ -374,9 +374,9 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
breakAt(conn, "work");
RemoteMethod activateThread = conn.getMethod("activate_thread");
- try (ManagedDomainObject mdo = openDomainObject(
+ try (ManagedDomainObject<Trace> mdo = openTrace(
IS_WINDOWS ? projectName("expCreateThreadExit") : projectName("expCloneExit"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
waitTxDone();
@@ -414,8 +414,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
breakAt(conn, "wrapputs");
RemoteMethod activateFrame = conn.getMethod("activate_frame");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
waitTxDone();
@@ -446,8 +446,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod removeProcess = conn.getMethod("remove_process");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc2 = Objects.requireNonNull(tb.objAny0("Processes[]"));
removeProcess.invoke(Map.of("process", proc2));
@@ -471,8 +471,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod attachObj = conn.getMethod("attach");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/lldb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject target =
Objects.requireNonNull(tb.obj("Available[%d]".formatted(dproc.pid)));
attachObj.invoke(Map.of("target", target));
@@ -496,8 +496,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod attachPid = conn.getMethod("attach_pid");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/lldb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc =
Objects.requireNonNull(tb.objAny("Processes[]", Lifespan.at(0)));
attachPid.invoke(Map.of("process", proc, "pid", dproc.pid));
@@ -518,8 +518,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
//conn.execute("process attach -p %d".formatted(dproc.pid));
RemoteMethod detach = conn.getMethod("detach");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = Objects.requireNonNull(tb.objAny0("Processes[]"));
detach.invoke(Map.of("process", proc));
@@ -539,8 +539,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod launch = conn.getMethod("launch_loader");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/lldb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = Objects.requireNonNull(tb.objAny0("Processes[]"));
launch.invoke(Map.ofEntries(
@@ -562,8 +562,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod launch = conn.getMethod("launch");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/lldb/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/lldb/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = Objects.requireNonNull(tb.objAny0("Processes[]"));
launch.invoke(Map.ofEntries(
@@ -593,8 +593,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod kill = conn.getMethod("kill");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
TraceObject proc = Objects.requireNonNull(tb.objAny0("Processes[]"));
@@ -648,8 +648,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod step_into = conn.getMethod("step_into");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
waitTxDone();
@@ -678,8 +678,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod step_over = conn.getMethod("step_over");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
txPut(conn, "threads");
conn.execute("script lldb.debugger.SetAsync(False)");
@@ -708,8 +708,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod step_advance = conn.getMethod("step_advance");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
txPut(conn, "threads");
conn.execute("script lldb.debugger.SetAsync(False)");
@@ -743,9 +743,9 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
RemoteMethod activate = conn.getMethod("activate_thread");
RemoteMethod step_out = conn.getMethod("step_out");
- try (ManagedDomainObject mdo =
- openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo =
+ openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
waitTxDone();
@@ -776,8 +776,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
RemoteMethod activate = conn.getMethod("activate_thread");
RemoteMethod ret = conn.getMethod("step_return");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
waitTxDone();
@@ -804,8 +804,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakAddress = conn.getMethod("break_address");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = Objects.requireNonNull(tb.objAny0("Processes[]"));
long address = Long.decode(conn.executeCapture("dis -c1 -n main").split("\\s+")[1]);
@@ -826,8 +826,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExpression = conn.getMethod("break_expression");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
breakExpression.invoke(Map.of("expression", "main"));
@@ -847,8 +847,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakAddress = conn.getMethod("break_hw_address");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
TraceObject proc = Objects.requireNonNull(tb.objAny0("Processes[]"));
@@ -869,8 +869,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExpression = conn.getMethod("break_hw_expression");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
breakExpression.invoke(Map.of("expression", "`(void(*)())main`"));
@@ -891,8 +891,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakRange = conn.getMethod("break_read_range");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
TraceObject proc = Objects.requireNonNull(tb.objAny0("Processes[]"));
@@ -918,8 +918,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExpression = conn.getMethod("break_read_expression");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
breakExpression.invoke(Map.of(
"expression", "`(void(*)())main`",
@@ -941,8 +941,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakRange = conn.getMethod("break_write_range");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
TraceObject proc = Objects.requireNonNull(tb.objAny0("Processes[]"));
@@ -970,8 +970,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExpression = conn.getMethod("break_write_expression");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
breakExpression.invoke(Map.of(
"expression", "`(void(*)())main`",
@@ -995,8 +995,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakRange = conn.getMethod("break_access_range");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
TraceObject proc = Objects.requireNonNull(tb.objAny0("Processes[]"));
@@ -1022,8 +1022,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExpression = conn.getMethod("break_access_expression");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
breakExpression.invoke(Map.of(
"expression", "`(void(*)())main`",
@@ -1046,8 +1046,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExc = conn.getMethod("break_exception");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
breakExc.invoke(Map.of("lang", "C++"));
@@ -1066,8 +1066,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod toggleBreakpoint = conn.getMethod("toggle_breakpoint");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
conn.execute("breakpoint set -n main");
@@ -1090,8 +1090,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod toggleBreakpointLocation = conn.getMethod("toggle_breakpoint_location");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
conn.execute("breakpoint set -n main");
@@ -1115,8 +1115,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
txPut(conn, "processes");
RemoteMethod deleteBreakpoint = conn.getMethod("delete_breakpoint");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
waitStopped(conn);
conn.execute("breakpoint set -n main");
@@ -1140,8 +1140,8 @@ public class LldbMethodsTest extends AbstractLldbTraceRmiTest {
RemoteMethod breakExpression = conn.getMethod("break_read_expression");
RemoteMethod deleteWatchpoint = conn.getMethod("delete_watchpoint");
- try (ManagedDomainObject mdo = openDomainObject(projectName("expPrint"))) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace(projectName("expPrint"))) {
+ tb = new ToyDBTraceBuilder(mdo.get());
breakExpression.invoke(Map.of(
"expression", "`(void(*)())main`",
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbStackUnwindTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbStackUnwindTest.java
index 43258e27c4..56b95db254 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbStackUnwindTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/lldb/rmi/LldbStackUnwindTest.java
@@ -15,7 +15,8 @@
*/
package agent.lldb.rmi;
-import static org.junit.Assert.*;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
import java.io.File;
import java.io.IOException;
@@ -87,7 +88,8 @@ public class LldbStackUnwindTest extends AbstractLldbTraceRmiTest {
DecompilerProvider decompilerProvider;
DecompilerPanel decompilerPanel;
- record LldbAndTrace(LldbAndConnection conn, ManagedDomainObject mdo) implements AutoCloseable {
+ record LldbAndTrace(LldbAndConnection conn, ManagedDomainObject<Trace> mdo)
+ implements AutoCloseable {
public void execute(String cmd) {
conn.execute(cmd);
}
@@ -122,10 +124,10 @@ public class LldbStackUnwindTest extends AbstractLldbTraceRmiTest {
}
@SuppressWarnings("resource")
- protected LldbAndTrace startAndSyncLldb(ManagedDomainObject mdo) throws Exception {
+ protected LldbAndTrace startAndSyncLldb(ManagedDomainObject<Trace> mdo) throws Exception {
LldbAndConnection conn = startAndConnectLldb();
try {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ tb = new ToyDBTraceBuilder(mdo.get());
return new LldbAndTrace(conn, mdo);
}
catch (Exception e) {
@@ -148,8 +150,8 @@ public class LldbStackUnwindTest extends AbstractLldbTraceRmiTest {
tool.acceptDomainFiles(dfs);
DomainFile traceDF = getDomainFile("expSpin_lldb");
- ManagedDomainObject mdo = new ManagedDomainObject(traceDF, false, false, monitor);
- resyncMappings((Trace) mdo.get());
+ ManagedDomainObject<Trace> mdo = new ManagedDomainObject<>(traceDF, Trace.class, monitor);
+ resyncMappings(mdo.get());
tool.acceptDomainFiles(new DomainFile[] { traceDF });
programs = openPrograms(dfs);
@@ -178,8 +180,8 @@ public class LldbStackUnwindTest extends AbstractLldbTraceRmiTest {
tool.acceptDomainFiles(dfs);
DomainFile traceDF = getDomainFile("expSpin_lldb");
- ManagedDomainObject mdo = new ManagedDomainObject(traceDF, false, false, monitor);
- resyncMappings((Trace) mdo.get());
+ ManagedDomainObject<Trace> mdo = new ManagedDomainObject<>(traceDF, Trace.class, monitor);
+ resyncMappings(mdo.get());
tool.acceptDomainFiles(new DomainFile[] { traceDF });
programs = openPrograms(dfs);
@@ -210,8 +212,8 @@ public class LldbStackUnwindTest extends AbstractLldbTraceRmiTest {
tool.acceptDomainFiles(dfs);
DomainFile traceDF = getDomainFile("expSpin_lldb");
- ManagedDomainObject mdo = new ManagedDomainObject(traceDF, false, false, monitor);
- resyncMappings((Trace) mdo.get());
+ ManagedDomainObject<Trace> mdo = new ManagedDomainObject<>(traceDF, Trace.class, monitor);
+ resyncMappings(mdo.get());
tool.acceptDomainFiles(new DomainFile[] { traceDF });
programs = openPrograms(dfs);
@@ -242,8 +244,8 @@ public class LldbStackUnwindTest extends AbstractLldbTraceRmiTest {
tool.acceptDomainFiles(dfs);
DomainFile traceDF = getDomainFile("expSpin_lldb");
- ManagedDomainObject mdo = new ManagedDomainObject(traceDF, false, false, monitor);
- resyncMappings((Trace) mdo.get());
+ ManagedDomainObject<Trace> mdo = new ManagedDomainObject<>(traceDF, Trace.class, monitor);
+ resyncMappings(mdo.get());
tool.acceptDomainFiles(new DomainFile[] { traceDF });
programs = openPrograms(dfs);
@@ -271,8 +273,8 @@ public class LldbStackUnwindTest extends AbstractLldbTraceRmiTest {
tool.acceptDomainFiles(dfs);
DomainFile traceDF = getDomainFile("expSpin_lldb");
- ManagedDomainObject mdo = new ManagedDomainObject(traceDF, false, false, monitor);
- resyncMappings((Trace) mdo.get());
+ ManagedDomainObject<Trace> mdo = new ManagedDomainObject<>(traceDF, Trace.class, monitor);
+ resyncMappings(mdo.get());
tool.acceptDomainFiles(new DomainFile[] { traceDF });
programs = openPrograms(dfs);
@@ -300,8 +302,8 @@ public class LldbStackUnwindTest extends AbstractLldbTraceRmiTest {
tool.acceptDomainFiles(dfs);
DomainFile traceDF = getDomainFile("expSpin_lldb");
- ManagedDomainObject mdo = new ManagedDomainObject(traceDF, false, false, monitor);
- resyncMappings((Trace) mdo.get());
+ ManagedDomainObject<Trace> mdo = new ManagedDomainObject<>(traceDF, Trace.class, monitor);
+ resyncMappings(mdo.get());
tool.acceptDomainFiles(new DomainFile[] { traceDF });
programs = openPrograms(dfs);
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/AbstractX64dbgTraceRmiTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/AbstractX64dbgTraceRmiTest.java
index abd1cda957..0caa1e52e9 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/AbstractX64dbgTraceRmiTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/AbstractX64dbgTraceRmiTest.java
@@ -16,7 +16,7 @@
package agent.x64dbg.rmi;
import static org.junit.Assert.*;
-import static org.junit.Assume.*;
+import static org.junit.Assume.assumeTrue;
import java.io.*;
import java.net.*;
@@ -44,6 +44,7 @@ import ghidra.program.model.address.Address;
import ghidra.program.model.address.AddressRangeImpl;
import ghidra.pty.testutil.DummyProc;
import ghidra.trace.model.Lifespan;
+import ghidra.trace.model.Trace;
import ghidra.trace.model.target.TraceObject;
import ghidra.trace.model.target.TraceObjectValue;
import ghidra.util.*;
@@ -468,19 +469,19 @@ public abstract class AbstractX64dbgTraceRmiTest extends AbstractGhidraHeadedDeb
return new RegDump();
}
- protected ManagedDomainObject openDomainObject(String path) throws Exception {
+ protected ManagedDomainObject<Trace> openTrace(String path) throws Exception {
DomainFile df = env.getProject().getProjectData().getFile(path);
assertNotNull(df);
- return new ManagedDomainObject(df, false, false, monitor);
+ return new ManagedDomainObject<>(df, Trace.class, monitor);
}
- protected ManagedDomainObject waitDomainObject(String path) throws Exception {
+ protected ManagedDomainObject<Trace> waitTrace(String path) throws Exception {
DomainFile df;
long start = System.currentTimeMillis();
while (true) {
df = env.getProject().getProjectData().getFile(path);
if (df != null) {
- return new ManagedDomainObject(df, false, false, monitor);
+ return new ManagedDomainObject<>(df, Trace.class, monitor);
}
Thread.sleep(1000);
if (System.currentTimeMillis() - start > 30000) {
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/X64dbgCommandsTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/X64dbgCommandsTest.java
index 11101eb710..9131731858 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/X64dbgCommandsTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/X64dbgCommandsTest.java
@@ -15,6 +15,7 @@
*/
package agent.x64dbg.rmi;
+import static org.hamcrest.MatcherAssert.assertThat;
import static org.hamcrest.Matchers.*;
import static org.junit.Assert.*;
@@ -111,8 +112,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("x86:LE:64:default",
tb.trace.getBaseLanguage().getLanguageID().getIdAsString());
assertEquals("windows",
@@ -129,7 +130,7 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/noname")) {
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/noname")) {
assertThat(mdo.get(), instanceOf(Trace.class));
}
}
@@ -150,8 +151,9 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
.formatted(PREAMBLE, addr, NOTEPAD));
DomainFile dfMyToy = env.getProject().getProjectData().getFile("/New Traces/x64dbg/myToy");
assertNotNull(dfMyToy);
- try (ManagedDomainObject mdo = new ManagedDomainObject(dfMyToy, false, false, monitor)) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo =
+ new ManagedDomainObject<>(dfMyToy, Trace.class, monitor)) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("Toy:BE:64:default",
tb.trace.getBaseLanguage().getLanguageID().getIdAsString());
assertEquals("default",
@@ -280,8 +282,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals(0, tb.trace.getTimeManager().getAllSnapshots().size());
}
@@ -296,8 +298,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals(1, tb.trace.getTimeManager().getAllSnapshots().size());
}
}
@@ -314,8 +316,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceSnapshot snapshot = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots());
assertEquals(0, snapshot.getKey());
assertEquals("Scripted snapshot", snapshot.getDescription());
@@ -343,8 +345,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
traceManager.openTrace(tb.trace);
traceManager.activateTrace(tb.trace);
@@ -379,8 +381,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
String eval = extractOutSection(out, "---Start---");
@@ -414,8 +416,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
String pc = extractOutSection(out, "---PC---");
@@ -448,8 +450,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD, count));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
List<TraceObjectValue> regVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
@@ -486,8 +488,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
quit()
""".formatted(PREAMBLE, addr, NOTEPAD, count));
// The spaces will be left over, but the values should be zeroed
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
long snap = Unique.assertOne(tb.trace.getTimeManager().getAllSnapshots()).getKey();
List<TraceObjectValue> regVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
@@ -518,8 +520,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -544,8 +546,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -572,8 +574,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -599,8 +601,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD, extra, x64dbgExpr, gtype));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -754,8 +756,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -786,8 +788,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject object = tb.trace.getObjectManager()
.getObjectByCanonicalPath(KeyPath.parse("Test.Objects[1]"));
assertNotNull(object);
@@ -834,8 +836,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("""
Parent Key Span Value Type
Test.Objects[1] vaddr [0,+inf) ram:deadbeef ADDRESS
@@ -875,8 +877,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("""
Parent Key Span Value Type
Test.Objects[1] vaddr [0,+inf) ram:deadbeef ADDRESS""",
@@ -900,7 +902,7 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
assertSame(mdo.get(), traceManager.getCurrentTrace());
assertEquals("Test.Objects[1]",
traceManager.getCurrentObject().getCanonicalPath().toString());
@@ -924,8 +926,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Not concerned about specifics, so long as disassembly occurs
long total = 0;
for (CodeUnit cu : tb.trace.getCodeManager().definedUnits().get(0, true)) {
@@ -950,8 +952,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<TraceObject> processes = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0), PathFilter.parse("Processes[]"))
@@ -973,8 +975,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<TraceObject> available = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0), PathFilter.parse("Sessions[].Available[]"))
@@ -1004,8 +1006,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
quit()
"""
.formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
List<TraceObjectValue> procSBreakLocVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
PathFilter.parse("Sessions[].Processes[].Debug.Software Breakpoints[]"))
@@ -1049,8 +1051,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
quit()
"""
.formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
List<TraceObjectValue> procBreakVals = tb.trace.getObjectManager()
.getValuePaths(Lifespan.at(0),
PathFilter.parse("Sessions[].Processes[].Debug.Hardware Breakpoints[]"))
@@ -1087,8 +1089,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Assumes LLDB on Linux amd64
TraceObject env =
Objects.requireNonNull(
@@ -1113,8 +1115,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<? extends TraceMemoryRegion> all =
tb.trace.getMemoryManager().getAllRegions();
@@ -1135,8 +1137,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<? extends TraceModule> all = tb.trace.getModuleManager().getAllModules();
TraceModule modBash =
@@ -1158,8 +1160,8 @@ public class X64dbgCommandsTest extends AbstractX64dbgTraceRmiTest {
util.terminate_session()
quit()
""".formatted(PREAMBLE, addr, NOTEPAD));
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
// Would be nice to control / validate the specifics
Collection<? extends TraceThread> threads = tb.trace.getThreadManager().getAllThreads();
assertThat(threads.size(), greaterThan(2));
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/X64dbgHooksTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/X64dbgHooksTest.java
index 043700ee18..a4fd1e372d 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/X64dbgHooksTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/X64dbgHooksTest.java
@@ -15,8 +15,11 @@
*/
package agent.x64dbg.rmi;
-import static org.hamcrest.Matchers.*;
-import static org.junit.Assert.*;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
import java.util.*;
@@ -37,7 +40,7 @@ public class X64dbgHooksTest extends AbstractX64dbgTraceRmiTest {
private static final long RUN_TIMEOUT_MS = 5000;
private static final long RETRY_MS = 500;
- record PythonAndTrace(PythonAndConnection conn, ManagedDomainObject mdo)
+ record PythonAndTrace(PythonAndConnection conn, ManagedDomainObject<Trace> mdo)
implements AutoCloseable {
public void execute(String cmd) {
conn.execute(cmd);
@@ -70,21 +73,20 @@ public class X64dbgHooksTest extends AbstractX64dbgTraceRmiTest {
protected PythonAndTrace startAndSyncPython(String exec) throws Exception {
PythonAndConnection conn = startAndConnectPython();
try {
- ManagedDomainObject mdo;
+ ManagedDomainObject<Trace> mdo;
conn.execute("from ghidraxdbg.commands import *");
conn.execute(
"util.set_convenience_variable('ghidra-language', 'x86:LE:64:default')");
if (exec != null) {
start(conn, exec);
- mdo = waitDomainObject(
- "/New Traces/x64dbg/" + exec.substring(exec.lastIndexOf("\\") + 1));
+ mdo = waitTrace("/New Traces/x64dbg/" + exec.substring(exec.lastIndexOf("\\") + 1));
}
else {
conn.execute("ghidra_trace_start()");
- mdo = waitDomainObject("/New Traces/x64dbg/noname");
+ mdo = waitTrace("/New Traces/x64dbg/noname");
}
clearBreakpoints(conn);
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ tb = new ToyDBTraceBuilder(mdo.get());
return new PythonAndTrace(conn, mdo);
}
catch (Exception e) {
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/X64dbgMethodsTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/X64dbgMethodsTest.java
index 1126812ded..284a7295c0 100644
--- a/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/X64dbgMethodsTest.java
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test.slow/java/agent/x64dbg/rmi/X64dbgMethodsTest.java
@@ -15,8 +15,11 @@
*/
package agent.x64dbg.rmi;
-import static org.hamcrest.Matchers.*;
-import static org.junit.Assert.*;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.containsString;
+import static org.hamcrest.Matchers.greaterThan;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotEquals;
import java.util.*;
@@ -48,8 +51,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
start(conn, null);
RemoteMethod evaluate = conn.getMethod("evaluate");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
assertEquals("11",
evaluate.invoke(Map.ofEntries(
Map.entry("session", tb.obj("Sessions[0]")),
@@ -77,7 +80,7 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
conn.execute("ghidra_trace_kill()");
conn.execute("util.terminate_session()");
}
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
// Just confirm it's present
}
}
@@ -91,8 +94,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
RemoteMethod refreshAvailable = conn.getMethod("refresh_available");
conn.execute("util.terminate_session()");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject available = Objects.requireNonNull(tb.objAny0("Sessions[].Available"));
refreshAvailable.invoke(Map.of("node", available));
@@ -114,8 +117,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod refreshBreakpoints = conn.getMethod("refresh_breakpoints");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
conn.execute("pc = util.get_pc()");
clearBreakpoints(conn);
@@ -163,8 +166,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "all");
RemoteMethod refreshProcWatchpoints = conn.getMethod("refresh_breakpoints");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
conn.execute("pc = util.get_pc()");
clearBreakpoints(conn);
@@ -214,8 +217,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txCreate(conn, "Sessions[0].Processes");
RemoteMethod refreshProcesses = conn.getMethod("refresh_processes");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject processes = Objects.requireNonNull(tb.objAny0("Sessions[].Processes"));
refreshProcesses.invoke(Map.of("node", processes));
@@ -238,8 +241,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "all");
RemoteMethod refreshEnvironment = conn.getMethod("refresh_environment");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject env =
Objects.requireNonNull(tb.objAny0("Sessions[].Processes[].Environment"));
@@ -262,8 +265,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod refreshThreads = conn.getMethod("refresh_threads");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = tb.objAny0("Sessions[].Processes[]");
TraceObject threads = fakeEmpty(proc, "Threads");
@@ -287,8 +290,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
conn.execute("ghidra_trace_txcommit()");
RemoteMethod refreshRegisters = conn.getMethod("refresh_registers");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
conn.execute("util.dbg.cmd('rax=0xdeadbeef')");
@@ -313,8 +316,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod refreshMappings = conn.getMethod("refresh_mappings");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = tb.objAny0("Sessions[].Processes[]");
TraceObject memory = fakeEmpty(proc, "Memory");
@@ -346,8 +349,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod refreshModules = conn.getMethod("refresh_modules");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = tb.objAny0("Sessions[].Processes[]");
TraceObject modules = fakeEmpty(proc, "Modules");
@@ -370,8 +373,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod activateThread = conn.getMethod("activate_thread");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "threads");
@@ -401,8 +404,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod removeProcess = conn.getMethod("remove_process");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/NETSTAT.EXE")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/NETSTAT.EXE")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc2 = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
removeProcess.invoke(Map.of("process", proc2));
@@ -423,8 +426,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "available");
RemoteMethod attachObj = conn.getMethod("attach_obj");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject target = Objects.requireNonNull(tb.obj(
"Sessions[0].Available[%d]".formatted(dproc.pid)));
attachObj.invoke(Map.ofEntries(
@@ -447,8 +450,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "available");
RemoteMethod attachPid = conn.getMethod("attach_pid");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
Objects.requireNonNull(tb.obj(
"Sessions[0].Available[%d]".formatted(dproc.pid)));
try {
@@ -476,8 +479,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod detach = conn.getMethod("detach");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/NETSTAT.EXE")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/NETSTAT.EXE")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
detach.invoke(Map.of("process", proc));
@@ -497,8 +500,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod launch = conn.getMethod("launch");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/noname")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/noname")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
launch.invoke(Map.ofEntries(
Map.entry("Session", tb.obj("Sessions[0]")),
@@ -523,8 +526,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod kill = conn.getMethod("kill");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
kill.invoke(Map.of("process", proc));
@@ -547,8 +550,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
RemoteMethod go = conn.getMethod("go");
RemoteMethod interrupt = conn.getMethod("interrupt");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
@@ -573,8 +576,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod stepInto = conn.getMethod("step_into");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "threads");
TraceObject thread =
@@ -609,8 +612,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod stepOver = conn.getMethod("step_over");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "threads");
TraceObject thread =
@@ -641,8 +644,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
RemoteMethod stepInto = conn.getMethod("step_into");
RemoteMethod stepOut = conn.getMethod("step_out");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
txPut(conn, "threads");
TraceObject thread =
@@ -673,8 +676,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakAddress = conn.getMethod("break_address");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
clearBreakpoints(conn);
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
@@ -699,8 +702,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExpression = conn.getMethod("break_expression");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
clearBreakpoints(conn);
breakExpression.invoke(Map.of("expression", "CreateFileW"));
@@ -723,8 +726,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakAddress = conn.getMethod("break_hw_address");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
@@ -750,8 +753,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExpression = conn.getMethod("break_hw_expression");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
clearBreakpoints(conn);
breakExpression.invoke(Map.of("expression", "CreateFileW"));
@@ -774,8 +777,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakAddr = conn.getMethod("break_read_address");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
clearBreakpoints(conn);
@@ -803,8 +806,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExpression = conn.getMethod("break_read_expression");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
clearBreakpoints(conn);
breakExpression.invoke(Map.of("expression", "CreateFileW"));
@@ -830,8 +833,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakAddr = conn.getMethod("break_write_address");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
clearBreakpoints(conn);
@@ -859,8 +862,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExpression = conn.getMethod("break_write_expression");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
clearBreakpoints(conn);
@@ -887,8 +890,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakAddr = conn.getMethod("break_access_address");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
clearBreakpoints(conn);
TraceObject proc = Objects.requireNonNull(tb.objAny0("Sessions[].Processes[]"));
@@ -915,8 +918,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
txPut(conn, "processes");
RemoteMethod breakExpression = conn.getMethod("break_access_expression");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
clearBreakpoints(conn);
breakExpression.invoke(Map.of("expression", "CreateFileW"));
@@ -943,8 +946,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
RemoteMethod breakAddress = conn.getMethod("break_address");
RemoteMethod toggleBreakpoint = conn.getMethod("toggle_breakpoint");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
clearBreakpoints(conn);
@@ -977,8 +980,8 @@ public class X64dbgMethodsTest extends AbstractX64dbgTraceRmiTest {
RemoteMethod breakAddress = conn.getMethod("break_address");
RemoteMethod deleteBreakpoint = conn.getMethod("delete_breakpoint");
- try (ManagedDomainObject mdo = openDomainObject("/New Traces/x64dbg/notepad.exe")) {
- tb = new ToyDBTraceBuilder((Trace) mdo.get());
+ try (ManagedDomainObject<Trace> mdo = openTrace("/New Traces/x64dbg/notepad.exe")) {
+ tb = new ToyDBTraceBuilder(mdo.get());
clearBreakpoints(conn);
diff --git a/Ghidra/Test/DebuggerIntegrationTest/src/test/java/ghidra/app/plugin/core/debug/gui/emulation/DebuggerEmulateFunctionDialogTest.java b/Ghidra/Test/DebuggerIntegrationTest/src/test/java/ghidra/app/plugin/core/debug/gui/emulation/DebuggerEmulateFunctionDialogTest.java
new file mode 100644
index 0000000000..269b4d203d
--- /dev/null
+++ b/Ghidra/Test/DebuggerIntegrationTest/src/test/java/ghidra/app/plugin/core/debug/gui/emulation/DebuggerEmulateFunctionDialogTest.java
@@ -0,0 +1,553 @@
+/* ###
+ * 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.app.plugin.core.debug.gui.emulation;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.Assert.*;
+import static org.junit.Assume.assumeFalse;
+
+import java.lang.annotation.*;
+import java.lang.reflect.Method;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.util.*;
+
+import javax.swing.JDialog;
+import javax.swing.JTextField;
+import javax.swing.tree.TreePath;
+
+import org.hamcrest.Matchers;
+import org.junit.*;
+
+import db.Transaction;
+import docking.ActionContext;
+import docking.action.DockingActionIf;
+import docking.widgets.table.EnumeratedColumnTableModel;
+import generic.Unique;
+import generic.test.ConcurrentTestExceptionHandler;
+import ghidra.app.plugin.assembler.Assembler;
+import ghidra.app.plugin.assembler.Assemblers;
+import ghidra.app.plugin.core.codebrowser.CodeBrowserPlugin;
+import ghidra.app.plugin.core.datamgr.DataTypeManagerPlugin;
+import ghidra.app.plugin.core.datamgr.util.DataTypeChooserDialog;
+import ghidra.app.plugin.core.datamgr.util.DataTypeChooserDialogTestHelper;
+import ghidra.app.plugin.core.debug.gui.AbstractGhidraHeadedDebuggerIntegrationTest;
+import ghidra.app.plugin.core.debug.gui.breakpoint.DebuggerBreakpointMarkerPlugin;
+import ghidra.app.plugin.core.debug.gui.breakpoint.DebuggerBreakpointsPlugin;
+import ghidra.app.plugin.core.debug.gui.emulation.FunctionEmulationHarness.ReturnAddressInfo;
+import ghidra.app.plugin.core.debug.gui.listing.DebuggerListingPlugin;
+import ghidra.app.plugin.core.debug.gui.register.DebuggerRegistersPlugin;
+import ghidra.app.plugin.core.debug.gui.time.DebuggerTimePlugin;
+import ghidra.app.plugin.core.debug.service.breakpoint.ProgramBreakpoint;
+import ghidra.app.plugin.core.function.FunctionPlugin;
+import ghidra.app.plugin.core.script.GhidraScriptMgrPlugin;
+import ghidra.app.plugin.processors.sleigh.SleighLanguage;
+import ghidra.debug.api.breakpoint.LogicalBreakpoint;
+import ghidra.pcode.exec.BytesPcodeArithmetic;
+import ghidra.pcode.exec.PcodeArithmetic;
+import ghidra.pcode.exec.PcodeArithmetic.Purpose;
+import ghidra.program.model.address.*;
+import ghidra.program.model.data.*;
+import ghidra.program.model.lang.Register;
+import ghidra.program.model.listing.*;
+import ghidra.program.model.listing.Function.FunctionUpdateType;
+import ghidra.program.model.symbol.SourceType;
+import ghidra.trace.database.ToyDBTraceBuilder;
+import ghidra.util.task.TaskMonitorComponent;
+import utility.function.ExceptionalCallback;
+
+public class DebuggerEmulateFunctionDialogTest extends AbstractGhidraHeadedDebuggerIntegrationTest {
+ final static List<String> DEFAULT_ASM = List.of(
+ "load r10, [r12]",
+ "imm r9, #8",
+ "add r12, r9",
+ "load r12, [r12]",
+ "add r12, r10",
+ "add r12, r11",
+ "ret");
+
+ PcodeArithmetic<byte[]> ba;
+ Function function;
+ DataType dtLongLong;
+ Pointer dtStructPtr;
+ DebuggerEmulateFunctionDialog dialog;
+ Address addressOfLoad; // Address of *last* load instruction
+ SleighLanguage language;
+ DataTypeManager dtm;
+
+ @Target(ElementType.METHOD)
+ @Retention(RetentionPolicy.RUNTIME)
+ @interface AltAsm {
+ String[] value();
+ }
+
+ @SuppressWarnings("unchecked")
+ <T extends DataType> T resolve(T dt) {
+ try (Transaction tx = program.openTransaction("Resolved %s".formatted(dt))) {
+ DataTypeConflictHandler handler = DataTypeConflictHandler.DEFAULT_HANDLER;
+ return (T) dtm.resolve(dt, handler);
+ }
+ }
+
+ String[] getAsm() throws Exception {
+ Method method = null;
+ try {
+ method = getClass().getMethod(name.getMethodName());
+ }
+ catch (NoSuchMethodException e) {
+ return DEFAULT_ASM.toArray(String[]::new);
+ }
+ AltAsm annotation = method.getAnnotation(AltAsm.class);
+ if (annotation == null) {
+ return DEFAULT_ASM.toArray(String[]::new);
+ }
+ return annotation.value();
+ }
+
+ @Before
+ public void setupEmulateFunctionTest() throws Exception {
+ createProgram();
+ language = (SleighLanguage) program.getLanguage();
+ dtm = program.getDataTypeManager();
+ intoProject(program);
+ ba = BytesPcodeArithmetic.forLanguage(program.getLanguage());
+ try (Transaction tx = program.openTransaction("Create function")) {
+ Address entry = addr(program, 0x00400000);
+
+ program.getMemory()
+ .createInitializedBlock(".text", entry, 0x1000, (byte) 0, monitor, false);
+
+ Assembler asm = Assemblers.getAssembler(program);
+ AddressSet body = new AddressSet();
+ for (Instruction i : asm.assemble(entry, getAsm())) {
+ body.add(new AddressRangeImpl(i.getMinAddress(), i.getMaxAddress()));
+ if ("load".equals(i.getMnemonicString())) {
+ addressOfLoad = i.getAddress();
+ }
+ }
+
+ function = program.getFunctionManager()
+ .createFunction("main", entry, body, SourceType.IMPORTED);
+
+ dtLongLong = resolve(LongLongDataType.dataType);
+
+ Structure st = new StructureDataType("myStruct", 0, dtm);
+ st.add(dtLongLong, "first", "");
+ st.add(dtLongLong, "second", "");
+ dtStructPtr = resolve(new PointerDataType(st));
+
+ Variable returnVar = new ReturnParameterImpl(dtLongLong, program);
+ Variable param1 = new ParameterImpl("param1", dtStructPtr, program);
+ Variable param2 = new ParameterImpl("param2", dtLongLong, program);
+
+ function.updateFunction("default", returnVar, List.of(param1, param2),
+ FunctionUpdateType.DYNAMIC_STORAGE_ALL_PARAMS, false, SourceType.ANALYSIS);
+ }
+
+ programManager.openProgram(program);
+
+ dialog = runSwing(() -> new DebuggerEmulateFunctionDialog(tool, function));
+
+ runSwing(() -> tool.showDialog(dialog));
+ }
+
+ @After
+ public void tearDownEmulateFunctionTest() {
+ runSwing(() -> dialog.close());
+ }
+
+ //@Test
+ public void testManual() throws Exception {
+ assumeFalse(BATCH_MODE);
+ ConcurrentTestExceptionHandler.disable();
+
+ addPlugin(tool, DataTypeManagerPlugin.class);
+ addPlugin(tool, CodeBrowserPlugin.class);
+ addPlugin(tool, FunctionPlugin.class);
+ addPlugin(tool, DebuggerListingPlugin.class);
+ addPlugin(tool, DebuggerTimePlugin.class);
+ addPlugin(tool, DebuggerRegistersPlugin.class);
+ addPlugin(tool, DebuggerBreakpointsPlugin.class);
+ addPlugin(tool, DebuggerBreakpointMarkerPlugin.class);
+ addPlugin(tool, GhidraScriptMgrPlugin.class);
+ waitForSwing();
+
+ while (runSwing(() -> dialog.isShowing())) {
+ Thread.sleep(1000);
+ }
+ }
+
+ record NameType(String name, DataType type) implements Comparable<NameType> {
+ public static final Comparator<NameType> NATURAL_ORDER =
+ Comparator.comparing(NameType::name);
+
+ static NameType extract(VarRow row) {
+ return new NameType(row.getName(), row.getType());
+ }
+
+ static List<NameType> extract(EnumeratedColumnTableModel<? extends VarRow> model) {
+ return model.getModelData().stream().map(NameType::extract).sorted().toList();
+ }
+
+ @Override
+ public int compareTo(NameType o) {
+ return NATURAL_ORDER.compare(this, o);
+ }
+ }
+
+ InputRow findInput(String name) {
+ return runSwing(() -> dialog.findRow(dialog.inputsTableModel, name)).orElseThrow();
+ }
+
+ OutputRow findOutput(String name) {
+ return runSwing(() -> dialog.findRow(dialog.outputsTableModel, name)).orElseThrow();
+ }
+
+ void performInputAction(String name, boolean wait) {
+ ActionContext ctx = runSwing(() -> dialog.inputActions.getActionContext(null));
+ performAction(dialog.inputActions.byName(name), ctx, wait);
+ }
+
+ void performOutputAction(String name, boolean wait) {
+ ActionContext ctx = runSwing(() -> dialog.outputActions.getActionContext(null));
+ performAction(dialog.outputActions.byName(name), ctx, wait);
+ }
+
+ @Test
+ public void testRetInRegister() throws Exception {
+ try (FunctionEmulationHarness harness =
+ FunctionEmulationHarness.start(tool, function, monitor)) {
+ ReturnAddressInfo retInfo = harness.locateReturnAddress();
+ Register lr = harness.language.getRegister("lr");
+ assertEquals(lr.getAddress(), retInfo.location());
+ assertEquals(lr.getAddress(), retInfo.computePhysicalLocation(harness.initEval,
+ harness.program.getCompilerSpec()));
+ }
+ }
+
+ @Test
+ @AltAsm({
+ "pop lr",
+ "ret" })
+ public void testRetOnStack() throws Exception {
+ try (FunctionEmulationHarness harness =
+ FunctionEmulationHarness.start(tool, function, monitor)) {
+ ReturnAddressInfo retInfo = harness.locateReturnAddress();
+ AddressSpace stack = harness.program.getAddressFactory().getStackSpace();
+ AddressSpace data = harness.language.getDefaultDataSpace();
+ assertEquals(stack.getAddress(8), retInfo.location());
+ assertEquals(data.getAddress(0x00005008), retInfo
+ .computePhysicalLocation(harness.initEval, harness.program.getCompilerSpec()));
+ }
+ }
+
+ @Test
+ public void testDefaultVars() throws Exception {
+ assertEquals(
+ List.of(
+ new NameType("param1", dtStructPtr),
+ new NameType("param2", dtLongLong)),
+ NameType.extract(dialog.inputsTableModel));
+ assertEquals(
+ List.of(
+ new NameType("<RETURN>", dtLongLong)),
+ NameType.extract(dialog.outputsTableModel));
+ }
+
+ @Test
+ public void testRefreshParameters() throws Exception {
+ InputRow param1 = findInput("param1");
+ assertEquals(dtStructPtr, param1.getType());
+
+ try (Transaction tx = program.openTransaction("Modify param1")) {
+ Parameter p1 = function.getParameter(0);
+ assertEquals("param1", p1.getName());
+ p1.setDataType(dtLongLong, SourceType.USER_DEFINED);
+ }
+ waitForDomainObject(program);
+ performInputAction("Refresh Parameter Inputs", true);
+
+ param1 = findInput("param1");
+ assertEquals(dtLongLong, param1.getType());
+ }
+
+ @Test
+ public void testRefreshReturn() throws Exception {
+ OutputRow ret = findOutput("<RETURN>");
+ assertEquals(dtLongLong, ret.getType());
+
+ try (Transaction tx = program.openTransaction("Modify return")) {
+ function.getReturn().setDataType(dtStructPtr, SourceType.USER_DEFINED);
+ }
+ waitForDomainObject(program);
+ performOutputAction("Refresh Return Outputs", true);
+
+ ret = findOutput("<RETURN>");
+ assertEquals(dtStructPtr, ret.getType());
+ }
+
+ <T extends Throwable> void expecting(Class<?> cls, ExceptionalCallback<T> cb) throws T {
+ try {
+ cb.call();
+ fail("Did not get expected exception %s".formatted(cls.getSimpleName()));
+ }
+ catch (Throwable e) {
+ if (cls.isInstance(e)) {
+ return;
+ }
+ throw e;
+ }
+ }
+
+ static final String RETURN = "<RETURN>";
+
+ @Test
+ public void testRefreshVoidReturn() throws Exception {
+ findOutput(RETURN);
+
+ try (Transaction tx = program.openTransaction("Modify return")) {
+ function.getReturn().setDataType(VoidDataType.dataType, SourceType.USER_DEFINED);
+ }
+ waitForDomainObject(program);
+ performOutputAction("Refresh Return Outputs", true);
+
+ expecting(NoSuchElementException.class, () -> {
+ findOutput(RETURN);
+ });
+ }
+
+ TreePath path(String... path) {
+ return new TreePath(path);
+ }
+
+ @Test
+ public void testAddVararg() throws Exception {
+ addPlugin(tool, DataTypeManagerPlugin.class);
+
+ DockingActionIf actionAddVararg = dialog.inputActions.byName("Add Vararg Input");
+ assertFalse(actionAddVararg.isEnabled());
+
+ try (Transaction tx = program.openTransaction("Enable varargs")) {
+ function.setVarArgs(true);
+ }
+ waitForDomainObject(program);
+
+ assertTrue(actionAddVararg.isEnabled());
+ performInputAction("Add Vararg Input", false);
+ DataTypeChooserDialog typeDialog = waitForDialogComponent(DataTypeChooserDialog.class);
+ waitForTasks();
+
+ typeDialog.setSelectedPath(path("Data Types", "BuiltInTypes", "float"));
+ waitForTasks();
+ DataTypeChooserDialogTestHelper.clickOk(typeDialog);
+
+ InputRow input = findInput("Vararg 3");
+ assertEquals(resolve(FloatDataType.dataType), input.getType());
+ }
+
+ @Test
+ public void testExpandStructPtr() throws Exception {
+ InputRow param1 = findInput("param1");
+ runSwing(() -> dialog.inputsFilterPanel.setSelectedItem(param1));
+ performInputAction("Allocate and Add Pointer Inputs", true);
+
+ InputRow param1First = findInput("(param1)->first");
+ assertEquals(dtLongLong, param1First.getType());
+ InputRow param1Second = findInput("(param1)->second");
+ assertEquals(dtLongLong, param1Second.getType());
+ }
+
+ @Test
+ public void testExpandSimplePtr() throws Exception {
+ InputRow param1 = findInput("param1");
+ DataType dtLongLongPtr = resolve(new PointerDataType(dtLongLong));
+ param1.setType(dtLongLongPtr);
+ runSwing(() -> dialog.inputsFilterPanel.setSelectedItem(param1));
+ performInputAction("Allocate and Add Pointer Inputs", true);
+
+ InputRow param1Deref = findInput("*(param1)");
+ assertEquals(dtLongLong, param1Deref.getType());
+ }
+
+ void placeInject(Address address, String inject) {
+ try (Transaction tx = program.openTransaction("Place inject")) {
+ Bookmark bm = program.getBookmarkManager()
+ .setBookmark(address, LogicalBreakpoint.ENABLED_BOOKMARK_TYPE, "x;1", "");
+ ProgramBreakpoint brk = ProgramBreakpoint.fromBookmark(program, bm);
+ brk.setEmuSleigh(inject);
+ }
+ waitForDomainObject(program);
+ }
+
+ @Test
+ public void testFullUse() throws Exception {
+ InputRow param1 = findInput("param1");
+ runSwing(() -> dialog.inputsFilterPanel.setSelectedItem(param1));
+ performInputAction("Allocate and Add Pointer Inputs", true);
+
+ InputRow param1First = findInput("(param1)->first");
+ param1First.setValue(ba.fromConst(6, param1First.length));
+ InputRow param1Second = findInput("(param1)->second");
+ param1Second.setRepr("7h");
+ InputRow param2 = findInput("param2");
+ param2.setRepr("8h");
+
+ placeInject(addressOfLoad, """
+ emu_probe(r12);
+ emu_exec_decoded();
+ """);
+
+ runSwing(() -> dialog.okCallback());
+ waitForTasks();
+
+ OutputRow ret = findOutput("<RETURN>");
+ assertEquals("15h", ret.getRepr());
+ OutputRow probe = findOutput("Probe 1");
+ assertEquals(0x7beef008L, ba.toLong(probe.value, Purpose.INSPECT));
+ }
+
+ @Test
+ public void testAddCustom() throws Exception {
+ performInputAction("Add Custom Input", false);
+ JDialog exprDialog = waitForJDialog("Add Custom Input");
+ JTextField exprField = findComponent(exprDialog, JTextField.class);
+ exprField.setText("r10");
+ runSwing(() -> findButtonByText(exprDialog, "OK").doClick());
+
+ assertNotNull(findInput("Custom 1"));
+ }
+
+ @Test
+ public void testConflictingInputs() throws Exception {
+ InputRow custom1 =
+ new InputRow(language, "Custom 1", VarStorage.fromExpression(language, "r12"), null);
+ dialog.inputsTableModel.add(custom1);
+ InputRow param1 = findInput("param1");
+ assertEquals(custom1.storage, param1.storage);
+
+ custom1.setValueStr("0x1");
+ param1.setValueStr("0x7");
+
+ runSwing(() -> dialog.okCallback());
+ waitForTasks();
+ String status = runSwing(() -> dialog.getStatusText());
+ assertThat(status,
+ Matchers.either(Matchers.equalTo("Input r12 conflicts: 0x1 != 0x7"))
+ .or(Matchers.equalTo("Input r12 conflicts: 0x7 != 0x1")));
+ }
+
+ @Test
+ public void testRemovedDependencyNotApplied() throws Exception {
+ InputRow param1 = findInput("param1");
+ runSwing(() -> dialog.inputsFilterPanel.setSelectedItem(param1));
+ performInputAction("Allocate and Add Pointer Inputs", true);
+
+ InputRow param1First = findInput("(param1)->first");
+ param1First.setValue(ba.fromConst(6, param1First.length));
+ InputRow param1Second = findInput("(param1)->second");
+ param1Second.setRepr("7h");
+ InputRow param2 = findInput("param2");
+ param2.setRepr("8h");
+
+ // Not zeros. Should be alloced address
+ assertFalse(Arrays.equals(new byte[param1.length], param1.getValue()));
+
+ runSwing(() -> dialog.inputsFilterPanel.setSelectedItem(param1));
+ performInputAction("Remove Input", true);
+
+ runSwing(() -> dialog.okCallback());
+ waitForTasks();
+
+ tb = new ToyDBTraceBuilder(Unique.assertOne(traceManager.getOpenTraces()));
+ // Should wind up at zero, because param1 is not be applied
+ ByteBuffer buf = ByteBuffer.allocate(dtStructPtr.getDataType().getLength())
+ .order(language.isBigEndian() ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN);
+ tb.trace.getMemoryManager().getBytes(0, tb.addr(0), buf);
+ buf.flip();
+ assertEquals(6, buf.getLong());
+ assertEquals(7, buf.getLong());
+ }
+
+ @Test
+ public void testDependencyRefreshedStillAffectsDependents() throws Exception {
+ InputRow param1 = findInput("param1");
+ runSwing(() -> dialog.inputsFilterPanel.setSelectedItem(param1));
+ performInputAction("Allocate and Add Pointer Inputs", true);
+
+ InputRow param1First = findInput("(param1)->first");
+ param1First.setValue(ba.fromConst(6, param1First.length));
+ InputRow param1Second = findInput("(param1)->second");
+ param1Second.setRepr("7h");
+ InputRow param2 = findInput("param2");
+ param2.setRepr("8h");
+
+ runSwing(() -> dialog.inputsFilterPanel.setSelectedItem(param1));
+ performInputAction("Remove Input", true);
+ performInputAction("Refresh Parameter Inputs", true);
+ InputRow param1a = findInput("param1");
+ assertNotSame(param1, param1a);
+
+ Address newAddr = program.getAddressFactory().getAddress("00600000");
+ param1a.setValue(ba.fromConst(newAddr));
+
+ runSwing(() -> dialog.okCallback());
+ waitForTasks();
+
+ tb = new ToyDBTraceBuilder(Unique.assertOne(traceManager.getOpenTraces()));
+ // Should wind up at zero, because param1 is not be applied
+ ByteBuffer buf = ByteBuffer.allocate(dtStructPtr.getDataType().getLength())
+ .order(language.isBigEndian() ? ByteOrder.BIG_ENDIAN : ByteOrder.LITTLE_ENDIAN);
+ tb.trace.getMemoryManager().getBytes(0, newAddr, buf);
+ buf.flip();
+ assertEquals(6, buf.getLong());
+ assertEquals(7, buf.getLong());
+ }
+
+ @Test
+ public void testCancelLoop() throws Exception {
+ placeInject(addressOfLoad, """
+ goto 0x%s;
+ """.formatted(function.getEntryPoint()));
+
+ runSwing(() -> dialog.okCallback());
+
+ TaskMonitorComponent monitor =
+ waitForValue(() -> findComponent(dialog, TaskMonitorComponent.class));
+ runSwing(() -> monitor.cancel());
+ waitForTasks();
+ }
+
+ /**
+ * i.e., an expression is placed inside the probe vs. just a varnode
+ *
+ * @throws Exception because
+ */
+ @Test
+ public void testProbeUnique() throws Exception {
+ // Note: r12 should be 8 at this address
+ placeInject(addressOfLoad, """
+ emu_probe(r12 + 0x1234);
+ emu_exec_decoded();
+ """);
+
+ runSwing(() -> dialog.okCallback());
+ waitForTasks();
+
+ OutputRow probe = findOutput("Probe 1");
+ assertEquals("$Unique", probe.getStorage().toString());
+ assertEquals(0x123c, ba.toLong(probe.value, Purpose.INSPECT));
+ }
+}