^Bs?^R`FPNH<2G(
zb6>~2j(;BgjZ$dAFavNCi)N9?zMxN?dnB7!T&5bC4{iDfSgQJEWdJQ6_Vf*0AIOu;
z%&()qjU0J9qtJo?7){`;{V;~Zsgq6=%!-HP@lz7t*up!L2`J@|zcwvfJ$1*C#cl=Q
tCjCDH1^*Wy+cNtnFv0U5SlR#TPO+MDF~(;?dN^hj5s=`|=Y8+-zW~Z{i@*Q?
literal 0
HcmV?d00001
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 372c54f55f..b0850cb8aa 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
@@ -49,7 +49,7 @@
surprising. For example, disassembling some instructions and then stepping back in time will
cause that disassembly to disappear.
- Because not all memory is captured, some background coloring is used to indicate the state
+
Because not all memory is recorded, some background coloring is used to indicate the state
of attempted memory reads. Regardless of state, the most-recent contents, as recorded in the
trace, are displayed in the listing, defaulting to 00. "Stale" memory, that is ranges of memory
which have not been read at the current time, are displayed with a darker background. Where
@@ -142,33 +142,32 @@
and/or needs a version upgrade. It will attempt to open the program, allowing Ghidra to prompt
you about the situation.
- Capture Memory
+ Read Memory
This action is available when the current trace is "at the present" with a live target, and
- there is a selection of addresses in the dynamic listing. It will instruct the recorder to
- capture the contents of memory for the selected range(s). Typically, the viewable addresses are
- automatically captured — see the Auto-Read action.
+ there is a selection of addresses in the dynamic listing. It will instruct the recorder to read
+ and record the contents of memory for the selected range(s). Typically, the viewable addresses
+ are automatically read, anyway — see the Auto-Read action.
Auto-Read Memory
This action is always available on all dynamic listings. It configures whether or not the
- memory range(s) displayed in the listing are automatically captured. Like the Capture Memory
- action, capture can only occur when the current trace is "at the present" with a live target.
- It occurs when the user scrolls the listing, or when the listing is otherwise navigated to a
- new location. Note that other components may capture memory, regardless of this listing's
- configuration. For example, the recorder typically captures the page of memory pointed to by
- the program counter. In other words, this action cannot "disable all memory captures."
- The options are pluggable, but currently consist of:
+ memory range(s) displayed in the listing are automatically read and recorded. Like the Read
+ Memory action, it is only permitted when the current trace is "at the present" with a live
+ target. It occurs when the user scrolls the listing, or when the listing is otherwise navigated
+ to a new location. Note that other components may read memory, regardless of this listing's
+ configuration. For example, the recorder typically reads the page of memory pointed to by the
+ program counter. In other words, this action cannot "disable all memory reads." The
+ options are pluggable, but currently consist of:
- - Do Not Read Memory - disables automatic memory capture for this listing
- only.
+ - Do Not Read Memory - disables automatic memory reads for this listing only.
- Read Visible Memory - automatically reads stale ranges that enter this listing's
view.
- Read Visible Memory, RO Once - (default) behaves like Read Visible Memory, except it will
- neglect to capture read-only ranges that have been captured previously.
+ neglect read-only ranges that have been read previously.
Tool Options: Colors
diff --git a/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerMemoryBytesPlugin/DebuggerMemoryBytesPlugin.html b/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerMemoryBytesPlugin/DebuggerMemoryBytesPlugin.html
index 79d4a7fc04..e03884984f 100644
--- a/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerMemoryBytesPlugin/DebuggerMemoryBytesPlugin.html
+++ b/Ghidra/Debug/Debugger/src/main/help/help/topics/DebuggerMemoryBytesPlugin/DebuggerMemoryBytesPlugin.html
@@ -36,7 +36,7 @@
limitation is that you cannot use snapshots to display different points in time for the same
trace.
- Because not all memory is captured, some background coloring is used to indicate the state
+
Because not all memory is recorded, some background coloring is used to indicate the state
of attempted memory reads. Regardless of state, the most-recent contents, as recorded in the
trace, are displayed in the window, defaulting to 00. "Stale" memory, that is ranges of memory
which have not been read at the current time, are displayed with a darker background. Where
@@ -103,33 +103,32 @@
-
Capture Memory
+ Read Memory
This action is available when the current trace is "at the present" with a live target, and
- there is a selection of addresses in the memory window. It will instruct the recorder to
- capture the contents of memory for the selected range(s). Typically, the viewable addresses are
- automatically captured — see the Auto-Read action.
+ there is a selection of addresses in the memory window. It will instruct the recorder to read
+ and record the contents of memory for the selected range(s). Typically, the viewable addresses
+ are automatically read — see the Auto-Read action.
Auto-Read Memory
This action is always available on all memory windows. It configures whether or not the
- memory range(s) displayed in the window are automatically captured. Like the Capture Memory
- action, capture can only occur when the current trace is "at the present" with a live target.
- It occurs when the user scrolls the window, or when the window is otherwise navigated to a new
- location. Note that other components may capture memory, regardless of this windows's
- configuration. For example, the recorder typically captures the page of memory pointed to by
- the program counter. In other words, this action cannot "disable all memory captures."
- The options are pluggable, but currently consist of:
+ memory range(s) displayed in the window are automatically read and recorded. Like the Read
+ Memory action, it is only permitted when the current trace is "at the present" with a live
+ target. It occurs when the user scrolls the window, or when the window is otherwise navigated
+ to a new location. Note that other components may read memory, regardless of this windows's
+ configuration. For example, the recorder typically reads the page of memory pointed to by the
+ program counter. In other words, this action cannot "disable all memory reads." The
+ options are pluggable, but currently consist of:
- - Do Not Read Memory - disables automatic memory capture for this window
- only.
+ - Do Not Read Memory - disables automatic memory reads for this window only.
- Read Visible Memory - automatically reads stale ranges that enter this window's
view.
- Read Visible Memory, RO Once - (default) behaves like Read Visible Memory, except it will
- neglect to capture read-only ranges that have been captured previously.
+ neglect read-only ranges that have been read previously.
Byte Viewer Options
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/DebuggerResources.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/DebuggerResources.java
index 4c2f68e243..e7b06c2a39 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/DebuggerResources.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/DebuggerResources.java
@@ -144,8 +144,8 @@ public interface DebuggerResources {
ImageIcon ICON_AUTOREAD = ResourceManager.loadImage("images/autoread.png");
// TODO: Draw a real icon.
- ImageIcon ICON_CAPTURE_MEMORY = ICON_REGIONS;
- //ResourceManager.loadImage("images/capture-memory.png");
+ ImageIcon ICON_READ_MEMORY = ICON_REGIONS;
+ //ResourceManager.loadImage("images/read-memory.png");
// TODO: Draw an icon
ImageIcon ICON_MAP_IDENTICALLY = ResourceManager.loadImage("images/doubleArrow.png");
@@ -777,14 +777,15 @@ public interface DebuggerResources {
}
}
- abstract class AbstractCaptureSelectedMemoryAction extends DockingAction {
- public static final String NAME = "Capture Selected Memory";
- public static final Icon ICON = ICON_CAPTURE_MEMORY;
- public static final String HELP_ANCHOR = "capture_memory";
+ abstract class AbstractReadSelectedMemoryAction extends DockingAction {
+ public static final String NAME = "Read Selected Memory";
+ public static final Icon ICON = ICON_READ_MEMORY;
+ public static final String HELP_ANCHOR = "read_memory";
- public AbstractCaptureSelectedMemoryAction(Plugin owner) {
+ public AbstractReadSelectedMemoryAction(Plugin owner) {
super(NAME, owner.getName());
- setDescription("Capture memory for the selected addresses into the trace database");
+ setDescription(
+ "(Re-)read and record memory for the selected addresses into the trace database");
setHelpLocation(new HelpLocation(owner.getName(), HELP_ANCHOR));
}
}
@@ -885,7 +886,7 @@ public interface DebuggerResources {
interface AutoReadMemoryAction {
String NAME = "Auto-Read Target Memory";
- String DESCRIPTION = "Automatically capture visible memory from the live target";
+ String DESCRIPTION = "Automatically read and record visible memory from the live target";
String HELP_ANCHOR = "auto_memory";
String NAME_VIS_RO_ONCE = "Read Visible Memory, RO Once";
@@ -1081,7 +1082,43 @@ public interface DebuggerResources {
return new ActionBuilder(NAME, ownerName)
.description(DESCRIPTION)
.menuGroup(GROUP)
- .menuPath(NAME)
+ .menuPath(DebuggerPluginPackage.NAME, NAME)
+ .helpLocation(new HelpLocation(ownerName, HELP_ANCHOR));
+ }
+ }
+
+ interface CopyIntoProgramAction {
+ String NAME_PAT = "Copy Into %s Program";
+ String DESC_PAT = "Copy the current selection into %s program";
+ String GROUP = GROUP_MAINTENANCE;
+ }
+
+ interface CopyIntoCurrentProgramAction extends CopyIntoProgramAction {
+ String NAME = String.format(NAME_PAT, "Current");
+ String DESCRIPTION = String.format(DESC_PAT, "the current");
+ String HELP_ANCHOR = "copy_into_current";
+
+ static ActionBuilder builder(Plugin owner) {
+ String ownerName = owner.getName();
+ return new ActionBuilder(NAME, ownerName)
+ .description(DESCRIPTION)
+ .menuGroup(GROUP)
+ .menuPath(DebuggerPluginPackage.NAME, NAME)
+ .helpLocation(new HelpLocation(ownerName, HELP_ANCHOR));
+ }
+ }
+
+ interface CopyIntoNewProgramAction extends CopyIntoProgramAction {
+ String NAME = String.format(NAME_PAT, "New");
+ String DESCRIPTION = String.format(DESC_PAT, "a new");
+ String HELP_ANCHOR = "copy_into_new";
+
+ static ActionBuilder builder(Plugin owner) {
+ String ownerName = owner.getName();
+ return new ActionBuilder(NAME, ownerName)
+ .description(DESCRIPTION)
+ .menuGroup(GROUP)
+ .menuPath(DebuggerPluginPackage.NAME, NAME)
.helpLocation(new HelpLocation(ownerName, HELP_ANCHOR));
}
}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/DebuggerReadsMemoryTrait.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/DebuggerReadsMemoryTrait.java
index f79d67a87a..d7857f63da 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/DebuggerReadsMemoryTrait.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/DebuggerReadsMemoryTrait.java
@@ -27,7 +27,7 @@ import docking.menu.MultiStateDockingAction;
import docking.widgets.EventTrigger;
import ghidra.app.plugin.core.debug.DebuggerCoordinates;
import ghidra.app.plugin.core.debug.gui.DebuggerResources;
-import ghidra.app.plugin.core.debug.gui.DebuggerResources.AbstractCaptureSelectedMemoryAction;
+import ghidra.app.plugin.core.debug.gui.DebuggerResources.AbstractReadSelectedMemoryAction;
import ghidra.app.plugin.core.debug.gui.action.AutoReadMemorySpec.AutoReadMemorySpecConfigFieldCodec;
import ghidra.app.plugin.core.debug.utils.BackgroundUtils;
import ghidra.app.services.TraceRecorder;
@@ -49,10 +49,10 @@ public abstract class DebuggerReadsMemoryTrait {
protected static final AutoConfigState.ClassHandler CONFIG_STATE_HANDLER =
AutoConfigState.wireHandler(DebuggerReadsMemoryTrait.class, MethodHandles.lookup());
- protected class CaptureSelectedMemoryAction extends AbstractCaptureSelectedMemoryAction {
+ protected class ReadSelectedMemoryAction extends AbstractReadSelectedMemoryAction {
public static final String GROUP = DebuggerResources.GROUP_GENERAL;
- public CaptureSelectedMemoryAction() {
+ public ReadSelectedMemoryAction() {
super(plugin);
setToolBarData(new ToolBarData(ICON, GROUP));
setEnabled(false);
@@ -89,14 +89,14 @@ public abstract class DebuggerReadsMemoryTrait {
}
}
- protected class ForCaptureTraceListener extends TraceDomainObjectListener {
- public ForCaptureTraceListener() {
+ protected class ForReadsTraceListener extends TraceDomainObjectListener {
+ public ForReadsTraceListener() {
listenFor(TraceSnapshotChangeType.ADDED, this::snapshotAdded);
listenFor(TraceMemoryStateChangeType.CHANGED, this::memStateChanged);
}
private void snapshotAdded(TraceSnapshot snapshot) {
- actionCaptureSelected.updateEnabled(null);
+ actionReadSelected.updateEnabled(null);
}
private void memStateChanged(TraceAddressSnapRange range, TraceMemoryState oldIsNull,
@@ -120,7 +120,7 @@ public abstract class DebuggerReadsMemoryTrait {
@Override
public void processMemoryAccessibilityChanged(TraceRecorder recorder) {
Swing.runIfSwingOrRunLater(() -> {
- actionCaptureSelected.updateEnabled(null);
+ actionReadSelected.updateEnabled(null);
});
}
}
@@ -137,7 +137,7 @@ public abstract class DebuggerReadsMemoryTrait {
}
protected MultiStateDockingAction actionAutoRead;
- protected CaptureSelectedMemoryAction actionCaptureSelected;
+ protected ReadSelectedMemoryAction actionReadSelected;
private final AutoReadMemorySpec defaultAutoSpec =
AutoReadMemorySpec.fromConfigName(VisibleROOnceAutoReadMemorySpec.CONFIG_NAME);
@@ -149,8 +149,8 @@ public abstract class DebuggerReadsMemoryTrait {
protected final Plugin plugin;
protected final ComponentProvider provider;
- protected final ForCaptureTraceListener traceListener =
- new ForCaptureTraceListener();
+ protected final ForReadsTraceListener traceListener =
+ new ForReadsTraceListener();
protected final ForAccessRecorderListener recorderListener = new ForAccessRecorderListener();
protected final ForVisibilityListener displayListener = new ForVisibilityListener();
@@ -257,10 +257,10 @@ public abstract class DebuggerReadsMemoryTrait {
}
}
- public DockingAction installCaptureSelectedAction() {
- actionCaptureSelected = new CaptureSelectedMemoryAction();
- provider.addLocalAction(actionCaptureSelected);
- return actionCaptureSelected;
+ public DockingAction installReadSelectedAction() {
+ actionReadSelected = new ReadSelectedMemoryAction();
+ provider.addLocalAction(actionReadSelected);
+ return actionReadSelected;
}
public AddressSetDisplayListener getDisplayListener() {
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/copying/DebuggerCopyActionsPlugin.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/copying/DebuggerCopyActionsPlugin.java
new file mode 100644
index 0000000000..97053afc18
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/copying/DebuggerCopyActionsPlugin.java
@@ -0,0 +1,153 @@
+/* ###
+ * 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.copying;
+
+import docking.ActionContext;
+import docking.action.DockingAction;
+import ghidra.app.context.ProgramLocationActionContext;
+import ghidra.app.plugin.PluginCategoryNames;
+import ghidra.app.plugin.core.debug.AbstractDebuggerPlugin;
+import ghidra.app.plugin.core.debug.DebuggerPluginPackage;
+import ghidra.app.plugin.core.debug.gui.DebuggerResources.*;
+import ghidra.app.plugin.core.exporter.ExporterDialog;
+import ghidra.app.services.*;
+import ghidra.framework.plugintool.PluginInfo;
+import ghidra.framework.plugintool.PluginTool;
+import ghidra.framework.plugintool.annotation.AutoServiceConsumed;
+import ghidra.framework.plugintool.util.PluginStatus;
+import ghidra.program.util.ProgramSelection;
+import ghidra.trace.model.program.TraceProgramView;
+import ghidra.trace.model.program.TraceVariableSnapProgramView;
+
+@PluginInfo(
+ shortDescription = "Copy and export trace data",
+ description = "Provides tool actions for moving data from traces to various destinations.",
+ category = PluginCategoryNames.DEBUGGER,
+ packageName = DebuggerPluginPackage.NAME,
+ status = PluginStatus.RELEASED,
+ eventsConsumed = {},
+ eventsProduced = {},
+ servicesRequired = {
+ DebuggerStaticMappingService.class,
+ ProgramManager.class,
+ },
+ servicesProvided = {})
+public class DebuggerCopyActionsPlugin extends AbstractDebuggerPlugin {
+
+ protected static ProgramSelection getSelectionFromContext(ActionContext context) {
+ if (!(context instanceof ProgramLocationActionContext)) {
+ return null;
+ }
+ ProgramLocationActionContext ctx = (ProgramLocationActionContext) context;
+ return ctx.hasSelection() ? ctx.getSelection() : null;
+ }
+
+ protected DebuggerCopyIntoProgramDialog copyDialog = new DebuggerCopyIntoProgramDialog();
+
+ protected DockingAction actionExportView;
+ protected DockingAction actionCopyIntoCurrentProgram;
+ protected DockingAction actionCopyIntoNewProgram;
+
+ @AutoServiceConsumed
+ private ProgramManager programManager;
+ @AutoServiceConsumed
+ private DebuggerStaticMappingService mappingService;
+ @AutoServiceConsumed
+ private DebuggerModelService modelService;
+
+ public DebuggerCopyActionsPlugin(PluginTool tool) {
+ super(tool);
+
+ createActions();
+ }
+
+ protected void createActions() {
+ actionExportView = ExportTraceViewAction.builder(this)
+ .enabled(false)
+ .withContext(ProgramLocationActionContext.class)
+ .enabledWhen(this::checkTrace)
+ .onAction(this::activatedExportView)
+ .buildAndInstall(tool);
+
+ // Using programManager here depends on it calling tool.updateContext()
+ actionCopyIntoCurrentProgram = CopyIntoCurrentProgramAction.builder(this)
+ .enabled(false)
+ .withContext(ProgramLocationActionContext.class)
+ .enabledWhen(
+ ctx -> checkTraceSelection(ctx) && programManager.getCurrentProgram() != null)
+ .onAction(this::activatedCopyIntoCurrentProgram)
+ .buildAndInstall(tool);
+
+ actionCopyIntoNewProgram = CopyIntoNewProgramAction.builder(this)
+ .enabled(false)
+ .withContext(ProgramLocationActionContext.class)
+ .enabledWhen(this::checkTraceSelection)
+ .onAction(this::activatedCopyIntoNewProgram)
+ .buildAndInstall(tool);
+ }
+
+ protected boolean checkTrace(ProgramLocationActionContext context) {
+ return context.getProgram() instanceof TraceProgramView;
+ }
+
+ protected boolean checkTraceSelection(ProgramLocationActionContext context) {
+ return checkTrace(context) && context.hasSelection();
+ }
+
+ protected void activatedExportView(ProgramLocationActionContext context) {
+ if (!checkTrace(context)) {
+ return;
+ }
+ TraceProgramView view = (TraceProgramView) context.getProgram();
+ // Avoid odd race conditions by fixing the snap
+ TraceProgramView fixed = view instanceof TraceVariableSnapProgramView
+ ? view.getTrace().getFixedProgramView(view.getSnap())
+ : view;
+
+ ExporterDialog dialog =
+ new ExporterDialog(tool, fixed.getDomainFile(), fixed,
+ getSelectionFromContext(context));
+ tool.showDialog(dialog);
+ }
+
+ protected void activatedCopyIntoCurrentProgram(ProgramLocationActionContext context) {
+ if (!checkTraceSelection(context)) {
+ return;
+ }
+ copyDialog.setSource((TraceProgramView) context.getProgram(), context.getSelection());
+ copyDialog.setProgramManager(programManager);
+ copyDialog.setStaticMappingService(mappingService);
+ copyDialog.setModelService(modelService);
+ copyDialog.setDestination(programManager.getCurrentProgram());
+ copyDialog.reset();
+ copyDialog.setStatusText("");
+ tool.showDialog(copyDialog);
+ }
+
+ protected void activatedCopyIntoNewProgram(ProgramLocationActionContext context) {
+ if (!checkTraceSelection(context)) {
+ return;
+ }
+ copyDialog.setSource((TraceProgramView) context.getProgram(), context.getSelection());
+ copyDialog.setProgramManager(programManager);
+ copyDialog.setStaticMappingService(mappingService);
+ copyDialog.setModelService(modelService);
+ copyDialog.setDestination(copyDialog.NEW_PROGRAM);
+ copyDialog.reset();
+ copyDialog.setStatusText("");
+ tool.showDialog(copyDialog);
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/copying/DebuggerCopyIntoProgramDialog.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/copying/DebuggerCopyIntoProgramDialog.java
new file mode 100644
index 0000000000..7313ace853
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/copying/DebuggerCopyIntoProgramDialog.java
@@ -0,0 +1,844 @@
+/* ###
+ * 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.copying;
+
+import java.awt.*;
+import java.io.IOException;
+import java.util.*;
+import java.util.List;
+import java.util.concurrent.CompletableFuture;
+import java.util.function.*;
+import java.util.stream.Collectors;
+
+import javax.swing.*;
+import javax.swing.table.TableColumn;
+import javax.swing.table.TableColumnModel;
+
+import com.google.common.collect.Range;
+
+import docking.DialogComponentProvider;
+import docking.widgets.table.*;
+import docking.widgets.table.DefaultEnumeratedColumnTableModel.EnumeratedTableColumn;
+import ghidra.app.plugin.core.debug.DebuggerCoordinates;
+import ghidra.app.plugin.core.debug.gui.DebuggerResources;
+import ghidra.app.plugin.core.debug.gui.copying.DebuggerCopyPlan.Copier;
+import ghidra.app.services.*;
+import ghidra.app.services.DebuggerStaticMappingService.MappedAddressRange;
+import ghidra.program.database.ProgramDB;
+import ghidra.program.model.address.*;
+import ghidra.program.model.listing.Program;
+import ghidra.program.model.mem.Memory;
+import ghidra.program.model.mem.MemoryBlock;
+import ghidra.trace.model.memory.TraceMemoryManager;
+import ghidra.trace.model.memory.TraceMemoryRegion;
+import ghidra.trace.model.modules.*;
+import ghidra.trace.model.program.TraceProgramView;
+import ghidra.util.*;
+import ghidra.util.database.UndoableTransaction;
+import ghidra.util.exception.CancelledException;
+import ghidra.util.table.GhidraTableFilterPanel;
+import ghidra.util.task.*;
+
+public class DebuggerCopyIntoProgramDialog extends DialogComponentProvider {
+ static final int GAP = 5;
+ static final int BUTTON_SIZE = 32;
+
+ protected static class RangeEntry {
+ private final String regionName;
+ private final String moduleNames;
+ private final String sectionNames;
+ private final AddressRange srcRange;
+ private String blockName;
+ private final boolean create;
+ private final boolean overlay;
+ private final AddressRange dstRange;
+
+ protected RangeEntry(String regionName, String moduleNames, String sectionNames,
+ AddressRange srcRange, String blockName, boolean create, boolean overlay,
+ AddressRange dstRange) {
+ this.regionName = regionName;
+ this.moduleNames = moduleNames;
+ this.sectionNames = sectionNames;
+ this.srcRange = srcRange;
+ this.blockName = blockName;
+ this.create = create;
+ this.overlay = overlay;
+ this.dstRange = dstRange;
+ }
+
+ public String getRegionName() {
+ return regionName;
+ }
+
+ public String getModuleNames() {
+ return moduleNames;
+ }
+
+ public String getSectionNames() {
+ return sectionNames;
+ }
+
+ public AddressRange getSrcRange() {
+ return srcRange;
+ }
+
+ public Address getSrcMinAddress() {
+ return srcRange.getMinAddress();
+ }
+
+ public Address getSrcMaxAddress() {
+ return srcRange.getMaxAddress();
+ }
+
+ public AddressRange getDstRange() {
+ return dstRange;
+ }
+
+ public String getBlockName() {
+ return create ? blockName : (blockName + " *");
+ }
+
+ public void setBlockName(String blockName) {
+ if (!create) {
+ throw new IllegalStateException("Cannot modify name of existing block");
+ }
+ this.blockName = blockName;
+ }
+
+ public boolean isCreate() {
+ return create;
+ }
+
+ public boolean isOverlay() {
+ return overlay;
+ }
+
+ public Address getDstMinAddress() {
+ return dstRange.getMinAddress();
+ }
+
+ public Address getDstMaxAddress() {
+ return dstRange.getMaxAddress();
+ }
+ }
+
+ protected enum RangeTableColumns
+ implements EnumeratedTableColumn {
+ REMOVE("Remove", String.class, e -> "Remove Range", (e, v) -> nop(), null),
+ REGION("Region", String.class, RangeEntry::getRegionName),
+ MODULES("Modules", String.class, RangeEntry::getModuleNames),
+ SECTIONS("Sections", String.class, RangeEntry::getSectionNames),
+ SRC_MIN("SrcMin", Address.class, RangeEntry::getSrcMinAddress),
+ SRC_MAX("SrcMax", Address.class, RangeEntry::getSrcMaxAddress),
+ BLOCK("Block", String.class, RangeEntry::getBlockName, RangeEntry::setBlockName, //
+ RangeEntry::isCreate),
+ OVERLAY("Overlay", Boolean.class, RangeEntry::isOverlay),
+ DST_MIN("DstMin", Address.class, RangeEntry::getDstMinAddress),
+ DST_MAX("DstMax", Address.class, RangeEntry::getDstMaxAddress);
+
+ private static void nop() {
+ }
+
+ private final String header;
+ private final Class cls;
+ private final Function getter;
+ private final BiConsumer setter;
+ private final Predicate editable;
+
+ @SuppressWarnings("unchecked")
+ RangeTableColumns(String header, Class cls, Function getter,
+ BiConsumer setter, Predicate editable) {
+ this.header = header;
+ this.cls = cls;
+ this.getter = getter;
+ this.setter = (BiConsumer) setter;
+ this.editable = editable;
+ }
+
+ RangeTableColumns(String header, Class cls, Function getter) {
+ this(header, cls, getter, null, null);
+ }
+
+ @Override
+ public String getHeader() {
+ return header;
+ }
+
+ @Override
+ public Class getValueClass() {
+ return cls;
+ }
+
+ @Override
+ public Object getValueOf(RangeEntry row) {
+ return getter.apply(row);
+ }
+
+ @Override
+ public boolean isEditable(RangeEntry row) {
+ return setter != null && (editable == null || editable.test(row));
+ }
+
+ @Override
+ public void setValueOf(RangeEntry row, Object value) {
+ setter.accept(row, value);
+ }
+ }
+
+ protected static class RangeTableModel
+ extends DefaultEnumeratedColumnTableModel {
+ public RangeTableModel() {
+ super("Ranges", RangeTableColumns.class);
+ }
+
+ @Override
+ public List defaultSortOrder() {
+ return List.of(RangeTableColumns.SRC_MIN);
+ }
+ }
+
+ protected interface CopyDestination {
+ default Program getExistingProgram() {
+ return null;
+ }
+
+ default boolean isExisting() {
+ return getExistingProgram() != null;
+ }
+
+ Program getOrCreateProgram(TraceProgramView source, Object consumer) throws IOException;
+
+ default void saveIfApplicable(Program program) {
+ }
+ }
+
+ protected static final CopyDestination TEMP_PROGRAM = new CopyDestination() {
+ @Override
+ public String toString() {
+ return "";
+ }
+
+ @Override
+ public Program getOrCreateProgram(TraceProgramView source, Object consumer)
+ throws IOException {
+ return new ProgramDB(source.getName(), source.getLanguage(), source.getCompilerSpec(),
+ consumer);
+ }
+ };
+
+ protected final CopyDestination NEW_PROGRAM = new CopyDestination() {
+ @Override
+ public String toString() {
+ return "";
+ }
+
+ @Override
+ public Program getOrCreateProgram(TraceProgramView source, Object consumer)
+ throws IOException {
+ return new ProgramDB(source.getName(), source.getLanguage(), source.getCompilerSpec(),
+ consumer);
+ }
+
+ @Override
+ public void saveIfApplicable(Program program) {
+ programManager.saveProgramAs(program);
+ }
+ };
+
+ protected static class OpenProgramDestination implements CopyDestination {
+ private final Program program;
+
+ public OpenProgramDestination(Program program) {
+ this.program = program;
+ }
+
+ @Override
+ public String toString() {
+ return program.getName();
+ }
+
+ @Override
+ public Program getExistingProgram() {
+ return program;
+ }
+
+ @Override
+ public Program getOrCreateProgram(TraceProgramView source, Object consumer) {
+ return program;
+ }
+ }
+
+ protected DebuggerModelService modelService;
+ protected ProgramManager programManager;
+ protected DebuggerStaticMappingService staticMappingService;
+
+ protected TraceProgramView source;
+ protected AddressSetView set;
+
+ protected CompletableFuture lastTask;
+ protected CompletableFuture captureTask;
+
+ protected final DefaultComboBoxModel comboDestinationModel =
+ new DefaultComboBoxModel<>();
+ protected JComboBox comboDestination;
+ protected final Map programDestinations = new HashMap<>();
+
+ // TODO: Save these options to tool state?
+ protected JCheckBox cbCapture;
+ protected JCheckBox cbRelocate;
+ protected JCheckBox cbUseOverlays;
+ protected DebuggerCopyPlan plan = new DebuggerCopyPlan();
+
+ protected final RangeTableModel tableModel = new RangeTableModel();
+ protected GTable table;
+ protected GhidraTableFilterPanel filterPanel;
+
+ protected JButton resetButton;
+
+ public DebuggerCopyIntoProgramDialog() {
+ super("Copy Into Program", true, true, true, true);
+
+ populateComponents();
+ }
+
+ protected void populateComponents() {
+ plan.selectAll();
+ JPanel panel = new JPanel(new BorderLayout());
+
+ {
+ JPanel opts = new JPanel();
+ opts.setLayout(new BoxLayout(opts, BoxLayout.Y_AXIS));
+
+ {
+ Box progBox = Box.createHorizontalBox();
+ progBox.setBorder(BorderFactory.createEmptyBorder(GAP, GAP, GAP, GAP));
+ progBox.add(new JLabel("Destination:"));
+ comboDestination = new JComboBox<>(comboDestinationModel);
+ comboDestination.setBorder(BorderFactory.createEmptyBorder(0, GAP, 0, 0));
+ comboDestination.addActionListener(e -> {
+ if (!isVisible()) {
+ return;
+ }
+ syncCbRelocateEnabled(getDestination());
+ reset();
+ });
+ progBox.add(comboDestination);
+ opts.add(progBox);
+ }
+
+ {
+ // Avoid Swing's automatic indentation
+ JPanel inner = new JPanel(new BorderLayout());
+ inner.setBorder(BorderFactory.createEmptyBorder(0, GAP, GAP, GAP));
+ cbCapture =
+ new JCheckBox("Read live target's memory");
+ cbCapture.addActionListener(e -> {
+ if (!isVisible()) {
+ return;
+ }
+ reset();
+ });
+ inner.add(cbCapture);
+ opts.add(inner);
+ }
+
+ {
+ // Avoid Swing's automatic indentation
+ JPanel inner = new JPanel(new BorderLayout());
+ inner.setBorder(BorderFactory.createEmptyBorder(0, GAP, GAP, GAP));
+ cbRelocate =
+ new JCheckBox("Relocate via Mappings. WARNING: No fixups");
+ cbRelocate.addActionListener(e -> {
+ if (!isVisible()) {
+ return;
+ }
+ reset();
+ });
+ inner.add(cbRelocate);
+ opts.add(inner);
+ }
+
+ {
+ // No swing indentation
+ JPanel inner = new JPanel(new BorderLayout());
+ inner.setBorder(BorderFactory.createEmptyBorder(0, GAP, GAP, GAP));
+ cbUseOverlays = new JCheckBox("Use overlays where blocks already exist");
+ cbUseOverlays.addActionListener(e -> {
+ if (!isVisible()) {
+ return;
+ }
+ reset();
+ });
+ inner.add(cbUseOverlays);
+ opts.add(inner);
+ }
+
+ {
+ JPanel panelInclude = new JPanel(new GridLayout(0, 2, GAP, GAP));
+ panelInclude.setBorder(BorderFactory.createTitledBorder("Include:"));
+ JButton buttonSelectNone = new JButton("Select None");
+ buttonSelectNone.addActionListener(e -> plan.selectNone());
+ panelInclude.add(buttonSelectNone);
+ JButton buttonSelectAll = new JButton("Select All");
+ buttonSelectAll.addActionListener(e -> plan.selectAll());
+ panelInclude.add(buttonSelectAll);
+ for (Copier copier : plan.getAllCopiers()) {
+ panelInclude.add(plan.getCheckBox(copier));
+ }
+ opts.add(panelInclude);
+ }
+ panel.add(opts, BorderLayout.NORTH);
+ }
+
+ {
+ JPanel tablePanel = new JPanel(new BorderLayout());
+ table = new GTable(tableModel);
+ table.setSelectionMode(ListSelectionModel.MULTIPLE_INTERVAL_SELECTION);
+ tablePanel.add(new JScrollPane(table));
+ filterPanel = new GhidraTableFilterPanel<>(table, tableModel);
+ tablePanel.add(filterPanel, BorderLayout.SOUTH);
+ panel.add(tablePanel, BorderLayout.CENTER);
+ }
+
+ panel.setMinimumSize(new Dimension(600, 600));
+ addWorkPanel(panel);
+
+ addOKButton();
+ okButton.setText("Copy");
+ addCancelButton();
+ addResetButton();
+
+ TableColumnModel columnModel = table.getColumnModel();
+
+ TableColumn removeCol = columnModel.getColumn(RangeTableColumns.REMOVE.ordinal());
+ CellEditorUtils.installButton(table, filterPanel, removeCol, DebuggerResources.ICON_DELETE,
+ BUTTON_SIZE, this::removeEntry);
+ }
+
+ protected void addResetButton() {
+ resetButton = new JButton("Reset");
+ resetButton.setMnemonic('R');
+ resetButton.setName("Reset");
+ resetButton.addActionListener(e -> resetCallback());
+ addButton(resetButton);
+ }
+
+ @Override
+ protected void cancelCallback() {
+ synchronized (this) {
+ if (captureTask != null) {
+ captureTask.cancel(false);
+ }
+ }
+ super.cancelCallback();
+ }
+
+ @Override
+ protected void okCallback() {
+ super.okCallback();
+
+ lastTask = new CompletableFuture<>();
+ Task task = new Task("Copy Into Program", true, true, false) {
+ @Override
+ public void run(TaskMonitor monitor) throws CancelledException {
+ try {
+ executePlan(monitor);
+ Swing.runLater(() -> {
+ setStatusText("");
+ close();
+ });
+ }
+ catch (Exception e) {
+ Msg.error(this, "Error copying into program", e);
+ setStatusText("Error: " + e.getMessage());
+ }
+ }
+ };
+ task.addTaskListener(new TaskListener() {
+ @Override
+ public void taskCancelled(Task task) {
+ lastTask.cancel(false);
+ }
+
+ @Override
+ public void taskCompleted(Task task) {
+ lastTask.complete(null);
+ }
+ });
+ executeProgressTask(task, 500);
+ }
+
+ protected void resetCallback() {
+ reset();
+ }
+
+ protected void removeEntry(RangeEntry entry) {
+ tableModel.delete(entry);
+ }
+
+ protected TraceRecorder getRecorderIfReadsPresent() {
+ if (modelService == null) {
+ return null;
+ }
+ TraceRecorder recorder = modelService.getRecorder(source.getTrace());
+ if (recorder == null) {
+ return null;
+ }
+ if (!DebuggerCoordinates.view(source).withRecorder(recorder).isAliveAndReadsPresent()) {
+ return null;
+ }
+ return recorder;
+ }
+
+ protected void checkCbCaptureEnabled() {
+ boolean en = getRecorderIfReadsPresent() != null;
+ cbCapture.setEnabled(en);
+ cbCapture.setSelected(en);
+ }
+
+ public void setModelService(DebuggerModelService modelService) {
+ this.modelService = modelService;
+ checkCbCaptureEnabled();
+ }
+
+ public void setSource(TraceProgramView source, AddressSetView set) {
+ this.source = source;
+ this.set = set;
+ checkCbCaptureEnabled();
+ }
+
+ public void setProgramManager(ProgramManager programManager) {
+ this.programManager = programManager;
+ setSelectablePrograms(programManager.getAllOpenPrograms());
+ }
+
+ protected void setSelectablePrograms(Program[] programs) {
+ setSelectablePrograms(Arrays.asList(programs));
+ }
+
+ protected void setSelectablePrograms(Collection programs) {
+ programDestinations.clear();
+ comboDestinationModel.removeAllElements();
+ comboDestinationModel.addElement(NEW_PROGRAM);
+ comboDestinationModel.addElement(TEMP_PROGRAM);
+ for (Program program : new LinkedHashSet<>(programs)) {
+ OpenProgramDestination destination = new OpenProgramDestination(program);
+ programDestinations.put(program, destination);
+ comboDestinationModel.addElement(destination);
+ }
+ }
+
+ public void setDestination(Program program) {
+ setDestination(programDestinations.get(program));
+ }
+
+ protected void syncCbRelocateEnabled(CopyDestination dest) {
+ cbRelocate.setEnabled(dest.getExistingProgram() != null);
+ }
+
+ public void setDestination(CopyDestination dest) {
+ Objects.requireNonNull(dest);
+ syncCbRelocateEnabled(dest);
+ comboDestinationModel.setSelectedItem(dest);
+ }
+
+ public CopyDestination getDestination() {
+ return (CopyDestination) comboDestinationModel.getSelectedItem();
+ }
+
+ public void setCapture(boolean capture) {
+ if (capture && getRecorderIfReadsPresent() == null) {
+ throw new IllegalStateException(
+ "Cannot enable capture unless live and reading the present");
+ }
+ this.cbCapture.setSelected(capture);
+ }
+
+ public boolean isCapture() {
+ return (cbCapture.isSelected() && getRecorderIfReadsPresent() != null);
+ }
+
+ public void setRelocate(boolean relocate) {
+ if (relocate && !getDestination().isExisting()) {
+ throw new IllegalStateException("Cannot relocate when creating a new program");
+ }
+ this.cbRelocate.setSelected(relocate);
+ }
+
+ public boolean isRelocate() {
+ return cbRelocate.isSelected() && staticMappingService != null &&
+ getDestination().isExisting();
+ }
+
+ public void setUseOverlays(boolean useOverlays) {
+ if (useOverlays && !getDestination().isExisting()) {
+ // Technically, you can, but why would you?
+ throw new IllegalStateException("Cannot use overlays when creating a new program");
+ }
+ this.cbUseOverlays.setSelected(useOverlays);
+ }
+
+ public boolean isUseOverlays() {
+ return cbUseOverlays.isSelected() && getDestination().isExisting();
+ }
+
+ public void setStaticMappingService(DebuggerStaticMappingService staticMappingService) {
+ this.staticMappingService = staticMappingService;
+ cbRelocate.setEnabled(staticMappingService != null);
+ }
+
+ /**
+ * Re-populate the table based on destination and relocation settings
+ */
+ public void reset() {
+ Program dest = getDestination().getExistingProgram();
+ plan.syncCopiersEnabled(source, dest);
+ if (isRelocate()) {
+ resetWithRelocation(isUseOverlays(), dest);
+ }
+ else {
+ resetWithoutRelocation(isUseOverlays(), dest);
+ }
+ }
+
+ protected String createName(String desired, Set taken) {
+ if (taken.add(desired)) {
+ return desired;
+ }
+ String candidate = desired;
+ for (int i = 2;; i++) {
+ candidate = desired + "_" + i;
+ if (taken.add(candidate)) {
+ return candidate;
+ }
+ }
+ }
+
+ protected String computeRegionString(AddressRange rng) {
+ TraceMemoryManager mm = source.getTrace().getMemoryManager();
+ Collection regions =
+ mm.getRegionsIntersecting(Range.singleton(source.getSnap()), rng);
+ return regions.isEmpty() ? "UNKNOWN" : regions.iterator().next().getName();
+ }
+
+ protected String computeModulesString(AddressRange rng) {
+ TraceModuleManager mm = source.getTrace().getModuleManager();
+ Collection modules =
+ mm.getModulesIntersecting(Range.singleton(source.getSnap()), rng);
+ return modules.stream().map(m -> m.getName()).collect(Collectors.joining(","));
+ }
+
+ protected String computeSectionsString(AddressRange rng) {
+ TraceModuleManager mm = source.getTrace().getModuleManager();
+ Collection sections =
+ mm.getSectionsIntersecting(Range.singleton(source.getSnap()), rng);
+ return sections.stream().map(s -> s.getName()).collect(Collectors.joining(","));
+ }
+
+ protected void createEntry(Collection result, AddressRange srcRange,
+ AddressRange dstRange, boolean overlay, Set taken, MemoryBlock dstBlock) {
+ String srcName = computeRegionString(srcRange);
+ String dstName = dstBlock != null ? dstBlock.getName() : createName(srcName, taken);
+ String srcModules = computeModulesString(srcRange);
+ String srcSections = computeSectionsString(srcRange);
+ result.add(new RangeEntry(srcName, srcModules, srcSections, srcRange, dstName,
+ dstBlock == null, overlay, dstRange));
+ }
+
+ protected void createEntries(Collection result, boolean useOverlays,
+ MappedAddressRange mappedRng, AddressRange srcRange, AddressRange dstRange,
+ Set taken, Program dest) {
+ if (dest == null) {
+ createEntry(result, srcRange, dstRange, false, taken, null);
+ return;
+ }
+
+ Memory memory = dest.getMemory();
+ AddressSetView hits =
+ memory.intersectRange(dstRange.getMinAddress(), dstRange.getMaxAddress());
+ if (!hits.isEmpty() && useOverlays) {
+ createEntry(result, srcRange, dstRange, true, taken, null);
+ return;
+ }
+
+ AddressSetView misses = new AddressSet(dstRange).subtract(hits);
+ for (AddressRange miss : misses) {
+ createEntry(result, mappedRng.mapDestinationToSource(miss), miss, false, taken, null);
+ }
+ for (AddressRange hit : hits) {
+ Address next = hit.getMinAddress();
+ while (next != null && hit.contains(next)) {
+ MemoryBlock block = memory.getBlock(next);
+ AddressRange dr = hit.intersectRange(block.getStart(), block.getEnd());
+ createEntry(result, mappedRng.mapDestinationToSource(dr), dr, false, taken, block);
+ next = block.getEnd().next();
+ }
+ }
+ }
+
+ protected void collectBlockNames(Collection result, Program program) {
+ if (program == null) {
+ return;
+ }
+ for (MemoryBlock b : program.getMemory().getBlocks()) {
+ result.add(b.getName());
+ }
+ }
+
+ protected List breakRangeByRegions(AddressRange srcRange) {
+ AddressSet remains = new AddressSet(srcRange);
+ List result = new ArrayList<>();
+ for (TraceMemoryRegion region : source.getTrace()
+ .getMemoryManager()
+ .getRegionsIntersecting(Range.singleton(source.getSnap()), srcRange)) {
+ AddressRange range = region.getRange().intersect(srcRange);
+ result.add(range);
+ remains.delete(range);
+ }
+ remains.iterator().forEachRemaining(result::add);
+ return result;
+ }
+
+ protected void resetWithRelocation(boolean useOverlays, Program dest) {
+ Objects.requireNonNull(dest);
+ tableModel.clear();
+ List result = new ArrayList<>();
+ Set taken = new HashSet<>();
+ collectBlockNames(taken, dest);
+ Collection mappedSet = staticMappingService
+ .getOpenMappedViews(source.getTrace(), set, source.getSnap())
+ .get(dest);
+ if (mappedSet == null) {
+ return;
+ }
+ for (MappedAddressRange mappedRng : mappedSet) {
+ for (AddressRange src : breakRangeByRegions(mappedRng.getSourceAddressRange())) {
+ AddressRange dst = mappedRng.mapSourceToDestination(src);
+ createEntries(result, useOverlays, mappedRng, src, dst, taken, dest);
+ }
+ }
+ tableModel.addAll(result);
+ }
+
+ protected MappedAddressRange identityMapped(AddressRange srng, Program dest) {
+ if (dest == null) { // New program
+ return new MappedAddressRange(srng, srng);
+ }
+ AddressSpace srcSpace = srng.getAddressSpace();
+ AddressSpace dstSpace = dest.getAddressFactory().getAddressSpace(srcSpace.getName());
+ if (dstSpace == null) {
+ return null;
+ }
+ long minOff = MathUtilities.unsignedMax(srng.getMinAddress().getOffset(),
+ dstSpace.getMinAddress().getOffset());
+ long maxOff = MathUtilities.unsignedMin(srng.getMaxAddress().getOffset(),
+ dstSpace.getMaxAddress().getOffset());
+ if (Long.compareUnsigned(minOff, maxOff) > 0) {
+ return null;
+ }
+ return new MappedAddressRange(
+ new AddressRangeImpl(srcSpace.getAddress(minOff), srcSpace.getAddress(maxOff)),
+ new AddressRangeImpl(dstSpace.getAddress(minOff), dstSpace.getAddress(maxOff)));
+ }
+
+ protected void resetWithoutRelocation(boolean useOverlays, Program dest) {
+ tableModel.clear();
+ List result = new ArrayList<>();
+ Set taken = new HashSet<>();
+ collectBlockNames(taken, dest);
+ for (AddressRange rng : set) {
+ for (AddressRange src : breakRangeByRegions(rng)) {
+ MappedAddressRange id = identityMapped(src, dest);
+ if (id == null) {
+ continue;
+ }
+ createEntries(result, useOverlays, id, id.getSourceAddressRange(),
+ id.getDestinationAddressRange(), taken, dest);
+ }
+ }
+ tableModel.addAll(result);
+ }
+
+ protected MemoryBlock executeEntryBlock(RangeEntry entry, Program dest, TaskMonitor monitor)
+ throws Exception {
+ if (entry.isCreate()) {
+ return dest.getMemory()
+ .createInitializedBlock(entry.getBlockName(), entry.getDstMinAddress(),
+ entry.getDstRange().getLength(), (byte) 0, monitor, entry.isOverlay());
+ }
+ MemoryBlock block = dest.getMemory().getBlock(entry.getDstMinAddress());
+ if (plan.isRequiresInitializedMemory(source, dest) && !block.isInitialized()) {
+ return dest.getMemory().convertToInitialized(block, (byte) 0);
+ }
+ return block;
+ }
+
+ protected void executeEntry(RangeEntry entry, Program dest, TraceRecorder recorder,
+ TaskMonitor monitor)
+ throws Exception {
+ MemoryBlock block = executeEntryBlock(entry, dest, monitor);
+ Address dstMin = entry.getDstRange().getMinAddress();
+ if (block.isOverlay()) {
+ dstMin = block.getStart().getAddressSpace().getAddress(dstMin.getOffset());
+ }
+ if (recorder != null) {
+ executeCapture(entry.getSrcRange(), recorder, monitor);
+ }
+ plan.execute(source, entry.getSrcRange(), dest, dstMin, monitor);
+ }
+
+ protected TraceRecorder getRecorderIfEnabledAndReadsPresent() {
+ if (!cbCapture.isSelected()) {
+ return null;
+ }
+ return getRecorderIfReadsPresent();
+ }
+
+ protected void executeCapture(AddressRange range, TraceRecorder recorder, TaskMonitor monitor)
+ throws Exception {
+ synchronized (this) {
+ monitor.checkCanceled();
+ this.captureTask = recorder.captureProcessMemory(new AddressSet(range), monitor, false);
+ }
+ try {
+ captureTask.get(); // Not a fan, but whatever.
+ }
+ finally {
+ captureTask = null;
+ }
+ }
+
+ protected void executePlan(TaskMonitor monitor) throws Exception {
+ Program dest = getDestination().getOrCreateProgram(source, this);
+ boolean doRelease = !Arrays.asList(programManager.getAllOpenPrograms()).contains(dest);
+ TraceRecorder recorder = getRecorderIfEnabledAndReadsPresent();
+ try (UndoableTransaction tid = UndoableTransaction.start(dest, "Copy From Trace", true)) {
+ monitor.initialize(tableModel.getRowCount());
+ for (RangeEntry entry : tableModel.getModelData()) {
+ monitor.setMessage("Copying into " + entry.getDstRange());
+ executeEntry(entry, dest, recorder, monitor);
+ monitor.incrementProgress(1);
+ }
+ programManager.openProgram(dest);
+ }
+ finally {
+ if (doRelease) {
+ dest.release(this);
+ }
+ }
+ getDestination().saveIfApplicable(dest);
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/copying/DebuggerCopyPlan.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/copying/DebuggerCopyPlan.java
new file mode 100644
index 0000000000..4c30b0aa37
--- /dev/null
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/copying/DebuggerCopyPlan.java
@@ -0,0 +1,449 @@
+/* ###
+ * 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.copying;
+
+import java.util.*;
+
+import javax.swing.JCheckBox;
+
+import com.google.common.collect.Range;
+
+import ghidra.app.plugin.core.debug.gui.DebuggerResources;
+import ghidra.app.plugin.core.debug.service.breakpoint.LogicalBreakpointInternal.ProgramBreakpoint;
+import ghidra.app.util.viewer.listingpanel.PropertyBasedBackgroundColorModel;
+import ghidra.program.database.IntRangeMap;
+import ghidra.program.model.address.*;
+import ghidra.program.model.data.*;
+import ghidra.program.model.listing.*;
+import ghidra.program.model.symbol.*;
+import ghidra.trace.model.breakpoint.TraceBreakpoint;
+import ghidra.trace.model.memory.TraceMemoryManager;
+import ghidra.trace.model.memory.TraceMemoryState;
+import ghidra.trace.model.program.TraceProgramView;
+import ghidra.util.exception.InvalidInputException;
+import ghidra.util.task.TaskMonitor;
+
+public class DebuggerCopyPlan {
+ public interface Copier {
+ String getName();
+
+ boolean isAvailable(TraceProgramView from, Program into);
+
+ Collection getRequires();
+
+ Collection getRequiredBy();
+
+ boolean isRequiresInitializedMemory();
+
+ void copy(TraceProgramView from, AddressRange fromRange, Program into, Address intoAddress,
+ TaskMonitor monitor) throws Exception;
+ }
+
+ public enum AllCopiers implements Copier {
+ BYTES("Bytes", List.of()) {
+ @Override
+ public boolean isRequiresInitializedMemory() {
+ return true;
+ }
+
+ @Override
+ public void copy(TraceProgramView from, AddressRange fromRange, Program into,
+ Address intoAddress, TaskMonitor monitor) throws Exception {
+ // This is perhaps too heavy handed....
+ into.getListing()
+ .clearCodeUnits(intoAddress, intoAddress.add(fromRange.getLength() - 1),
+ false);
+ byte[] buf = new byte[4096];
+ AddressRangeChunker chunker = new AddressRangeChunker(fromRange, buf.length);
+ for (AddressRange chunk : chunker) {
+ monitor.checkCanceled();
+ Address addr = chunk.getMinAddress();
+ int len = (int) chunk.getLength();
+ from.getMemory().getBytes(addr, buf, 0, len);
+ long off = addr.subtract(fromRange.getMinAddress());
+ Address dest = intoAddress.add(off);
+ into.getMemory().setBytes(dest, buf, 0, len);
+ }
+ }
+ },
+ STATE("State (as colors)", List.of()) {
+ @Override
+ public void copy(TraceProgramView from, AddressRange fromRange, Program into,
+ Address intoAddress, TaskMonitor monitor) throws Exception {
+ IntRangeMap map =
+ into.getIntRangeMap(PropertyBasedBackgroundColorModel.COLOR_PROPERTY_NAME);
+ if (map == null) {
+ map = into.createIntRangeMap(
+ PropertyBasedBackgroundColorModel.COLOR_PROPERTY_NAME);
+ }
+ AddressSet rngAsSet = new AddressSet(fromRange);
+ TraceMemoryManager mm = from.getTrace().getMemoryManager();
+ AddressSetView knownSet = mm.getAddressesWithState(from.getSnap(), rngAsSet,
+ s -> s == TraceMemoryState.KNOWN);
+ AddressSetView errorSet = mm.getAddressesWithState(from.getSnap(), rngAsSet,
+ s -> s == TraceMemoryState.ERROR);
+ AddressSetView staleSet = rngAsSet.subtract(knownSet).subtract(errorSet);
+ setShifted(map, fromRange.getMinAddress(), intoAddress, errorSet,
+ DebuggerResources.DEFAULT_COLOR_BACKGROUND_ERROR.getRGB());
+ setShifted(map, fromRange.getMinAddress(), intoAddress, staleSet,
+ DebuggerResources.DEFAULT_COLOR_BACKGROUND_STALE.getRGB());
+ }
+
+ public void setShifted(IntRangeMap map, Address src, Address dst, AddressSetView set,
+ int value) {
+ for (AddressRange rng : set) {
+ long offMin = rng.getMinAddress().subtract(src);
+ long offMax = rng.getMaxAddress().subtract(src);
+ Address dMin = dst.add(offMin);
+ Address dMax = dst.add(offMax);
+ map.setValue(dMin, dMax, value);
+ }
+ }
+ },
+ INSTRUCTIONS("Instructions", List.of(BYTES)) {
+ @Override
+ protected boolean checkAvailable(TraceProgramView from, Program into) {
+ return into == null || from.getLanguage() == into.getLanguage();
+ }
+
+ @Override
+ public void copy(TraceProgramView from, AddressRange fromRange, Program into,
+ Address intoAddress, TaskMonitor monitor) throws Exception {
+ Listing intoListing = into.getListing();
+ for (Instruction ins : from.getListing()
+ .getInstructions(new AddressSet(fromRange), true)) {
+ monitor.checkCanceled();
+ if (!ins.getPrototype().getLanguage().equals(into.getLanguage())) {
+ // Filter out "guest" instructions
+ continue;
+ }
+ long off = ins.getMinAddress().subtract(fromRange.getMinAddress());
+ Address dest = intoAddress.add(off);
+ intoListing.createInstruction(dest, ins.getPrototype(), ins, ins);
+ }
+ }
+ },
+ DATA("Data", List.of()) {
+ @Override
+ protected boolean checkAvailable(TraceProgramView from, Program into) {
+ return into == null || sameDataOrganization(from, into);
+ }
+
+ @Override
+ public void copy(TraceProgramView from, AddressRange fromRange, Program into,
+ Address intoAddress, TaskMonitor monitor)
+ throws Exception {
+ Listing intoListing = into.getListing();
+ for (Data data : from.getListing()
+ .getDefinedData(new AddressSet(fromRange), true)) {
+ monitor.checkCanceled();
+ long off = data.getMinAddress().subtract(fromRange.getMinAddress());
+ Address dest = intoAddress.add(off);
+ DataType dt = data.getDataType();
+ if (!(dt instanceof DynamicDataType)) {
+ intoListing.createData(dest, dt, data.getLength());
+ }
+ }
+ }
+ },
+ DYNAMIC_DATA("Dynamic Data", List.of(BYTES)) {
+ @Override
+ protected boolean checkAvailable(TraceProgramView from, Program into) {
+ return into == null || sameDataOrganization(from, into);
+ }
+
+ @Override
+ public void copy(TraceProgramView from, AddressRange fromRange, Program into,
+ Address intoAddress, TaskMonitor monitor) throws Exception {
+ Listing intoListing = into.getListing();
+ for (Data data : from.getListing()
+ .getDefinedData(new AddressSet(fromRange), true)) {
+ monitor.checkCanceled();
+ long off = data.getMinAddress().subtract(fromRange.getMinAddress());
+ Address dest = intoAddress.add(off);
+ DataType dt = data.getDataType();
+ if (dt instanceof DynamicDataType) {
+ intoListing.createData(dest, dt, data.getLength());
+ }
+ }
+ }
+ },
+ LABELS("Labels", List.of()) {
+ @Override
+ public void copy(TraceProgramView from, AddressRange fromRange, Program into,
+ Address intoAddress, TaskMonitor monitor) throws Exception {
+ SymbolTable intoTable = into.getSymbolTable();
+ for (Symbol label : from.getSymbolTable()
+ .getSymbols(new AddressSet(fromRange), SymbolType.LABEL, true)) {
+ monitor.checkCanceled();
+ if (label.getSource() == SourceType.DEFAULT) {
+ continue;
+ }
+ long off = label.getAddress().subtract(fromRange.getMinAddress());
+ Address dest = intoAddress.add(off);
+ Namespace destNs =
+ findOrCopyNamespace(label.getParentNamespace(), intoTable, into);
+ try {
+ intoTable.createLabel(dest, label.getName(), destNs, label.getSource());
+ }
+ catch (InvalidInputException e) {
+ throw new AssertionError(e);
+ }
+ }
+ }
+
+ private Namespace findOrCopyNamespace(Namespace ns, SymbolTable intoTable,
+ Program into) throws Exception {
+ if (ns.isGlobal()) {
+ return into.getGlobalNamespace();
+ }
+ Namespace destParent =
+ findOrCopyNamespace(ns.getParentNamespace(), intoTable, into);
+ return intoTable.getOrCreateNameSpace(destParent, ns.getName(),
+ ns.getSymbol().getSource());
+ }
+ },
+ BREAKPOINTS("Breakpoints (as bookmarks)", List.of()) {
+ @Override
+ public void copy(TraceProgramView from, AddressRange fromRange, Program into,
+ Address intoAddress, TaskMonitor monitor) throws Exception {
+ for (TraceBreakpoint bpt : from.getTrace()
+ .getBreakpointManager()
+ .getBreakpointsIntersecting(Range.singleton(from.getSnap()), fromRange)) {
+ monitor.checkCanceled();
+ long off = bpt.getMinAddress().subtract(fromRange.getMinAddress());
+ Address dest = intoAddress.add(off);
+ ProgramBreakpoint pb =
+ new ProgramBreakpoint(into, dest, bpt.getLength(), bpt.getKinds());
+ if (bpt.isEnabled()) {
+ pb.enable();
+ }
+ else {
+ pb.disable();
+ }
+ }
+ }
+ },
+ BOOKMARKS("Bookmarks", List.of()) {
+ @Override
+ public void copy(TraceProgramView from, AddressRange fromRange, Program into,
+ Address intoAddress, TaskMonitor monitor) throws Exception {
+ BookmarkManager intoBookmarks = into.getBookmarkManager();
+ Iterator bit =
+ from.getBookmarkManager().getBookmarksIterator(fromRange.getMinAddress(), true);
+ while (bit.hasNext()) {
+ monitor.checkCanceled();
+ Bookmark bm = bit.next();
+ if (bm.getAddress().compareTo(fromRange.getMaxAddress()) > 0) {
+ break;
+ }
+ BookmarkType type = bm.getType();
+ long off = bm.getAddress().subtract(fromRange.getMinAddress());
+ Address dest = intoAddress.add(off);
+ BookmarkType destType = intoBookmarks.getBookmarkType(type.getTypeString());
+ if (destType == null) {
+ destType = intoBookmarks.defineType(type.getTypeString(), type.getIcon(),
+ type.getMarkerColor(), type.getMarkerPriority());
+ }
+ intoBookmarks.setBookmark(dest, destType.getTypeString(), bm.getCategory(),
+ bm.getComment());
+ }
+ }
+ },
+ REFERENCES("References (memory only)", List.of()) {
+ @Override
+ public void copy(TraceProgramView from, AddressRange fromRange, Program into,
+ Address intoAddress, TaskMonitor monitor) throws Exception {
+ ReferenceManager intoRefs = into.getReferenceManager();
+ for (Reference ref : from.getReferenceManager()
+ .getReferenceIterator(fromRange.getMinAddress())) {
+ monitor.checkCanceled();
+ if (ref.getFromAddress().compareTo(fromRange.getMaxAddress()) > 0) {
+ break;
+ }
+ if (ref.getSource() == SourceType.DEFAULT) {
+ continue;
+ }
+ // TODO: Other kinds of references?
+ if (!ref.isMemoryReference()) {
+ continue;
+ }
+ // Requiring both ends to be in copied range
+ if (!fromRange.contains(ref.getToAddress())) {
+ continue;
+ }
+
+ // NB. "from" is overloaded here
+ long offFrom = ref.getFromAddress().subtract(fromRange.getMinAddress());
+ long offTo = ref.getToAddress().subtract(fromRange.getMinAddress());
+ Address destFrom = intoAddress.add(offFrom);
+ Address destTo = intoAddress.add(offTo);
+ intoRefs.addMemoryReference(destFrom, destTo, ref.getReferenceType(),
+ ref.getSource(), ref.getOperandIndex());
+ }
+ }
+ },
+ COMMENTS("Comments", List.of()) {
+ @Override
+ public void copy(TraceProgramView from, AddressRange fromRange, Program into,
+ Address intoAddress, TaskMonitor monitor) throws Exception {
+ Listing fromListing = from.getListing();
+ Listing intoListing = into.getListing();
+ for (Address addr : fromListing.getCommentAddressIterator(new AddressSet(fromRange),
+ true)) {
+ monitor.checkCanceled();
+ long off = addr.subtract(fromRange.getMinAddress());
+ Address dest = intoAddress.add(off);
+ // Ugly, but there's not MAX/MIN_COMMENT_TYPE
+ for (int i = CodeUnit.EOL_COMMENT; i <= CodeUnit.REPEATABLE_COMMENT; i++) {
+ String comment = fromListing.getComment(i, addr);
+ if (comment == null) {
+ continue;
+ }
+ intoListing.setComment(dest, i, comment);
+ }
+ }
+ }
+ };
+
+ protected boolean sameDataOrganization(Program p1, Program p2) {
+ DataOrganization dataOrg1 = p1.getDataTypeManager().getDataOrganization();
+ DataOrganization dataOrg2 = p2.getDataTypeManager().getDataOrganization();
+ return dataOrg1.equals(dataOrg2);
+ }
+
+ public static final List VALUES;
+ static {
+ List asList = Arrays.asList(values());
+ Collections.sort(asList, Comparator.comparing(AllCopiers::getName));
+ VALUES = Collections.unmodifiableList(asList);
+ }
+
+ final String name;
+ final Collection requires;
+ final Collection requiredBy = new HashSet<>();
+
+ private AllCopiers(String name, Collection requires) {
+ this.name = name;
+ this.requires = Collections.unmodifiableCollection(requires);
+ for (AllCopiers req : requires) {
+ req.requiredBy.add(this);
+ }
+ }
+
+ protected boolean checkAvailable(TraceProgramView from, Program into) {
+ return true;
+ }
+
+ @Override
+ public boolean isAvailable(TraceProgramView from, Program into) {
+ return checkAvailable(from, into) &&
+ getRequires().stream().allMatch(c -> c.isAvailable(from, into));
+ }
+
+ @Override
+ public String getName() {
+ return name;
+ }
+
+ @Override
+ public Collection getRequires() {
+ return requires;
+ }
+
+ @Override
+ public Collection getRequiredBy() {
+ return requiredBy;
+ }
+
+ @Override
+ public boolean isRequiresInitializedMemory() {
+ return false;
+ }
+ }
+
+ protected final Map checkBoxes = new LinkedHashMap<>();
+
+ public DebuggerCopyPlan() {
+ for (Copier copier : getAllCopiers()) {
+ JCheckBox cb = new JCheckBox(copier.getName());
+ Collection requires = copier.getRequires();
+ Collection requiredBy = copier.getRequiredBy();
+ if (!requires.isEmpty() || !requiredBy.isEmpty()) {
+ cb.addActionListener(e -> {
+ if (cb.isSelected()) {
+ for (Copier req : requires) {
+ checkBoxes.get(req).setSelected(true);
+ }
+ }
+ else {
+ for (Copier dep : requiredBy) {
+ checkBoxes.get(dep).setSelected(false);
+ }
+ }
+ });
+ }
+ checkBoxes.put(copier, cb);
+ }
+ }
+
+ public Collection getAllCopiers() {
+ return AllCopiers.VALUES;
+ }
+
+ public JCheckBox getCheckBox(Copier copier) {
+ return checkBoxes.get(copier);
+ }
+
+ public void selectAll() {
+ for (JCheckBox cb : checkBoxes.values()) {
+ cb.setSelected(true);
+ }
+ }
+
+ public void selectNone() {
+ for (JCheckBox cb : checkBoxes.values()) {
+ cb.setSelected(false);
+ }
+ }
+
+ public void execute(TraceProgramView from, AddressRange fromRange, Program into,
+ Address intoAddress, TaskMonitor monitor) throws Exception {
+ for (Copier copier : getAllCopiers()) {
+ if (!copier.isAvailable(from, into)) {
+ continue;
+ }
+ if (!checkBoxes.get(copier).isSelected()) {
+ continue;
+ }
+ copier.copy(from, fromRange, into, intoAddress, monitor);
+ }
+ }
+
+ public void syncCopiersEnabled(TraceProgramView from, Program dest) {
+ for (Map.Entry ent : checkBoxes.entrySet()) {
+ ent.getValue().setEnabled(ent.getKey().isAvailable(from, dest));
+ }
+ }
+
+ public boolean isRequiresInitializedMemory(TraceProgramView from, Program dest) {
+ return checkBoxes.entrySet().stream().anyMatch(ent -> {
+ Copier copier = ent.getKey();
+ return copier.isRequiresInitializedMemory() &&
+ copier.isAvailable(from, dest) && ent.getValue().isSelected();
+ });
+ }
+}
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingProvider.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingProvider.java
index 70c600d489..d63c9adf3d 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingProvider.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/listing/DebuggerListingProvider.java
@@ -52,7 +52,6 @@ import ghidra.app.plugin.core.debug.gui.action.*;
import ghidra.app.plugin.core.debug.gui.modules.DebuggerMissingModuleActionContext;
import ghidra.app.plugin.core.debug.utils.ProgramLocationUtils;
import ghidra.app.plugin.core.debug.utils.ProgramURLUtils;
-import ghidra.app.plugin.core.exporter.ExporterDialog;
import ghidra.app.services.*;
import ghidra.app.util.viewer.format.FormatManager;
import ghidra.app.util.viewer.listingpanel.ListingPanel;
@@ -72,7 +71,6 @@ import ghidra.program.util.ProgramSelection;
import ghidra.trace.model.Trace;
import ghidra.trace.model.modules.*;
import ghidra.trace.model.program.TraceProgramView;
-import ghidra.trace.model.program.TraceVariableSnapProgramView;
import ghidra.util.HTMLUtilities;
import ghidra.util.Swing;
import ghidra.util.exception.CancelledException;
@@ -239,8 +237,7 @@ public class DebuggerListingProvider extends CodeViewerProvider {
protected SyncToStaticListingAction actionSyncToStaticListing;
protected FollowsCurrentThreadAction actionFollowsCurrentThread;
protected MultiStateDockingAction actionAutoReadMemory;
- protected DockingAction actionCaptureSelectedMemory;
- protected DockingAction actionExportView;
+ protected DockingAction actionReadSelectedMemory;
protected DockingAction actionOpenProgram;
protected MultiStateDockingAction actionTrackLocation;
@@ -608,12 +605,7 @@ public class DebuggerListingProvider extends CodeViewerProvider {
actionGoTo = goToTrait.installAction();
actionTrackLocation = trackingTrait.installAction();
actionAutoReadMemory = readsMemTrait.installAutoReadAction();
- actionCaptureSelectedMemory = readsMemTrait.installCaptureSelectedAction();
-
- actionExportView = ExportTraceViewAction.builder(plugin)
- .enabledWhen(ctx -> current.getView() != null)
- .onAction(this::activatedExportView)
- .buildAndInstallLocal(this);
+ actionReadSelectedMemory = readsMemTrait.installReadSelectedAction();
actionOpenProgram = OpenProgramAction.builder(plugin)
.withContext(DebuggerOpenProgramActionContext.class)
@@ -623,20 +615,6 @@ public class DebuggerListingProvider extends CodeViewerProvider {
contextChanged();
}
- private void activatedExportView(ActionContext context) {
- if (current.getView() == null) {
- return;
- }
- // Avoid odd race conditions by fixing the snap
- TraceProgramView fixed = current.getView() instanceof TraceVariableSnapProgramView
- ? current.getTrace().getFixedProgramView(current.getSnap())
- : current.getView();
-
- ExporterDialog dialog =
- new ExporterDialog(tool, fixed.getDomainFile(), fixed, getSelection());
- tool.showDialog(dialog);
- }
-
private void activatedOpenProgram(DebuggerOpenProgramActionContext context) {
programManager.openProgram(context.getDomainFile(), DomainFile.DEFAULT_VERSION,
ProgramManager.OPEN_CURRENT);
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/memory/DebuggerMemoryBytesProvider.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/memory/DebuggerMemoryBytesProvider.java
index 3d8050eaf1..222edf3693 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/memory/DebuggerMemoryBytesProvider.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/memory/DebuggerMemoryBytesProvider.java
@@ -148,7 +148,7 @@ public class DebuggerMemoryBytesProvider extends ProgramByteViewerComponentProvi
protected DockingAction actionGoTo;
protected FollowsCurrentThreadAction actionFollowsCurrentThread;
protected MultiStateDockingAction actionAutoReadMemory;
- protected DockingAction actionCaptureSelectedMemory;
+ protected DockingAction actionReadSelectedMemory;
protected MultiStateDockingAction actionTrackLocation;
protected ForMemoryBytesGoToTrait goToTrait;
@@ -257,7 +257,7 @@ public class DebuggerMemoryBytesProvider extends ProgramByteViewerComponentProvi
actionGoTo = goToTrait.installAction();
actionTrackLocation = trackingTrait.installAction();
actionAutoReadMemory = readsMemTrait.installAutoReadAction();
- actionCaptureSelectedMemory = readsMemTrait.installCaptureSelectedAction();
+ actionReadSelectedMemory = readsMemTrait.installReadSelectedAction();
}
@Override
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/breakpoint/LogicalBreakpointInternal.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/breakpoint/LogicalBreakpointInternal.java
index 9d17df1b79..40d542c548 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/breakpoint/LogicalBreakpointInternal.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/breakpoint/LogicalBreakpointInternal.java
@@ -37,7 +37,7 @@ import ghidra.util.exception.CancelledException;
import ghidra.util.task.TaskMonitor;
import utilities.util.IDHashed;
-interface LogicalBreakpointInternal extends LogicalBreakpoint {
+public interface LogicalBreakpointInternal extends LogicalBreakpoint {
public static class ProgramBreakpoint {
public static Set kindsFromBookmark(Bookmark mark) {
String[] parts = mark.getCategory().split(";");
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/ReadsTargetMemoryPcodeExecutorState.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/ReadsTargetMemoryPcodeExecutorState.java
index 8700bbdc66..020c0f46d1 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/ReadsTargetMemoryPcodeExecutorState.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/ReadsTargetMemoryPcodeExecutorState.java
@@ -15,10 +15,11 @@
*/
package ghidra.app.plugin.core.debug.service.emulation;
+import java.util.Collection;
import java.util.Map.Entry;
import ghidra.app.services.DebuggerStaticMappingService;
-import ghidra.app.services.DebuggerStaticMappingService.ShiftAndAddressSetView;
+import ghidra.app.services.DebuggerStaticMappingService.MappedAddressRange;
import ghidra.app.services.TraceRecorder;
import ghidra.framework.plugintool.PluginTool;
import ghidra.program.model.address.*;
@@ -78,40 +79,44 @@ public class ReadsTargetMemoryPcodeExecutorState
DebuggerStaticMappingService mappingService =
tool.getService(DebuggerStaticMappingService.class);
byte[] data = new byte[4096];
- for (Entry ent : mappingService
+ for (Entry> ent : mappingService
.getOpenMappedViews(trace, unknown, snap)
.entrySet()) {
Program program = ent.getKey();
- ShiftAndAddressSetView shifted = ent.getValue();
- long shift = shifted.getShift();
Memory memory = program.getMemory();
AddressSetView initialized = memory.getLoadedAndInitializedAddressSet();
- AddressSetView toRead = shifted.getAddressSetView().intersect(initialized);
- Msg.warn(this,
- "Filling in unknown trace memory in emulator using mapped image: " +
- program + ": " + toRead);
- for (AddressRange rng : toRead) {
- long lower = rng.getMinAddress().getOffset();
- long fullLen = rng.getLength();
- while (fullLen > 0) {
- int len = MathUtilities.unsignedMin(data.length, fullLen);
- try {
- int read =
- memory.getBytes(space.getAddress(lower), data, 0, len);
- if (read < len) {
- Msg.warn(this,
- " Partial read of " + rng + ". Got " + read + " bytes");
+ Collection mappedSet = ent.getValue();
+ for (MappedAddressRange mappedRng : mappedSet) {
+ AddressRange srng = mappedRng.getSourceAddressRange();
+ long shift = mappedRng.getShift();
+ for (AddressRange subsrng : initialized.intersectRange(srng.getMinAddress(),
+ srng.getMaxAddress())) {
+ Msg.warn(this,
+ "Filling in unknown trace memory in emulator using mapped image: " +
+ program + ": " + subsrng);
+ long lower = subsrng.getMinAddress().getOffset();
+ long fullLen = subsrng.getLength();
+ while (fullLen > 0) {
+ int len = MathUtilities.unsignedMin(data.length, fullLen);
+ try {
+ int read =
+ memory.getBytes(space.getAddress(lower), data, 0, len);
+ if (read < len) {
+ Msg.warn(this,
+ " Partial read of " + subsrng + ". Got " + read +
+ " bytes");
+ }
+ cache.putData(lower - shift, data, 0, read);
}
- cache.putData(lower - shift, data, 0, read);
+ catch (MemoryAccessException | AddressOutOfBoundsException e) {
+ throw new AssertionError(e);
+ }
+ lower += len;
+ fullLen -= len;
}
- catch (MemoryAccessException | AddressOutOfBoundsException e) {
- throw new AssertionError(e);
- }
- lower += len;
- fullLen -= len;
+ result = true;
}
- result = true;
}
}
return result;
diff --git a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/modules/DebuggerStaticMappingServicePlugin.java b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/modules/DebuggerStaticMappingServicePlugin.java
index 9348c19b52..9a397b5d70 100644
--- a/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/modules/DebuggerStaticMappingServicePlugin.java
+++ b/Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/modules/DebuggerStaticMappingServicePlugin.java
@@ -283,7 +283,6 @@ public class DebuggerStaticMappingServicePlugin extends Plugin
private Program program;
private AddressRange staticRange;
- private Long shift; // from static image to trace
public MappingEntry(TraceStaticMapping mapping) {
this.mapping = mapping;
@@ -309,8 +308,6 @@ public class DebuggerStaticMappingServicePlugin extends Plugin
Address minAddr = opened.getAddressFactory().getAddress(mapping.getStaticAddress());
Address maxAddr = addOrMax(minAddr, mapping.getLength() - 1);
this.staticRange = new AddressRangeImpl(minAddr, maxAddr);
- this.shift = mapping.getMinTraceAddress().getOffset() -
- staticRange.getMinAddress().getOffset();
return true;
}
return false;
@@ -320,7 +317,6 @@ public class DebuggerStaticMappingServicePlugin extends Plugin
if (this.program == closed) {
this.program = null;
this.staticRange = null;
- this.shift = null;
return true;
}
return false;
@@ -565,7 +561,7 @@ public class DebuggerStaticMappingServicePlugin extends Plugin
}
protected void collectOpenMappedPrograms(AddressRange rng, Range