yetangitu/ghidra
1
0
Fork 0
mirror of https://github.com/NationalSecurityAgency/ghidra.git synced 2025-10-05 19:42:36 +02:00
Code Issues Releases Wiki Activity

Merge remote-tracking branch 'origin/GP-4186_Dan_enumTraceChangeTypes--SQUASHED'

Browse source
This commit is contained in:
Ryan Kurtz 2024-02-06 10:47:19 -05:00
commit dfadd58ee4
93 changed files with 1555 additions and 1111 deletions
Download patch file Download diff file Expand all files Collapse all files

24
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/DebuggerLocationLabel.java
View file

@ -26,12 +26,12 @@ import ghidra.async.AsyncTimer;
import ghidra.debug.api.tracemgr.DebuggerCoordinates;
import ghidra.program.model.address.Address;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.*;
import ghidra.trace.model.TraceDomainObjectListener;
import ghidra.trace.model.memory.TraceMemoryRegion;
import ghidra.trace.model.modules.TraceModule;
import ghidra.trace.model.modules.TraceSection;
import ghidra.trace.model.program.TraceProgramView;
import ghidra.trace.util.TraceEvents;
import ghidra.util.Swing;
public class DebuggerLocationLabel extends JLabel {
@ -44,19 +44,19 @@ public class DebuggerLocationLabel extends JLabel {
updateLabelDebouncer
.addListener(__ -> Swing.runIfSwingOrRunLater(() -> doUpdateLabel()));
listenFor(TraceMemoryRegionChangeType.ADDED, this::regionChanged);
listenFor(TraceMemoryRegionChangeType.CHANGED, this::regionChanged);
listenFor(TraceMemoryRegionChangeType.LIFESPAN_CHANGED, this::regionChanged);
listenFor(TraceMemoryRegionChangeType.DELETED, this::regionChanged);
listenFor(TraceEvents.REGION_ADDED, this::regionChanged);
listenFor(TraceEvents.REGION_CHANGED, this::regionChanged);
listenFor(TraceEvents.REGION_LIFESPAN_CHANGED, this::regionChanged);
listenFor(TraceEvents.REGION_DELETED, this::regionChanged);
listenFor(TraceModuleChangeType.ADDED, this::moduleChanged);
listenFor(TraceModuleChangeType.CHANGED, this::moduleChanged);
listenFor(TraceModuleChangeType.LIFESPAN_CHANGED, this::moduleChanged);
listenFor(TraceModuleChangeType.DELETED, this::moduleChanged);
listenFor(TraceEvents.MODULE_ADDED, this::moduleChanged);
listenFor(TraceEvents.MODULE_CHANGED, this::moduleChanged);
listenFor(TraceEvents.MODULE_LIFESPAN_CHANGED, this::moduleChanged);
listenFor(TraceEvents.MODULE_DELETED, this::moduleChanged);
listenFor(TraceSectionChangeType.ADDED, this::sectionChanged);
listenFor(TraceSectionChangeType.CHANGED, this::sectionChanged);
listenFor(TraceSectionChangeType.DELETED, this::sectionChanged);
listenFor(TraceEvents.SECTION_ADDED, this::sectionChanged);
listenFor(TraceEvents.SECTION_CHANGED, this::sectionChanged);
listenFor(TraceEvents.SECTION_DELETED, this::sectionChanged);
}
private void doUpdateLabel() {

4
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/AutoMapSpec.java
View file

@ -31,7 +31,7 @@ import ghidra.framework.options.SaveState;
import ghidra.framework.plugintool.AutoConfigState.ConfigFieldCodec;
import ghidra.framework.plugintool.PluginTool;
import ghidra.trace.model.Trace;
import ghidra.trace.util.TraceChangeType;
import ghidra.trace.util.TraceEvent;
import ghidra.util.classfinder.ClassSearcher;
import ghidra.util.classfinder.ExtensionPoint;
import ghidra.util.exception.CancelledException;
@ -91,7 +91,7 @@ public interface AutoMapSpec extends ExtensionPoint {
return DebuggerResources.ICON_CONFIG;
}
Collection<TraceChangeType<?, ?>> getChangeTypes();
Collection<TraceEvent<?, ?>> getChangeTypes();
default String getTaskTitle() {
return getMenuName();

12
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/ByModuleAutoMapSpec.java
View file

@ -24,9 +24,8 @@ import ghidra.debug.api.modules.ModuleMapProposal;
import ghidra.debug.api.modules.ModuleMapProposal.ModuleMapEntry;
import ghidra.program.model.listing.Program;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceMemoryRegionChangeType;
import ghidra.trace.model.Trace.TraceModuleChangeType;
import ghidra.trace.util.TraceChangeType;
import ghidra.trace.util.TraceEvent;
import ghidra.trace.util.TraceEvents;
import ghidra.util.exception.CancelledException;
import ghidra.util.task.TaskMonitor;
@ -44,9 +43,10 @@ public class ByModuleAutoMapSpec implements AutoMapSpec {
}
@Override
public Collection<TraceChangeType<?, ?>> getChangeTypes() {
return List.of(TraceModuleChangeType.ADDED, TraceModuleChangeType.CHANGED,
TraceMemoryRegionChangeType.ADDED, TraceMemoryRegionChangeType.CHANGED);
public Collection<TraceEvent<?, ?>> getChangeTypes() {
return List.of(
TraceEvents.MODULE_ADDED, TraceEvents.MODULE_CHANGED,
TraceEvents.REGION_ADDED, TraceEvents.REGION_CHANGED);
}
@Override

8
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/ByRegionAutoMapSpec.java
View file

@ -24,8 +24,8 @@ import ghidra.debug.api.modules.RegionMapProposal;
import ghidra.debug.api.modules.RegionMapProposal.RegionMapEntry;
import ghidra.program.model.listing.Program;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceMemoryRegionChangeType;
import ghidra.trace.util.TraceChangeType;
import ghidra.trace.util.TraceEvent;
import ghidra.trace.util.TraceEvents;
import ghidra.util.exception.CancelledException;
import ghidra.util.task.TaskMonitor;
@ -43,8 +43,8 @@ public class ByRegionAutoMapSpec implements AutoMapSpec {
}
@Override
public Collection<TraceChangeType<?, ?>> getChangeTypes() {
return List.of(TraceMemoryRegionChangeType.ADDED);
public Collection<TraceEvent<?, ?>> getChangeTypes() {
return List.of(TraceEvents.REGION_ADDED);
}
@Override

8
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/BySectionAutoMapSpec.java
View file

@ -24,8 +24,8 @@ import ghidra.debug.api.modules.SectionMapProposal;
import ghidra.debug.api.modules.SectionMapProposal.SectionMapEntry;
import ghidra.program.model.listing.Program;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceSectionChangeType;
import ghidra.trace.util.TraceChangeType;
import ghidra.trace.util.TraceEvent;
import ghidra.trace.util.TraceEvents;
import ghidra.util.exception.CancelledException;
import ghidra.util.task.TaskMonitor;
@ -43,8 +43,8 @@ public class BySectionAutoMapSpec implements AutoMapSpec {
}
@Override
public Collection<TraceChangeType<?, ?>> getChangeTypes() {
return List.of(TraceSectionChangeType.ADDED);
public Collection<TraceEvent<?, ?>> getChangeTypes() {
return List.of(TraceEvents.SECTION_ADDED);
}
@Override

12
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/DebuggerReadsMemoryTrait.java
View file

@ -32,18 +32,16 @@ import ghidra.app.util.viewer.listingpanel.AddressSetDisplayListener;
import ghidra.debug.api.target.Target;
import ghidra.debug.api.tracemgr.DebuggerCoordinates;
import ghidra.framework.cmd.BackgroundCommand;
import ghidra.framework.model.DomainObject;
import ghidra.framework.model.DomainObjectChangeRecord;
import ghidra.framework.model.*;
import ghidra.framework.options.SaveState;
import ghidra.framework.plugintool.*;
import ghidra.framework.plugintool.annotation.AutoConfigStateField;
import ghidra.program.model.address.*;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceMemoryStateChangeType;
import ghidra.trace.model.Trace.TraceSnapshotChangeType;
import ghidra.trace.model.memory.TraceMemoryState;
import ghidra.trace.model.program.TraceProgramView;
import ghidra.trace.model.time.TraceSnapshot;
import ghidra.trace.util.TraceEvents;
import ghidra.util.Msg;
import ghidra.util.exception.CancelledException;
import ghidra.util.task.TaskMonitor;
@ -101,9 +99,9 @@ public abstract class DebuggerReadsMemoryTrait {
protected class ForReadsTraceListener extends TraceDomainObjectListener {
public ForReadsTraceListener() {
listenForUntyped(DomainObject.DO_OBJECT_RESTORED, this::objectRestored);
listenFor(TraceSnapshotChangeType.ADDED, this::snapshotAdded);
listenFor(TraceMemoryStateChangeType.CHANGED, this::memStateChanged);
listenForUntyped(DomainObjectEvent.RESTORED, this::objectRestored);
listenFor(TraceEvents.SNAPSHOT_ADDED, this::snapshotAdded);
listenFor(TraceEvents.BYTES_STATE_CHANGED, this::memStateChanged);
}
private void objectRestored(DomainObjectChangeRecord rec) {

7
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/DebuggerTrackLocationTrait.java
View file

@ -43,11 +43,10 @@ import ghidra.framework.plugintool.*;
import ghidra.framework.plugintool.annotation.AutoConfigStateField;
import ghidra.program.util.ProgramLocation;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceMemoryBytesChangeType;
import ghidra.trace.model.Trace.TraceStackChangeType;
import ghidra.trace.model.stack.TraceStack;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceAddressSpace;
import ghidra.trace.util.TraceEvents;
import ghidra.util.Msg;
public class DebuggerTrackLocationTrait {
@ -57,8 +56,8 @@ public class DebuggerTrackLocationTrait {
protected class ForTrackingListener extends TraceDomainObjectListener {
public ForTrackingListener() {
listenFor(TraceMemoryBytesChangeType.CHANGED, this::registersChanged);
listenFor(TraceStackChangeType.CHANGED, this::stackChanged);
listenFor(TraceEvents.BYTES_CHANGED, this::registersChanged);
listenFor(TraceEvents.STACK_CHANGED, this::stackChanged);
}
private void registersChanged(TraceAddressSpace space, TraceAddressSnapRange range,

4
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/NoneAutoMapSpec.java
View file

@ -22,7 +22,7 @@ import ghidra.app.services.DebuggerStaticMappingService;
import ghidra.app.services.ProgramManager;
import ghidra.framework.plugintool.PluginTool;
import ghidra.trace.model.Trace;
import ghidra.trace.util.TraceChangeType;
import ghidra.trace.util.TraceEvent;
import ghidra.util.exception.CancelledException;
import ghidra.util.task.TaskMonitor;
@ -40,7 +40,7 @@ public class NoneAutoMapSpec implements AutoMapSpec {
}
@Override
public Collection<TraceChangeType<?, ?>> getChangeTypes() {
public Collection<TraceEvent<?, ?>> getChangeTypes() {
return List.of();
}

4
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/action/OneToOneAutoMapSpec.java
View file

@ -24,7 +24,7 @@ import ghidra.program.model.listing.Program;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace;
import ghidra.trace.model.modules.TraceConflictedMappingException;
import ghidra.trace.util.TraceChangeType;
import ghidra.trace.util.TraceEvent;
import ghidra.util.exception.CancelledException;
import ghidra.util.task.TaskMonitor;
@ -42,7 +42,7 @@ public class OneToOneAutoMapSpec implements AutoMapSpec {
}
@Override
public Collection<TraceChangeType<?, ?>> getChangeTypes() {
public Collection<TraceEvent<?, ?>> getChangeTypes() {
return List.of();
}

10
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/breakpoint/DebuggerBreakpointsProvider.java
View file

@ -52,9 +52,9 @@ import ghidra.program.model.address.AddressRange;
import ghidra.program.util.MarkerLocation;
import ghidra.program.util.ProgramLocation;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceBreakpointChangeType;
import ghidra.trace.model.breakpoint.TraceBreakpoint;
import ghidra.trace.model.breakpoint.TraceBreakpointKind;
import ghidra.trace.util.TraceEvents;
import ghidra.util.*;
import ghidra.util.database.ObjectKey;
import ghidra.util.table.GhidraTable;
@ -602,10 +602,10 @@ public class DebuggerBreakpointsProvider extends ComponentProviderAdapter
public ForBreakpointLocationsTraceListener(Trace trace) {
this.trace = trace;
listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored());
listenFor(TraceBreakpointChangeType.ADDED, this::locationAdded);
listenFor(TraceBreakpointChangeType.CHANGED, this::locationChanged);
listenFor(TraceBreakpointChangeType.LIFESPAN_CHANGED, this::locationLifespanChanged);
listenFor(TraceBreakpointChangeType.DELETED, this::locationDeleted);
listenFor(TraceEvents.BREAKPOINT_ADDED, this::locationAdded);
listenFor(TraceEvents.BREAKPOINT_CHANGED, this::locationChanged);
listenFor(TraceEvents.BREAKPOINT_LIFESPAN_CHANGED, this::locationLifespanChanged);
listenFor(TraceEvents.BREAKPOINT_DELETED, this::locationDeleted);
trace.addListener(this);
}

8
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/control/DebuggerControlPlugin.java
View file

@ -49,10 +49,10 @@ import ghidra.framework.plugintool.util.PluginStatus;
import ghidra.program.model.address.Address;
import ghidra.program.model.listing.Program;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceObjectChangeType;
import ghidra.trace.model.target.TraceObjectValue;
import ghidra.trace.model.time.schedule.Scheduler;
import ghidra.trace.model.time.schedule.TraceSchedule;
import ghidra.trace.util.TraceEvents;
import ghidra.util.Msg;
import ghidra.util.Swing;
import ghidra.util.exception.CancelledException;
@ -78,9 +78,9 @@ public class DebuggerControlPlugin extends AbstractDebuggerPlugin
private final TraceDomainObjectListener listenerForObjects = new TraceDomainObjectListener() {
{
listenFor(TraceObjectChangeType.VALUE_CREATED, this::valueChanged);
listenFor(TraceObjectChangeType.VALUE_DELETED, this::valueChanged);
listenFor(TraceObjectChangeType.VALUE_LIFESPAN_CHANGED, this::valueLifespanChanged);
listenFor(TraceEvents.VALUE_CREATED, this::valueChanged);
listenFor(TraceEvents.VALUE_DELETED, this::valueChanged);
listenFor(TraceEvents.VALUE_LIFESPAN_CHANGED, this::valueLifespanChanged);
}
private void valueChanged(TraceObjectValue value) {

10
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/memory/DebuggerLegacyRegionsPanel.java
View file

@ -42,9 +42,9 @@ import ghidra.program.model.address.Address;
import ghidra.program.model.address.AddressSet;
import ghidra.program.util.ProgramSelection;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceMemoryRegionChangeType;
import ghidra.trace.model.memory.TraceMemoryManager;
import ghidra.trace.model.memory.TraceMemoryRegion;
import ghidra.trace.util.TraceEvents;
import ghidra.util.database.ObjectKey;
import ghidra.util.table.GhidraTable;
import ghidra.util.table.GhidraTableFilterPanel;
@ -143,10 +143,10 @@ public class DebuggerLegacyRegionsPanel extends JPanel {
public RegionsListener() {
listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored());
listenFor(TraceMemoryRegionChangeType.ADDED, this::regionAdded);
listenFor(TraceMemoryRegionChangeType.CHANGED, this::regionChanged);
listenFor(TraceMemoryRegionChangeType.LIFESPAN_CHANGED, this::regionChanged);
listenFor(TraceMemoryRegionChangeType.DELETED, this::regionDeleted);
listenFor(TraceEvents.REGION_ADDED, this::regionAdded);
listenFor(TraceEvents.REGION_CHANGED, this::regionChanged);
listenFor(TraceEvents.REGION_LIFESPAN_CHANGED, this::regionChanged);
listenFor(TraceEvents.REGION_DELETED, this::regionDeleted);
}
private void objectRestored() {

4
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/memory/DebuggerMemoryBytesProvider.java
View file

@ -55,10 +55,10 @@ import ghidra.program.model.mem.MemoryBlock;
import ghidra.program.util.ProgramLocation;
import ghidra.program.util.ProgramSelection;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceMemoryBytesChangeType;
import ghidra.trace.model.TraceDomainObjectListener;
import ghidra.trace.model.program.TraceProgramView;
import ghidra.trace.util.TraceAddressSpace;
import ghidra.trace.util.TraceEvents;
import ghidra.util.Swing;
public class DebuggerMemoryBytesProvider extends ProgramByteViewerComponentProvider {
@ -88,7 +88,7 @@ public class DebuggerMemoryBytesProvider extends ProgramByteViewerComponentProvi
protected class ListenerForChanges extends TraceDomainObjectListener {
public ListenerForChanges() {
listenFor(TraceMemoryBytesChangeType.CHANGED, this::bytesChanged);
listenFor(TraceEvents.BYTES_CHANGED, this::bytesChanged);
}
private void bytesChanged(TraceAddressSpace space) {

42
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/memview/DebuggerMemviewTraceListener.java
View file

@ -22,7 +22,6 @@ import ghidra.async.AsyncTimer;
import ghidra.debug.api.tracemgr.DebuggerCoordinates;
import ghidra.program.model.address.*;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.*;
import ghidra.trace.model.breakpoint.TraceBreakpoint;
import ghidra.trace.model.breakpoint.TraceBreakpointManager;
import ghidra.trace.model.memory.TraceMemoryManager;
@ -30,6 +29,7 @@ import ghidra.trace.model.memory.TraceMemoryRegion;
import ghidra.trace.model.modules.*;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.model.thread.TraceThreadManager;
import ghidra.trace.util.TraceEvents;
import ghidra.util.Swing;
public class DebuggerMemviewTraceListener extends TraceDomainObjectListener {
@ -55,31 +55,31 @@ public class DebuggerMemviewTraceListener extends TraceDomainObjectListener {
updateLabelDebouncer.addListener(__ -> Swing.runIfSwingOrRunLater(() -> doUpdate()));
listenFor(TraceThreadChangeType.ADDED, this::threadChanged);
listenFor(TraceThreadChangeType.CHANGED, this::threadChanged);
listenFor(TraceThreadChangeType.LIFESPAN_CHANGED, this::threadChanged);
listenFor(TraceThreadChangeType.DELETED, this::threadChanged);
listenFor(TraceEvents.THREAD_ADDED, this::threadChanged);
listenFor(TraceEvents.THREAD_CHANGED, this::threadChanged);
listenFor(TraceEvents.THREAD_LIFESPAN_CHANGED, this::threadChanged);
listenFor(TraceEvents.THREAD_DELETED, this::threadChanged);
listenFor(TraceMemoryRegionChangeType.ADDED, this::regionChanged);
listenFor(TraceMemoryRegionChangeType.CHANGED, this::regionChanged);
listenFor(TraceMemoryRegionChangeType.LIFESPAN_CHANGED, this::regionChanged);
listenFor(TraceMemoryRegionChangeType.DELETED, this::regionChanged);
listenFor(TraceEvents.REGION_ADDED, this::regionChanged);
listenFor(TraceEvents.REGION_CHANGED, this::regionChanged);
listenFor(TraceEvents.REGION_LIFESPAN_CHANGED, this::regionChanged);
listenFor(TraceEvents.REGION_DELETED, this::regionChanged);
listenFor(TraceModuleChangeType.ADDED, this::moduleChanged);
listenFor(TraceModuleChangeType.CHANGED, this::moduleChanged);
listenFor(TraceModuleChangeType.LIFESPAN_CHANGED, this::moduleChanged);
listenFor(TraceModuleChangeType.DELETED, this::moduleChanged);
listenFor(TraceEvents.MODULE_ADDED, this::moduleChanged);
listenFor(TraceEvents.MODULE_CHANGED, this::moduleChanged);
listenFor(TraceEvents.MODULE_LIFESPAN_CHANGED, this::moduleChanged);
listenFor(TraceEvents.MODULE_DELETED, this::moduleChanged);
listenFor(TraceSectionChangeType.ADDED, this::sectionChanged);
listenFor(TraceSectionChangeType.CHANGED, this::sectionChanged);
listenFor(TraceSectionChangeType.DELETED, this::sectionChanged);
listenFor(TraceEvents.SECTION_ADDED, this::sectionChanged);
listenFor(TraceEvents.SECTION_CHANGED, this::sectionChanged);
listenFor(TraceEvents.SECTION_DELETED, this::sectionChanged);
listenFor(TraceBreakpointChangeType.ADDED, this::breakpointChanged);
listenFor(TraceBreakpointChangeType.CHANGED, this::breakpointChanged);
listenFor(TraceBreakpointChangeType.LIFESPAN_CHANGED, this::breakpointChanged);
listenFor(TraceBreakpointChangeType.DELETED, this::breakpointChanged);
listenFor(TraceEvents.BREAKPOINT_ADDED, this::breakpointChanged);
listenFor(TraceEvents.BREAKPOINT_CHANGED, this::breakpointChanged);
listenFor(TraceEvents.BREAKPOINT_LIFESPAN_CHANGED, this::breakpointChanged);
listenFor(TraceEvents.BREAKPOINT_DELETED, this::breakpointChanged);
listenFor(TraceMemoryBytesChangeType.CHANGED, this::bytesChanged);
listenFor(TraceEvents.BYTES_CHANGED, this::bytesChanged);
}
public MemviewProvider getProvider() {

15
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/model/AbstractQueryTableModel.java
View file

@ -22,14 +22,13 @@ import java.util.stream.Stream;
import docking.widgets.table.RangeCursorTableHeaderRenderer.SeekListener;
import docking.widgets.table.threaded.ThreadedTableModel;
import ghidra.framework.model.DomainObjectEvent;
import ghidra.framework.model.DomainObjectChangeRecord;
import ghidra.framework.model.DomainObjectEvent;
import ghidra.framework.plugintool.Plugin;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceObjectChangeType;
import ghidra.trace.model.Trace.TraceSnapshotChangeType;
import ghidra.trace.model.target.TraceObject;
import ghidra.trace.model.target.TraceObjectValue;
import ghidra.trace.util.TraceEvents;
import ghidra.util.datastruct.Accumulator;
import ghidra.util.exception.CancelledException;
import ghidra.util.task.TaskMonitor;
@ -40,12 +39,12 @@ public abstract class AbstractQueryTableModel<T> extends ThreadedTableModel<T, T
protected class ListenerForChanges extends TraceDomainObjectListener {
public ListenerForChanges() {
listenForUntyped(DomainObjectEvent.RESTORED, this::objectRestored);
listenFor(TraceObjectChangeType.VALUE_CREATED, this::valueCreated);
listenFor(TraceObjectChangeType.VALUE_DELETED, this::valueDeleted);
listenFor(TraceObjectChangeType.VALUE_LIFESPAN_CHANGED, this::valueLifespanChanged);
listenFor(TraceEvents.VALUE_CREATED, this::valueCreated);
listenFor(TraceEvents.VALUE_DELETED, this::valueDeleted);
listenFor(TraceEvents.VALUE_LIFESPAN_CHANGED, this::valueLifespanChanged);
listenFor(TraceSnapshotChangeType.ADDED, this::maxSnapChanged);
listenFor(TraceSnapshotChangeType.DELETED, this::maxSnapChanged);
listenFor(TraceEvents.SNAPSHOT_ADDED, this::maxSnapChanged);
listenFor(TraceEvents.SNAPSHOT_DELETED, this::maxSnapChanged);
}
protected void objectRestored(DomainObjectChangeRecord record) {

10
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/model/ObjectTreeModel.java
View file

@ -27,8 +27,8 @@ import ghidra.dbg.target.*;
import ghidra.dbg.util.PathUtils.TargetObjectKeyComparator;
import ghidra.framework.model.*;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceObjectChangeType;
import ghidra.trace.model.target.*;
import ghidra.trace.util.TraceEvents;
import ghidra.util.HTMLUtilities;
import ghidra.util.LockHold;
import ghidra.util.datastruct.WeakValueHashMap;
@ -40,10 +40,10 @@ public class ObjectTreeModel implements DisplaysModified {
implements DomainObjectClosedListener {
public ListenerForChanges() {
listenForUntyped(DomainObjectEvent.RESTORED, this::domainObjectRestored);
listenFor(TraceObjectChangeType.CREATED, this::objectCreated);
listenFor(TraceObjectChangeType.VALUE_CREATED, this::valueCreated);
listenFor(TraceObjectChangeType.VALUE_DELETED, this::valueDeleted);
listenFor(TraceObjectChangeType.VALUE_LIFESPAN_CHANGED, this::valueLifespanChanged);
listenFor(TraceEvents.OBJECT_CREATED, this::objectCreated);
listenFor(TraceEvents.VALUE_CREATED, this::valueCreated);
listenFor(TraceEvents.VALUE_DELETED, this::valueDeleted);
listenFor(TraceEvents.VALUE_LIFESPAN_CHANGED, this::valueLifespanChanged);
}
@Override

10
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/modules/DebuggerLegacyModulesPanel.java
View file

@ -36,8 +36,8 @@ import ghidra.framework.model.DomainObjectEvent;
import ghidra.framework.plugintool.PluginTool;
import ghidra.program.model.address.*;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceModuleChangeType;
import ghidra.trace.model.modules.*;
import ghidra.trace.util.TraceEvents;
import ghidra.util.database.ObjectKey;
import ghidra.util.table.GhidraTable;
import ghidra.util.table.GhidraTableFilterPanel;
@ -159,10 +159,10 @@ public class DebuggerLegacyModulesPanel extends JPanel {
public ModulesListener() {
listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored());
listenFor(TraceModuleChangeType.ADDED, this::moduleAdded);
listenFor(TraceModuleChangeType.CHANGED, this::moduleChanged);
listenFor(TraceModuleChangeType.LIFESPAN_CHANGED, this::moduleChanged);
listenFor(TraceModuleChangeType.DELETED, this::moduleDeleted);
listenFor(TraceEvents.MODULE_ADDED, this::moduleAdded);
listenFor(TraceEvents.MODULE_CHANGED, this::moduleChanged);
listenFor(TraceEvents.MODULE_LIFESPAN_CHANGED, this::moduleChanged);
listenFor(TraceEvents.MODULE_DELETED, this::moduleDeleted);
}
private void objectRestored() {

15
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/modules/DebuggerLegacySectionsPanel.java
View file

@ -37,10 +37,9 @@ import ghidra.framework.model.DomainObjectEvent;
import ghidra.framework.plugintool.PluginTool;
import ghidra.program.model.address.*;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceModuleChangeType;
import ghidra.trace.model.Trace.TraceSectionChangeType;
import ghidra.trace.model.TraceDomainObjectListener;
import ghidra.trace.model.modules.*;
import ghidra.trace.util.TraceEvents;
import ghidra.util.database.ObjectKey;
import ghidra.util.table.GhidraTable;
import ghidra.util.table.GhidraTableFilterPanel;
@ -146,13 +145,13 @@ public class DebuggerLegacySectionsPanel extends JPanel {
* NOTE: No need for Module.ADDED here. A TraceModule is created empty, so when each
* section is added, we'll get the call.
*/
listenFor(TraceModuleChangeType.CHANGED, this::moduleChanged);
listenFor(TraceModuleChangeType.LIFESPAN_CHANGED, this::moduleChanged);
listenFor(TraceModuleChangeType.DELETED, this::moduleDeleted);
listenFor(TraceEvents.MODULE_CHANGED, this::moduleChanged);
listenFor(TraceEvents.MODULE_LIFESPAN_CHANGED, this::moduleChanged);
listenFor(TraceEvents.MODULE_DELETED, this::moduleDeleted);
listenFor(TraceSectionChangeType.ADDED, this::sectionAdded);
listenFor(TraceSectionChangeType.CHANGED, this::sectionChanged);
listenFor(TraceSectionChangeType.DELETED, this::sectionDeleted);
listenFor(TraceEvents.SECTION_ADDED, this::sectionAdded);
listenFor(TraceEvents.SECTION_CHANGED, this::sectionChanged);
listenFor(TraceEvents.SECTION_DELETED, this::sectionDeleted);
}
private void objectRestored() {

10
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/modules/DebuggerModulesProvider.java
View file

@ -64,9 +64,9 @@ import ghidra.program.model.mem.MemoryBlock;
import ghidra.program.util.ProgramLocation;
import ghidra.program.util.ProgramSelection;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceMemoryBytesChangeType;
import ghidra.trace.model.modules.*;
import ghidra.trace.util.TraceChangeType;
import ghidra.trace.util.TraceEvent;
import ghidra.trace.util.TraceEvents;
import ghidra.util.HelpLocation;
import ghidra.util.Msg;
@ -271,12 +271,12 @@ public class DebuggerModulesProvider extends ComponentProviderAdapter {
protected class ForMappingTraceListener extends TraceDomainObjectListener {
public ForMappingTraceListener(AutoMapSpec spec) {
for (TraceChangeType<?, ?> type : spec.getChangeTypes()) {
for (TraceEvent<?, ?> type : spec.getChangeTypes()) {
listenFor(type, this::changed);
}
// TODO: Delete this if/when TraceRecorderTarget is removed
listenFor(TraceMemoryBytesChangeType.CHANGED, this::memoryChanged);
// Delete this if/when TraceRecorderTarget is removed
listenFor(TraceEvents.BYTES_CHANGED, this::memoryChanged);
}
private void changed() {

6
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/modules/DebuggerStaticMappingProvider.java
View file

@ -48,9 +48,9 @@ import ghidra.program.model.listing.Program;
import ghidra.program.util.ProgramLocation;
import ghidra.program.util.ProgramSelection;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceStaticMappingChangeType;
import ghidra.trace.model.modules.TraceStaticMapping;
import ghidra.trace.model.modules.TraceStaticMappingManager;
import ghidra.trace.util.TraceEvents;
import ghidra.util.MathUtilities;
import ghidra.util.Msg;
import ghidra.util.database.ObjectKey;
@ -107,8 +107,8 @@ public class DebuggerStaticMappingProvider extends ComponentProviderAdapter
protected class ListenerForStaticMappingDisplay extends TraceDomainObjectListener {
public ListenerForStaticMappingDisplay() {
listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored());
listenFor(TraceStaticMappingChangeType.ADDED, this::staticMappingAdded);
listenFor(TraceStaticMappingChangeType.DELETED, this::staticMappingDeleted);
listenFor(TraceEvents.MAPPING_ADDED, this::staticMappingAdded);
listenFor(TraceEvents.MAPPING_DELETED, this::staticMappingDeleted);
}
private void objectRestored() {

22
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/register/DebuggerRegistersProvider.java
View file

@ -52,8 +52,8 @@ import ghidra.dbg.error.DebuggerModelAccessException;
import ghidra.debug.api.target.Target;
import ghidra.debug.api.tracemgr.DebuggerCoordinates;
import ghidra.docking.settings.*;
import ghidra.framework.model.DomainObjectEvent;
import ghidra.framework.model.DomainObjectChangeRecord;
import ghidra.framework.model.DomainObjectEvent;
import ghidra.framework.options.AutoOptions;
import ghidra.framework.options.SaveState;
import ghidra.framework.plugintool.*;
@ -64,15 +64,13 @@ import ghidra.program.model.lang.*;
import ghidra.program.model.listing.Data;
import ghidra.program.model.util.CodeUnitInsertionException;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.*;
import ghidra.trace.model.guest.TracePlatform;
import ghidra.trace.model.listing.*;
import ghidra.trace.model.memory.*;
import ghidra.trace.model.program.TraceProgramView;
import ghidra.trace.model.target.TraceObject;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceAddressSpace;
import ghidra.trace.util.TraceRegisterUtils;
import ghidra.trace.util.*;
import ghidra.util.HelpLocation;
import ghidra.util.Msg;
import ghidra.util.classfinder.ClassSearcher;
@ -274,14 +272,14 @@ public class DebuggerRegistersProvider extends ComponentProviderAdapter
class TraceChangeListener extends TraceDomainObjectListener {
public TraceChangeListener() {
listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored(e));
listenFor(TraceMemoryBytesChangeType.CHANGED, this::registerValueChanged);
listenFor(TraceMemoryStateChangeType.CHANGED, this::registerStateChanged);
listenFor(TraceCodeChangeType.ADDED, this::registerTypeAdded);
listenFor(TraceCodeChangeType.DATA_TYPE_REPLACED, this::registerTypeReplaced);
listenFor(TraceCodeChangeType.LIFESPAN_CHANGED, this::registerTypeLifespanChanged);
listenFor(TraceCodeChangeType.REMOVED, this::registerTypeRemoved);
listenFor(TraceThreadChangeType.DELETED, this::threadDeleted);
listenFor(TraceThreadChangeType.LIFESPAN_CHANGED, this::threadDestroyed);
listenFor(TraceEvents.BYTES_CHANGED, this::registerValueChanged);
listenFor(TraceEvents.BYTES_STATE_CHANGED, this::registerStateChanged);
listenFor(TraceEvents.CODE_ADDED, this::registerTypeAdded);
listenFor(TraceEvents.CODE_DATA_TYPE_REPLACED, this::registerTypeReplaced);
listenFor(TraceEvents.CODE_LIFESPAN_CHANGED, this::registerTypeLifespanChanged);
listenFor(TraceEvents.CODE_REMOVED, this::registerTypeRemoved);
listenFor(TraceEvents.THREAD_DELETED, this::threadDeleted);
listenFor(TraceEvents.THREAD_LIFESPAN_CHANGED, this::threadDestroyed);
}
private boolean isVisibleObjectsMode(AddressSpace space) {

2
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/register/RegisterRow.java
View file

@ -170,7 +170,7 @@ public class RegisterRow {
/**
* Check if the register's value can be set via its data type's representation
*
* @return
* @return true if the representation cell is editable
*/
public boolean isRepresentationEditable() {
return provider.canWriteRegisterRepresentation(register);

13
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/stack/DebuggerLegacyStackPanel.java
View file

@ -39,15 +39,12 @@ import ghidra.program.model.lang.Register;
import ghidra.program.model.lang.RegisterValue;
import ghidra.program.model.listing.Program;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceMemoryBytesChangeType;
import ghidra.trace.model.Trace.TraceStackChangeType;
import ghidra.trace.model.memory.TraceMemorySpace;
import ghidra.trace.model.program.TraceProgramView;
import ghidra.trace.model.stack.TraceStack;
import ghidra.trace.model.stack.TraceStackFrame;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceAddressSpace;
import ghidra.trace.util.TraceRegisterUtils;
import ghidra.trace.util.*;
import ghidra.util.Swing;
import ghidra.util.table.GhidraTable;
import ghidra.util.table.GhidraTableFilterPanel;
@ -124,11 +121,11 @@ public class DebuggerLegacyStackPanel extends JPanel {
class ForStackListener extends TraceDomainObjectListener {
public ForStackListener() {
listenFor(TraceStackChangeType.ADDED, this::stackAdded);
listenFor(TraceStackChangeType.CHANGED, this::stackChanged);
listenFor(TraceStackChangeType.DELETED, this::stackDeleted);
listenFor(TraceEvents.STACK_ADDED, this::stackAdded);
listenFor(TraceEvents.STACK_CHANGED, this::stackChanged);
listenFor(TraceEvents.STACK_DELETED, this::stackDeleted);
listenFor(TraceMemoryBytesChangeType.CHANGED, this::bytesChanged);
listenFor(TraceEvents.BYTES_CHANGED, this::bytesChanged);
}
private void stackAdded(TraceStack stack) {

8
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/stack/vars/VariableValueUtils.java
View file

@ -40,7 +40,6 @@ import ghidra.program.model.mem.ByteMemBufferImpl;
import ghidra.program.model.mem.Memory;
import ghidra.program.model.pcode.*;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceMemoryBytesChangeType;
import ghidra.trace.model.guest.TracePlatform;
import ghidra.trace.model.listing.*;
import ghidra.trace.model.memory.*;
@ -48,6 +47,7 @@ import ghidra.trace.model.stack.TraceStack;
import ghidra.trace.model.stack.TraceStackFrame;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceAddressSpace;
import ghidra.trace.util.TraceEvents;
import ghidra.util.MathUtilities;
import ghidra.util.Msg;
import ghidra.util.exception.InvalidInputException;
@ -650,7 +650,7 @@ public enum VariableValueUtils {
*/
private class ListenerForChanges extends TraceDomainObjectListener {
public ListenerForChanges() {
listenFor(TraceMemoryBytesChangeType.CHANGED, this::bytesChanged);
listenFor(TraceEvents.BYTES_CHANGED, this::bytesChanged);
}
private void bytesChanged(TraceAddressSpace space, TraceAddressSnapRange range) {
@ -826,8 +826,8 @@ public enum VariableValueUtils {
* data unit using {@link #getRegisterUnit(Register)}. Fall back to this method only if that
* one fails.
*
* @param register
* @return
* @param register the register
* @return the "raw" value of the register
*/
public WatchValue getRawRegisterValue(Register register) {
WatchValuePcodeExecutorState state =

17
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/thread/DebuggerLegacyThreadsPanel.java
View file

@ -33,16 +33,15 @@ import ghidra.app.plugin.core.debug.gui.DebuggerSnapActionContext;
import ghidra.app.services.DebuggerTraceManagerService;
import ghidra.debug.api.tracemgr.DebuggerCoordinates;
import ghidra.docking.settings.Settings;
import ghidra.framework.model.DomainObjectEvent;
import ghidra.framework.model.DomainObjectChangeRecord;
import ghidra.framework.model.DomainObjectEvent;
import ghidra.framework.plugintool.AutoService;
import ghidra.framework.plugintool.annotation.AutoServiceConsumed;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceSnapshotChangeType;
import ghidra.trace.model.Trace.TraceThreadChangeType;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.model.thread.TraceThreadManager;
import ghidra.trace.model.time.TraceSnapshot;
import ghidra.trace.util.TraceEvents;
import ghidra.util.database.ObjectKey;
import ghidra.util.table.GhidraTable;
import ghidra.util.table.GhidraTableFilterPanel;
@ -128,13 +127,13 @@ public class DebuggerLegacyThreadsPanel extends JPanel {
public ForThreadsListener() {
listenForUntyped(DomainObjectEvent.RESTORED, this::objectRestored);
listenFor(TraceThreadChangeType.ADDED, this::threadAdded);
listenFor(TraceThreadChangeType.CHANGED, this::threadChanged);
listenFor(TraceThreadChangeType.LIFESPAN_CHANGED, this::threadChanged);
listenFor(TraceThreadChangeType.DELETED, this::threadDeleted);
listenFor(TraceEvents.THREAD_ADDED, this::threadAdded);
listenFor(TraceEvents.THREAD_CHANGED, this::threadChanged);
listenFor(TraceEvents.THREAD_LIFESPAN_CHANGED, this::threadChanged);
listenFor(TraceEvents.THREAD_DELETED, this::threadDeleted);
listenFor(TraceSnapshotChangeType.ADDED, this::snapAdded);
listenFor(TraceSnapshotChangeType.DELETED, this::snapDeleted);
listenFor(TraceEvents.SNAPSHOT_ADDED, this::snapAdded);
listenFor(TraceEvents.SNAPSHOT_DELETED, this::snapDeleted);
}
private void objectRestored(DomainObjectChangeRecord rec) {

8
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/thread/DebuggerThreadsProvider.java
View file

@ -33,15 +33,15 @@ import ghidra.app.plugin.core.debug.gui.DebuggerResources.ToToggleSelectionListe
import ghidra.app.services.*;
import ghidra.app.services.DebuggerTraceManagerService.BooleanChangeAdapter;
import ghidra.debug.api.tracemgr.DebuggerCoordinates;
import ghidra.framework.model.DomainObjectEvent;
import ghidra.framework.model.DomainObjectChangeRecord;
import ghidra.framework.model.DomainObjectEvent;
import ghidra.framework.plugintool.AutoService;
import ghidra.framework.plugintool.ComponentProviderAdapter;
import ghidra.framework.plugintool.annotation.AutoServiceConsumed;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceSnapshotChangeType;
import ghidra.trace.model.TraceDomainObjectListener;
import ghidra.trace.model.time.TraceSnapshot;
import ghidra.trace.util.TraceEvents;
public class DebuggerThreadsProvider extends ComponentProviderAdapter {
@ -67,8 +67,8 @@ public class DebuggerThreadsProvider extends ComponentProviderAdapter {
public ForSnapsListener() {
listenForUntyped(DomainObjectEvent.RESTORED, this::objectRestored);
listenFor(TraceSnapshotChangeType.ADDED, this::snapAdded);
listenFor(TraceSnapshotChangeType.DELETED, this::snapDeleted);
listenFor(TraceEvents.SNAPSHOT_ADDED, this::snapAdded);
listenFor(TraceEvents.SNAPSHOT_DELETED, this::snapDeleted);
}
private void setTrace(Trace trace) {

8
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/time/DebuggerSnapshotTablePanel.java
View file

@ -31,10 +31,10 @@ import ghidra.docking.settings.Settings;
import ghidra.framework.model.DomainObjectEvent;
import ghidra.framework.plugintool.PluginTool;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceSnapshotChangeType;
import ghidra.trace.model.TraceDomainObjectListener;
import ghidra.trace.model.time.TraceSnapshot;
import ghidra.trace.model.time.TraceTimeManager;
import ghidra.trace.util.TraceEvents;
import ghidra.util.table.GhidraTableFilterPanel;
import ghidra.util.table.column.AbstractGColumnRenderer;
@ -96,9 +96,9 @@ public class DebuggerSnapshotTablePanel extends JPanel {
public SnapshotListener() {
listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored());
listenFor(TraceSnapshotChangeType.ADDED, this::snapAdded);
listenFor(TraceSnapshotChangeType.CHANGED, this::snapChanged);
listenFor(TraceSnapshotChangeType.DELETED, this::snapDeleted);
listenFor(TraceEvents.SNAPSHOT_ADDED, this::snapAdded);
listenFor(TraceEvents.SNAPSHOT_CHANGED, this::snapChanged);
listenFor(TraceEvents.SNAPSHOT_DELETED, this::snapDeleted);
}
private void objectRestored() {

9
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/gui/watch/DebuggerWatchesProvider.java
View file

@ -56,8 +56,8 @@ import ghidra.base.widgets.table.DataTypeTableCellEditor;
import ghidra.debug.api.tracemgr.DebuggerCoordinates;
import ghidra.debug.api.watch.WatchRow;
import ghidra.docking.settings.*;
import ghidra.framework.model.DomainObjectEvent;
import ghidra.framework.model.DomainObjectChangeRecord;
import ghidra.framework.model.DomainObjectEvent;
import ghidra.framework.options.SaveState;
import ghidra.framework.plugintool.*;
import ghidra.framework.plugintool.annotation.AutoServiceConsumed;
@ -75,12 +75,11 @@ import ghidra.program.model.util.CodeUnitInsertionException;
import ghidra.program.util.ProgramLocation;
import ghidra.program.util.ProgramSelection;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceMemoryBytesChangeType;
import ghidra.trace.model.Trace.TraceMemoryStateChangeType;
import ghidra.trace.model.guest.TracePlatform;
import ghidra.trace.model.program.TraceProgramView;
import ghidra.trace.model.time.schedule.TraceSchedule;
import ghidra.trace.util.TraceAddressSpace;
import ghidra.trace.util.TraceEvents;
import ghidra.util.HelpLocation;
import ghidra.util.Msg;
import ghidra.util.exception.CancelledException;
@ -247,8 +246,8 @@ public class DebuggerWatchesProvider extends ComponentProviderAdapter
class ForDepsListener extends TraceDomainObjectListener {
public ForDepsListener() {
listenForUntyped(DomainObjectEvent.RESTORED, this::objectRestored);
listenFor(TraceMemoryBytesChangeType.CHANGED, this::bytesChanged);
listenFor(TraceMemoryStateChangeType.CHANGED, this::stateChanged);
listenFor(TraceEvents.BYTES_CHANGED, this::bytesChanged);
listenFor(TraceEvents.BYTES_STATE_CHANGED, this::stateChanged);
}
private void objectRestored(DomainObjectChangeRecord rec) {

10
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/breakpoint/DebuggerLogicalBreakpointServicePlugin.java
View file

@ -49,11 +49,11 @@ import ghidra.program.model.address.AddressRange;
import ghidra.program.model.listing.*;
import ghidra.program.util.*;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceBreakpointChangeType;
import ghidra.trace.model.breakpoint.TraceBreakpoint;
import ghidra.trace.model.breakpoint.TraceBreakpointKind;
import ghidra.trace.model.program.TraceProgramView;
import ghidra.trace.util.TraceAddressSpace;
import ghidra.trace.util.TraceEvents;
import ghidra.util.Msg;
import ghidra.util.datastruct.ListenerSet;
@ -198,10 +198,10 @@ public class DebuggerLogicalBreakpointServicePlugin extends Plugin
this.info = info;
listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored());
listenFor(TraceBreakpointChangeType.ADDED, this::breakpointAdded);
listenFor(TraceBreakpointChangeType.CHANGED, this::breakpointChanged);
listenFor(TraceBreakpointChangeType.LIFESPAN_CHANGED, this::breakpointLifespanChanged);
listenFor(TraceBreakpointChangeType.DELETED, this::breakpointDeleted);
listenFor(TraceEvents.BREAKPOINT_ADDED, this::breakpointAdded);
listenFor(TraceEvents.BREAKPOINT_CHANGED, this::breakpointChanged);
listenFor(TraceEvents.BREAKPOINT_LIFESPAN_CHANGED, this::breakpointLifespanChanged);
listenFor(TraceEvents.BREAKPOINT_DELETED, this::breakpointDeleted);
}
@Override

6
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/modules/DebuggerStaticMappingServicePlugin.java
View file

@ -51,10 +51,10 @@ import ghidra.program.model.listing.Program;
import ghidra.program.model.mem.MemoryBlock;
import ghidra.program.util.ProgramLocation;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceStaticMappingChangeType;
import ghidra.trace.model.memory.TraceMemoryRegion;
import ghidra.trace.model.modules.*;
import ghidra.trace.model.program.TraceProgramView;
import ghidra.trace.util.TraceEvents;
import ghidra.util.Msg;
import ghidra.util.datastruct.ListenerSet;
import ghidra.util.exception.CancelledException;
@ -222,8 +222,8 @@ public class DebuggerStaticMappingServicePlugin extends Plugin
this.trace = trace;
listenForUntyped(DomainObjectEvent.RESTORED, e -> objectRestored());
listenFor(TraceStaticMappingChangeType.ADDED, this::staticMappingAdded);
listenFor(TraceStaticMappingChangeType.DELETED, this::staticMappingDeleted);
listenFor(TraceEvents.MAPPING_ADDED, this::staticMappingAdded);
listenFor(TraceEvents.MAPPING_DELETED, this::staticMappingDeleted);
trace.addListener(this);

9
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/tracemgr/DebuggerTraceManagerServicePlugin.java
View file

@ -52,8 +52,6 @@ import ghidra.framework.plugintool.annotation.AutoServiceConsumed;
import ghidra.framework.plugintool.util.PluginStatus;
import ghidra.lifecycle.Internal;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceObjectChangeType;
import ghidra.trace.model.Trace.TraceThreadChangeType;
import ghidra.trace.model.guest.TracePlatform;
import ghidra.trace.model.program.TraceProgramView;
import ghidra.trace.model.program.TraceVariableSnapProgramView;
@ -62,6 +60,7 @@ import ghidra.trace.model.target.TraceObjectKeyPath;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.model.time.TraceSnapshot;
import ghidra.trace.model.time.schedule.TraceSchedule;
import ghidra.trace.util.TraceEvents;
import ghidra.util.*;
import ghidra.util.database.DomainObjectLockHold;
import ghidra.util.exception.*;
@ -107,9 +106,9 @@ public class DebuggerTraceManagerServicePlugin extends Plugin
public ListenerForTraceChanges(Trace trace) {
this.trace = trace;
listenFor(TraceThreadChangeType.ADDED, this::threadAdded);
listenFor(TraceThreadChangeType.DELETED, this::threadDeleted);
listenFor(TraceObjectChangeType.CREATED, this::objectCreated);
listenFor(TraceEvents.THREAD_ADDED, this::threadAdded);
listenFor(TraceEvents.THREAD_DELETED, this::threadDeleted);
listenFor(TraceEvents.OBJECT_CREATED, this::objectCreated);
}
private void threadAdded(TraceThread thread) {

4
Ghidra/Debug/Debugger/src/test/java/ghidra/app/plugin/core/debug/gui/AbstractGhidraHeadedDebuggerTest.java
View file

@ -77,10 +77,10 @@ import ghidra.test.AbstractGhidraHeadedIntegrationTest;
import ghidra.test.TestEnv;
import ghidra.trace.database.ToyDBTraceBuilder;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceMemoryBytesChangeType;
import ghidra.trace.model.memory.TraceMemorySpace;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceAddressSpace;
import ghidra.trace.util.TraceEvents;
import ghidra.util.InvalidNameException;
import ghidra.util.datastruct.TestDataStructureErrorHandlerInstaller;
import ghidra.util.exception.CancelledException;
@ -820,7 +820,7 @@ public abstract class AbstractGhidraHeadedDebuggerTest
TraceDomainObjectListener listener = new TraceDomainObjectListener() {
{
listenFor(TraceMemoryBytesChangeType.CHANGED, this::bytesChanged);
listenFor(TraceEvents.BYTES_CHANGED, this::bytesChanged);
}
void bytesChanged(TraceAddressSpace space, TraceAddressSnapRange range, byte[] oldValue,

8
Ghidra/Debug/Debugger/src/test/java/ghidra/app/plugin/core/debug/gui/pcode/DebuggerPcodeStepperProviderTest.java
View file

@ -17,6 +17,7 @@ package ghidra.app.plugin.core.debug.gui.pcode;
import static org.junit.Assert.*;
import java.awt.Color;
import java.lang.invoke.MethodHandles;
import java.util.List;
@ -25,12 +26,14 @@ import org.junit.Test;
import db.Transaction;
import generic.Unique;
import generic.theme.*;
import ghidra.app.plugin.assembler.Assembler;
import ghidra.app.plugin.assembler.Assemblers;
import ghidra.app.plugin.core.debug.gui.AbstractGhidraHeadedDebuggerTest;
import ghidra.app.plugin.core.debug.gui.listing.DebuggerListingPlugin;
import ghidra.app.plugin.core.debug.gui.pcode.DebuggerPcodeStepperProvider.PcodeRowHtmlFormatter;
import ghidra.app.plugin.core.debug.service.emulation.*;
import ghidra.app.plugin.core.debug.service.emulation.BytesDebuggerPcodeEmulator;
import ghidra.app.plugin.core.debug.service.emulation.BytesDebuggerPcodeEmulatorFactory;
import ghidra.app.plugin.core.debug.service.tracemgr.DebuggerTraceManagerServicePlugin;
import ghidra.app.plugin.processors.sleigh.SleighLanguage;
import ghidra.app.services.DebuggerEmulationService;
@ -63,6 +66,9 @@ public class DebuggerPcodeStepperProviderTest extends AbstractGhidraHeadedDebugg
@Before
public void setUpPcodeStepperProviderTest() throws Exception {
ThemeManager themeManager = ApplicationThemeManager.getInstance();
themeManager.setColor("color.fg.listing.pcode.label", new Color(0, 0, 255));
traceManager = addPlugin(tool, DebuggerTraceManagerServicePlugin.class);
pcodePlugin = addPlugin(tool, DebuggerPcodeStepperPlugin.class);
listingPlugin = addPlugin(tool, DebuggerListingPlugin.class); // For colors

28
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/DBTrace.java
View file

@ -59,10 +59,9 @@ import ghidra.trace.model.memory.TraceMemoryRegion;
import ghidra.trace.model.program.TraceProgramView;
import ghidra.trace.model.property.TraceAddressPropertyManager;
import ghidra.trace.model.time.TraceSnapshot;
import ghidra.trace.util.*;
import ghidra.trace.util.CopyOnWrite.WeakHashCowSet;
import ghidra.trace.util.CopyOnWrite.WeakValueHashCowMap;
import ghidra.trace.util.TraceChangeManager;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.util.*;
import ghidra.util.database.*;
import ghidra.util.datastruct.ListenerSet;
@ -658,7 +657,8 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
traceChangeSet.sourceArchiveChanged(sourceArchiveID.getValue());
}
setChanged(
new TraceChangeRecord<>(TraceSourceArchiveChangeType.CHANGED, null, sourceArchiveID));
new TraceChangeRecord<>(TraceEvents.SOURCE_TYPE_ARCHIVE_CHANGED, null,
sourceArchiveID));
}
public void sourceArchiveAdded(UniversalID sourceArchiveID) {
@ -666,7 +666,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
traceChangeSet.sourceArchiveAdded(sourceArchiveID.getValue());
}
setChanged(
new TraceChangeRecord<>(TraceSourceArchiveChangeType.ADDED, null, sourceArchiveID));
new TraceChangeRecord<>(TraceEvents.SOURCE_TYPE_ARCHIVE_ADDED, null, sourceArchiveID));
}
public void dataTypeChanged(long changedID, DataType changedType) {
@ -674,7 +674,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
traceChangeSet.dataTypeChanged(changedID);
}
setChanged(
new TraceChangeRecord<>(TraceDataTypeChangeType.CHANGED, null, changedID, changedType));
new TraceChangeRecord<>(TraceEvents.DATA_TYPE_CHANGED, null, changedID, changedType));
}
public void dataTypeAdded(long addedID, DataType addedType) {
@ -682,14 +682,14 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
traceChangeSet.dataTypeAdded(addedID);
}
setChanged(
new TraceChangeRecord<>(TraceDataTypeChangeType.ADDED, null, addedID, addedType));
new TraceChangeRecord<>(TraceEvents.DATA_TYPE_ADDED, null, addedID, addedType));
}
public void dataTypeReplaced(long replacedID, DataTypePath replacedPath, DataTypePath newPath) {
if (recordChanges) {
traceChangeSet.dataTypeChanged(replacedID);
}
setChanged(new TraceChangeRecord<>(TraceDataTypeChangeType.REPLACED, null, replacedID,
setChanged(new TraceChangeRecord<>(TraceEvents.DATA_TYPE_REPLACED, null, replacedID,
replacedPath, newPath));
}
@ -697,7 +697,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
if (recordChanges) {
traceChangeSet.dataTypeChanged(movedID);
}
setChanged(new TraceChangeRecord<>(TraceDataTypeChangeType.MOVED, null, movedID, oldPath,
setChanged(new TraceChangeRecord<>(TraceEvents.DATA_TYPE_MOVED, null, movedID, oldPath,
newPath));
}
@ -705,7 +705,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
if (recordChanges) {
traceChangeSet.dataTypeChanged(renamedID);
}
setChanged(new TraceChangeRecord<>(TraceDataTypeChangeType.RENAMED, null, renamedID,
setChanged(new TraceChangeRecord<>(TraceEvents.DATA_TYPE_RENAMED, null, renamedID,
oldName, newName));
}
@ -713,7 +713,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
if (recordChanges) {
traceChangeSet.dataTypeChanged(deletedID);
}
setChanged(new TraceChangeRecord<>(TraceDataTypeChangeType.DELETED, null, deletedID,
setChanged(new TraceChangeRecord<>(TraceEvents.DATA_TYPE_DELETED, null, deletedID,
deletedPath, null));
}
@ -722,14 +722,14 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
traceChangeSet.categoryAdded(addedID);
}
setChanged(
new TraceChangeRecord<>(TraceCategoryChangeType.ADDED, null, addedID, addedCategory));
new TraceChangeRecord<>(TraceEvents.TYPE_CATEGORY_ADDED, null, addedID, addedCategory));
}
public void categoryMoved(long movedID, CategoryPath oldPath, CategoryPath newPath) {
if (recordChanges) {
traceChangeSet.categoryChanged(movedID);
}
setChanged(new TraceChangeRecord<>(TraceCategoryChangeType.MOVED, null, movedID, oldPath,
setChanged(new TraceChangeRecord<>(TraceEvents.TYPE_CATEGORY_MOVED, null, movedID, oldPath,
newPath));
}
@ -737,7 +737,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
if (recordChanges) {
traceChangeSet.categoryChanged(renamedID);
}
setChanged(new TraceChangeRecord<>(TraceCategoryChangeType.RENAMED, null, renamedID,
setChanged(new TraceChangeRecord<>(TraceEvents.TYPE_CATEGORY_RENAMED, null, renamedID,
oldName, newName));
}
@ -745,7 +745,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
if (recordChanges) {
traceChangeSet.categoryChanged(deletedID);
}
setChanged(new TraceChangeRecord<>(TraceCategoryChangeType.DELETED, null, deletedID,
setChanged(new TraceChangeRecord<>(TraceEvents.TYPE_CATEGORY_DELETED, null, deletedID,
deletedPath, null));
}

8
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/address/DBTraceOverlaySpaceAdapter.java
View file

@ -29,8 +29,8 @@ import ghidra.program.model.address.Address;
import ghidra.program.model.address.AddressSpace;
import ghidra.trace.database.DBTrace;
import ghidra.trace.database.DBTraceManager;
import ghidra.trace.model.Trace.TraceOverlaySpaceChangeType;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.*;
import ghidra.util.database.DBCachedObjectStoreFactory.AbstractDBFieldCodec;
@ -267,7 +267,7 @@ public class DBTraceOverlaySpaceAdapter implements DBTraceManager {
ent.set(space.getName(), base.getName());
trace.updateViewsAddSpaceBlock(space);
trace.setChanged(
new TraceChangeRecord<>(TraceOverlaySpaceChangeType.ADDED, null, trace, null, space));
new TraceChangeRecord<>(TraceEvents.OVERLAY_ADDED, null, trace, null, space));
return space;
}
@ -313,8 +313,8 @@ public class DBTraceOverlaySpaceAdapter implements DBTraceManager {
assert space != null;
factory.removeOverlaySpace(name);
trace.updateViewsDeleteSpaceBlock(space);
trace.setChanged(new TraceChangeRecord<>(TraceOverlaySpaceChangeType.DELETED, null,
trace, space, null));
trace.setChanged(
new TraceChangeRecord<>(TraceEvents.OVERLAY_DELETED, null, trace, space, null));
invalidateCache(true);
}
}

6
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/bookmark/DBTraceBookmark.java
View file

@ -24,11 +24,11 @@ import ghidra.trace.database.DBTraceUtils;
import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceBookmarkChangeType;
import ghidra.trace.model.bookmark.TraceBookmark;
import ghidra.trace.model.bookmark.TraceBookmarkType;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.DBCachedObjectStore;
import ghidra.util.database.DBObjectColumn;
@ -140,14 +140,14 @@ public class DBTraceBookmark extends AbstractDBTraceAddressSnapRangePropertyMapD
update(CATEGORY_COLUMN, COMMENT_COLUMN);
}
space.trace.setChanged(
new TraceChangeRecord<>(TraceBookmarkChangeType.CHANGED, space, this));
new TraceChangeRecord<>(TraceEvents.BOOKMARK_CHANGED, space, this));
}
@Override
public void delete() {
space.bookmarkMapSpace.deleteData(this);
space.trace.setChanged(
new TraceChangeRecord<>(TraceBookmarkChangeType.DELETED, space, this));
new TraceChangeRecord<>(TraceEvents.BOOKMARK_DELETED, space, this));
}
@Override

6
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/bookmark/DBTraceBookmarkManager.java
View file

@ -31,12 +31,12 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAdd
import ghidra.trace.database.space.*;
import ghidra.trace.database.thread.DBTraceThreadManager;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceBookmarkChangeType;
import ghidra.trace.model.bookmark.TraceBookmarkManager;
import ghidra.trace.model.bookmark.TraceBookmarkType;
import ghidra.trace.model.stack.TraceStackFrame;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.Msg;
import ghidra.util.database.DBOpenMode;
@ -231,7 +231,7 @@ public class DBTraceBookmarkManager extends AbstractDBTraceSpaceBasedManager<DBT
type = new DBTraceBookmarkType(this, typeName);
typesByName.put(typeName, type);
}
trace.setChanged(new TraceChangeRecord<>(TraceBookmarkChangeType.TYPE_ADDED, null, type));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.BOOKMARK_TYPE_ADDED, null, type));
return type;
}
@ -250,7 +250,7 @@ public class DBTraceBookmarkManager extends AbstractDBTraceSpaceBasedManager<DBT
type = new DBTraceBookmarkType(this, typeName, icon, color, priority);
typesByName.put(typeName, type);
}
trace.setChanged(new TraceChangeRecord<>(TraceBookmarkChangeType.TYPE_ADDED, null, type));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.BOOKMARK_TYPE_ADDED, null, type));
return type;
}

5
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/bookmark/DBTraceBookmarkSpace.java
View file

@ -25,11 +25,11 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapSpace;
import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
import ghidra.trace.database.space.DBTraceSpaceBased;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceBookmarkChangeType;
import ghidra.trace.model.bookmark.TraceBookmarkSpace;
import ghidra.trace.model.bookmark.TraceBookmarkType;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.DBCachedObjectIndex;
import ghidra.util.exception.VersionException;
@ -110,8 +110,7 @@ public class DBTraceBookmarkSpace implements TraceBookmarkSpace, DBTraceSpaceBas
try (LockHold hold = LockHold.lock(lock.writeLock())) {
DBTraceBookmark bookmark = bookmarkMapSpace.put(address, lifespan, null);
bookmark.set(type.getTypeString(), category, comment);
trace.setChanged(
new TraceChangeRecord<>(TraceBookmarkChangeType.ADDED, this, bookmark));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.BOOKMARK_ADDED, this, bookmark));
return bookmark;
}
}

39
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/breakpoint/DBTraceBreakpoint.java
View file

@ -27,11 +27,11 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
import ghidra.trace.database.thread.DBTraceThreadManager;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceBreakpointChangeType;
import ghidra.trace.model.breakpoint.TraceBreakpoint;
import ghidra.trace.model.breakpoint.TraceBreakpointKind;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.Msg;
import ghidra.util.database.DBCachedObjectStore;
@ -193,8 +193,8 @@ public class DBTraceBreakpoint
this.name = name;
update(NAME_COLUMN);
}
space.trace.setChanged(new TraceChangeRecord<>(TraceBreakpointChangeType.CHANGED,
space, this));
space.trace
.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, this));
}
@ -261,7 +261,7 @@ public class DBTraceBreakpoint
oldLifespan = lifespan;
doSetLifespan(newLifespan);
}
space.trace.setChanged(new TraceChangeRecord<>(TraceBreakpointChangeType.LIFESPAN_CHANGED,
space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_LIFESPAN_CHANGED,
space, this, oldLifespan, newLifespan));
}
@ -325,16 +325,15 @@ public class DBTraceBreakpoint
}
if (that == this) {
space.trace.setChanged(
new TraceChangeRecord<>(TraceBreakpointChangeType.CHANGED, space, this));
new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, this));
}
else {
// Yes, issue ADDED, before LIFESPAN_CHANGED, as noted in docs
space.trace
.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_ADDED, space, that));
space.trace.setChanged(
new TraceChangeRecord<>(TraceBreakpointChangeType.ADDED, space, that));
space.trace.setChanged(
new TraceChangeRecord<>(TraceBreakpointChangeType.LIFESPAN_CHANGED,
space, this, Objects.requireNonNull(oldLifespan),
Objects.requireNonNull(newLifespan)));
new TraceChangeRecord<>(TraceEvents.BREAKPOINT_LIFESPAN_CHANGED, space, this,
Objects.requireNonNull(oldLifespan), Objects.requireNonNull(newLifespan)));
}
return that;
}
@ -403,8 +402,8 @@ public class DBTraceBreakpoint
try (LockHold hold = LockHold.lock(space.lock.writeLock())) {
doSetEnabled(enabled);
}
space.trace.setChanged(new TraceChangeRecord<>(TraceBreakpointChangeType.CHANGED,
space, this));
space.trace
.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, this));
}
@Override
@ -420,8 +419,8 @@ public class DBTraceBreakpoint
try (LockHold hold = LockHold.lock(space.lock.writeLock())) {
doSetEmuEnabled(enabled);
}
space.trace.setChanged(new TraceChangeRecord<>(TraceBreakpointChangeType.CHANGED,
space, this));
space.trace
.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, this));
}
@Override
@ -437,8 +436,8 @@ public class DBTraceBreakpoint
try (LockHold hold = LockHold.lock(space.lock.writeLock())) {
doSetKinds(kinds);
}
space.trace.setChanged(
new TraceChangeRecord<>(TraceBreakpointChangeType.CHANGED, space, this));
space.trace
.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, this));
}
@Override
@ -454,8 +453,8 @@ public class DBTraceBreakpoint
this.comment = comment;
update(COMMENT_COLUMN);
}
space.trace.setChanged(new TraceChangeRecord<>(TraceBreakpointChangeType.CHANGED,
space, this));
space.trace
.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, this));
}
@Override
@ -476,8 +475,8 @@ public class DBTraceBreakpoint
}
update(SLEIGH_COLUMN);
}
space.trace.setChanged(new TraceChangeRecord<>(TraceBreakpointChangeType.CHANGED,
space, this));
space.trace
.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, this));
}
@Override

7
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/breakpoint/DBTraceBreakpointSpace.java
View file

@ -31,11 +31,11 @@ import ghidra.trace.database.thread.DBTraceThread;
import ghidra.trace.database.thread.DBTraceThreadManager;
import ghidra.trace.model.ImmutableTraceAddressSnapRange;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceBreakpointChangeType;
import ghidra.trace.model.breakpoint.TraceBreakpoint;
import ghidra.trace.model.breakpoint.TraceBreakpointKind;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.DBCachedObjectIndex;
import ghidra.util.database.DBCachedObjectStoreFactory;
@ -102,7 +102,7 @@ public class DBTraceBreakpointSpace implements DBTraceSpaceBased {
breakpointMapSpace.put(new ImmutableTraceAddressSnapRange(range, lifespan), null);
breakpoint.set(path, path, threads, kinds, enabled, true, comment);
trace.setChanged(
new TraceChangeRecord<>(TraceBreakpointChangeType.ADDED, this, breakpoint));
new TraceChangeRecord<>(TraceEvents.BREAKPOINT_ADDED, this, breakpoint));
return breakpoint;
}
}
@ -128,8 +128,7 @@ public class DBTraceBreakpointSpace implements DBTraceSpaceBased {
public void deleteBreakpoint(DBTraceBreakpoint breakpoint) {
breakpointMapSpace.deleteData(breakpoint);
trace.setChanged(
new TraceChangeRecord<>(TraceBreakpointChangeType.DELETED, this, breakpoint));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.BREAKPOINT_DELETED, this, breakpoint));
}
@Override

17
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/breakpoint/DBTraceObjectBreakpointLocation.java
View file

@ -27,7 +27,6 @@ import ghidra.program.model.address.AddressRange;
import ghidra.trace.database.target.*;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceBreakpointChangeType;
import ghidra.trace.model.breakpoint.*;
import ghidra.trace.model.target.TraceObject;
import ghidra.trace.model.target.annot.TraceObjectInterfaceUtils;
@ -59,18 +58,18 @@ public class DBTraceObjectBreakpointLocation
}
@Override
protected TraceChangeType<TraceBreakpoint, Void> getAddedType() {
return TraceBreakpointChangeType.ADDED;
protected TraceEvent<TraceBreakpoint, Void> getAddedType() {
return TraceEvents.BREAKPOINT_ADDED;
}
@Override
protected TraceChangeType<TraceBreakpoint, Lifespan> getLifespanChangedType() {
return TraceBreakpointChangeType.LIFESPAN_CHANGED;
protected TraceEvent<TraceBreakpoint, Lifespan> getLifespanChangedType() {
return TraceEvents.BREAKPOINT_LIFESPAN_CHANGED;
}
@Override
protected TraceChangeType<TraceBreakpoint, Void> getChangedType() {
return TraceBreakpointChangeType.CHANGED;
protected TraceEvent<TraceBreakpoint, Void> getChangedType() {
return TraceEvents.BREAKPOINT_CHANGED;
}
@Override
@ -79,8 +78,8 @@ public class DBTraceObjectBreakpointLocation
}
@Override
protected TraceChangeType<TraceBreakpoint, Void> getDeletedType() {
return TraceBreakpointChangeType.DELETED;
protected TraceEvent<TraceBreakpoint, Void> getDeletedType() {
return TraceEvents.BREAKPOINT_DELETED;
}
}

14
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/breakpoint/DBTraceObjectBreakpointSpec.java
View file

@ -26,8 +26,6 @@ import ghidra.trace.database.target.DBTraceObject;
import ghidra.trace.database.target.DBTraceObjectInterface;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceBreakpointChangeType;
import ghidra.trace.model.Trace.TraceObjectChangeType;
import ghidra.trace.model.breakpoint.*;
import ghidra.trace.model.breakpoint.TraceBreakpointKind.TraceBreakpointKindSet;
import ghidra.trace.model.target.TraceObject;
@ -35,8 +33,7 @@ import ghidra.trace.model.target.TraceObjectValue;
import ghidra.trace.model.target.annot.TraceObjectInterfaceUtils;
import ghidra.trace.model.thread.TraceObjectThread;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceAddressSpace;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.*;
import ghidra.util.LockHold;
import ghidra.util.Msg;
import ghidra.util.exception.DuplicateNameException;
@ -243,9 +240,8 @@ public class DBTraceObjectBreakpointSpec
@Override
public TraceChangeRecord<?, ?> translateEvent(TraceChangeRecord<?, ?> rec) {
if (rec.getEventType() == TraceObjectChangeType.VALUE_CREATED.getEventType()) {
TraceChangeRecord<TraceObjectValue, Void> cast =
TraceObjectChangeType.VALUE_CREATED.cast(rec);
if (rec.getEventType() == TraceEvents.VALUE_CREATED) {
TraceChangeRecord<TraceObjectValue, Void> cast = TraceEvents.VALUE_CREATED.cast(rec);
TraceObjectValue affected = cast.getAffectedObject();
String key = affected.getEntryKey();
boolean applies = keys.contains(key);
@ -259,8 +255,8 @@ public class DBTraceObjectBreakpointSpec
for (TraceObjectBreakpointLocation loc : getLocations()) {
DBTraceObjectBreakpointLocation dbLoc = (DBTraceObjectBreakpointLocation) loc;
TraceAddressSpace space = dbLoc.getTraceAddressSpace();
TraceChangeRecord<?, ?> evt = new TraceChangeRecord<>(
TraceBreakpointChangeType.CHANGED, space, loc, null, null);
TraceChangeRecord<?, ?> evt =
new TraceChangeRecord<>(TraceEvents.BREAKPOINT_CHANGED, space, loc, null, null);
object.getTrace().setChanged(evt);
}
return null;

12
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/guest/DBTraceGuestPlatform.java
View file

@ -34,12 +34,10 @@ import ghidra.trace.database.DBTraceUtils.CompilerSpecIDDBFieldCodec;
import ghidra.trace.database.DBTraceUtils.LanguageIDDBFieldCodec;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TracePlatformChangeType;
import ghidra.trace.model.guest.TraceGuestPlatform;
import ghidra.trace.model.guest.TraceGuestPlatformMappedRange;
import ghidra.trace.util.OverlappingObjectIterator;
import ghidra.trace.util.*;
import ghidra.trace.util.OverlappingObjectIterator.Ranger;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.util.LockHold;
import ghidra.util.database.*;
import ghidra.util.database.annot.*;
@ -217,8 +215,8 @@ public class DBTraceGuestPlatform extends DBAnnotatedObject
hostAddressSet.delete(hostRange);
guestAddressSet.delete(guestRange);
}
manager.trace.setChanged(new TraceChangeRecord<>(TracePlatformChangeType.MAPPING_DELETED,
null, this, range, null));
manager.trace.setChanged(
new TraceChangeRecord<>(TraceEvents.PLATFORM_MAPPING_DELETED, null, this, range, null));
}
@Override
@ -265,8 +263,8 @@ public class DBTraceGuestPlatform extends DBAnnotatedObject
hostAddressSet.add(mappedRange.getHostRange());
guestAddressSet.add(mappedRange.getGuestRange());
}
manager.trace.setChanged(new TraceChangeRecord<>(TracePlatformChangeType.MAPPING_ADDED,
null, this, null, mappedRange));
manager.trace.setChanged(new TraceChangeRecord<>(TraceEvents.PLATFORM_MAPPING_ADDED, null,
this, null, mappedRange));
return mappedRange;
}

10
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/guest/DBTraceObjectRegisterSupport.java
View file

@ -32,13 +32,13 @@ import ghidra.program.model.address.AddressSpace;
import ghidra.program.model.lang.Register;
import ghidra.program.model.lang.RegisterValue;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.*;
import ghidra.trace.model.guest.*;
import ghidra.trace.model.memory.TraceMemoryManager;
import ghidra.trace.model.memory.TraceMemorySpace;
import ghidra.trace.model.symbol.*;
import ghidra.trace.model.target.*;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.Msg;
public enum DBTraceObjectRegisterSupport {
@ -47,10 +47,10 @@ public enum DBTraceObjectRegisterSupport {
private static final TraceDomainObjectListener HANDLER = new TraceDomainObjectListener() {
{
listenFor(TraceObjectChangeType.VALUE_CREATED, INSTANCE::objectValueCreated);
listenFor(TraceSymbolChangeType.ADDED, INSTANCE::symbolAdded);
listenFor(TraceOverlaySpaceChangeType.ADDED, INSTANCE::spaceAdded);
listenFor(TracePlatformChangeType.MAPPING_ADDED, INSTANCE::guestMappingAdded);
listenFor(TraceEvents.VALUE_CREATED, INSTANCE::objectValueCreated);
listenFor(TraceEvents.SYMBOL_ADDED, INSTANCE::symbolAdded);
listenFor(TraceEvents.OVERLAY_ADDED, INSTANCE::spaceAdded);
listenFor(TraceEvents.PLATFORM_MAPPING_ADDED, INSTANCE::guestMappingAdded);
}
};

8
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/guest/DBTracePlatformManager.java
View file

@ -28,9 +28,9 @@ import ghidra.trace.database.DBTrace;
import ghidra.trace.database.DBTraceManager;
import ghidra.trace.database.guest.DBTraceGuestPlatform.DBTraceGuestLanguage;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TracePlatformChangeType;
import ghidra.trace.model.guest.*;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.*;
import ghidra.util.exception.CancelledException;
@ -282,7 +282,7 @@ public class DBTracePlatformManager implements DBTraceManager, TracePlatformMana
platformsByCompiler.remove(platform.getCompilerSpec());
platformStore.delete(platform);
}
trace.setChanged(new TraceChangeRecord<>(TracePlatformChangeType.DELETED, null, platform));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.PLATFORM_DELETED, null, platform));
}
@Override
@ -307,7 +307,7 @@ public class DBTracePlatformManager implements DBTraceManager, TracePlatformMana
try (LockHold hold = LockHold.lock(lock.writeLock())) {
platform = doAddGuestPlatform(compilerSpec);
}
trace.setChanged(new TraceChangeRecord<>(TracePlatformChangeType.ADDED, null, platform));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.PLATFORM_ADDED, null, platform));
return platform;
}
@ -335,7 +335,7 @@ public class DBTracePlatformManager implements DBTraceManager, TracePlatformMana
}
platform = doAddGuestPlatform(compilerSpec);
}
trace.setChanged(new TraceChangeRecord<>(TracePlatformChangeType.ADDED, null, platform));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.PLATFORM_ADDED, null, platform));
return platform;
}

10
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/AbstractBaseDBTraceDefinedUnitsView.java
View file

@ -29,9 +29,9 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapSpace;
import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
import ghidra.trace.database.memory.DBTraceMemorySpace;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceCodeChangeType;
import ghidra.trace.model.listing.TraceBaseDefinedUnitsView;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.spatial.rect.Rectangle2DDirection;
import ghidra.util.exception.CancelledException;
@ -339,8 +339,8 @@ public abstract class AbstractBaseDBTraceDefinedUnitsView<T extends AbstractDBTr
cacheForContaining.notifyEntryRemoved(unit.getLifespan(), unit.getRange(), unit);
cacheForSequence.notifyEntryRemoved(unit.getLifespan(), unit.getRange(), unit);
space.undefinedData.invalidateCache();
space.trace.setChanged(new TraceChangeRecord<>(TraceCodeChangeType.REMOVED,
space, unit.getBounds(), unit, null));
space.trace.setChanged(
new TraceChangeRecord<>(TraceEvents.CODE_REMOVED, space, unit.getBounds(), unit, null));
}
/**
@ -353,8 +353,8 @@ public abstract class AbstractBaseDBTraceDefinedUnitsView<T extends AbstractDBTr
cacheForContaining.notifyEntryShapeChanged(unit.getLifespan(), unit.getRange(), unit);
cacheForSequence.notifyEntryShapeChanged(unit.getLifespan(), unit.getRange(), unit);
space.undefinedData.invalidateCache();
space.trace.setChanged(new TraceChangeRecord<>(TraceCodeChangeType.LIFESPAN_CHANGED,
space, unit, oldSpan, unit.getLifespan()));
space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.CODE_LIFESPAN_CHANGED, space,
unit, oldSpan, unit.getLifespan()));
}
/**

4
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceCommentAdapter.java
View file

@ -36,8 +36,8 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAdd
import ghidra.trace.database.space.DBTraceSpaceKey;
import ghidra.trace.database.thread.DBTraceThreadManager;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceCommentChangeType;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.*;
import ghidra.util.database.annot.*;
@ -155,7 +155,7 @@ public class DBTraceCommentAdapter
}
}
trace.setChanged(new TraceChangeRecord<TraceAddressSnapRange, String>(
TraceCommentChangeType.byType(commentType),
TraceEvents.byCommentType(commentType),
DBTraceSpaceKey.create(address.getAddressSpace(), null, 0),
new ImmutableTraceAddressSnapRange(address, lifespan),
oldValue, comment));

26
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceDataAdapter.java
View file

@ -25,7 +25,6 @@ import ghidra.program.model.symbol.RefType;
import ghidra.program.model.symbol.SourceType;
import ghidra.trace.database.data.DBTraceDataSettingsOperations;
import ghidra.trace.database.symbol.DBTraceReference;
import ghidra.trace.model.Trace.TraceCodeChangeType;
import ghidra.trace.model.listing.TraceData;
import ghidra.trace.model.symbol.TraceReference;
import ghidra.trace.util.*;
@ -96,9 +95,8 @@ public interface DBTraceDataAdapter extends DBTraceCodeUnitAdapter, DataAdapterM
try (LockHold hold = getTrace().lockWrite()) {
getSettingsSpace(true).setLong(getLifespan(), getAddress(), name, value);
}
getTrace().setChanged(new TraceChangeRecord<>(
TraceCodeChangeType.DATA_TYPE_SETTINGS_CHANGED, getTraceSpace(), this.getBounds(), null,
null));
getTrace().setChanged(new TraceChangeRecord<>(TraceEvents.CODE_DATA_SETTINGS_CHANGED,
getTraceSpace(), this.getBounds(), null, null));
}
@Override
@ -121,9 +119,8 @@ public interface DBTraceDataAdapter extends DBTraceCodeUnitAdapter, DataAdapterM
try (LockHold hold = getTrace().lockWrite()) {
getSettingsSpace(true).setString(getLifespan(), getAddress(), name, value);
}
getTrace().setChanged(new TraceChangeRecord<>(
TraceCodeChangeType.DATA_TYPE_SETTINGS_CHANGED, getTraceSpace(), this.getBounds(), null,
null));
getTrace().setChanged(new TraceChangeRecord<>(TraceEvents.CODE_DATA_SETTINGS_CHANGED,
getTraceSpace(), this.getBounds(), null, null));
}
@Override
@ -147,9 +144,8 @@ public interface DBTraceDataAdapter extends DBTraceCodeUnitAdapter, DataAdapterM
try (LockHold hold = getTrace().lockWrite()) {
getSettingsSpace(true).setValue(getLifespan(), getAddress(), name, value);
}
getTrace().setChanged(new TraceChangeRecord<>(
TraceCodeChangeType.DATA_TYPE_SETTINGS_CHANGED, getTraceSpace(), this.getBounds(), null,
null));
getTrace().setChanged(new TraceChangeRecord<>(TraceEvents.CODE_DATA_SETTINGS_CHANGED,
getTraceSpace(), this.getBounds(), null, null));
}
@Override
@ -176,9 +172,8 @@ public interface DBTraceDataAdapter extends DBTraceCodeUnitAdapter, DataAdapterM
}
space.clear(getLifespan(), getAddress(), name);
}
getTrace().setChanged(new TraceChangeRecord<>(
TraceCodeChangeType.DATA_TYPE_SETTINGS_CHANGED, getTraceSpace(), this.getBounds(), null,
null));
getTrace().setChanged(new TraceChangeRecord<>(TraceEvents.CODE_DATA_SETTINGS_CHANGED,
getTraceSpace(), this.getBounds(), null, null));
}
@Override
@ -190,9 +185,8 @@ public interface DBTraceDataAdapter extends DBTraceCodeUnitAdapter, DataAdapterM
}
space.clear(getLifespan(), getAddress(), null);
}
getTrace().setChanged(new TraceChangeRecord<>(
TraceCodeChangeType.DATA_TYPE_SETTINGS_CHANGED, getTraceSpace(), this.getBounds(), null,
null));
getTrace().setChanged(new TraceChangeRecord<>(TraceEvents.CODE_DATA_SETTINGS_CHANGED,
getTraceSpace(), this.getBounds(), null, null));
}
@Override

13
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceDefinedDataView.java
View file

@ -21,10 +21,9 @@ import ghidra.program.model.mem.MemBuffer;
import ghidra.program.model.util.CodeUnitInsertionException;
import ghidra.trace.database.memory.DBTraceMemorySpace;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceCodeChangeType;
import ghidra.trace.model.Trace.TraceCompositeDataChangeType;
import ghidra.trace.model.listing.TraceCodeSpace;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
/**
@ -157,12 +156,12 @@ public class DBTraceDefinedDataView extends AbstractBaseDBTraceDefinedUnitsView<
if (dataType instanceof Composite || dataType instanceof Array ||
dataType instanceof Dynamic) {
// TODO: Track composites?
space.trace.setChanged(new TraceChangeRecord<>(TraceCompositeDataChangeType.ADDED,
space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.COMPOSITE_DATA_ADDED,
space, tasr, created));
}
space.trace.setChanged(new TraceChangeRecord<>(TraceCodeChangeType.ADDED,
space, tasr, created));
space.trace.setChanged(
new TraceChangeRecord<>(TraceEvents.CODE_ADDED, space, tasr, created));
return created;
}
catch (AddressOverflowException e) {
@ -176,7 +175,7 @@ public class DBTraceDefinedDataView extends AbstractBaseDBTraceDefinedUnitsView<
DataType dataType = unit.getBaseDataType();
if (dataType instanceof Composite || dataType instanceof Array ||
dataType instanceof Dynamic) {
space.trace.setChanged(new TraceChangeRecord<>(TraceCompositeDataChangeType.REMOVED,
space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.COMPOSITE_DATA_REMOVED,
space, unit.getBounds(), unit, null));
}
}
@ -188,7 +187,7 @@ public class DBTraceDefinedDataView extends AbstractBaseDBTraceDefinedUnitsView<
if (dataType instanceof Composite || dataType instanceof Array ||
dataType instanceof Dynamic) {
space.trace.setChanged(
new TraceChangeRecord<>(TraceCompositeDataChangeType.LIFESPAN_CHANGED,
new TraceChangeRecord<>(TraceEvents.COMPOSITE_DATA_LIFESPAN_CHANGED,
space, unit, oldSpan, unit.getLifespan()));
}
}

7
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceInstruction.java
View file

@ -39,7 +39,6 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
import ghidra.trace.database.symbol.DBTraceReference;
import ghidra.trace.database.symbol.DBTraceReferenceSpace;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceInstructionChangeType;
import ghidra.trace.model.guest.TracePlatform;
import ghidra.trace.model.listing.TraceInstruction;
import ghidra.trace.model.symbol.TraceReference;
@ -571,7 +570,7 @@ public class DBTraceInstruction extends AbstractDBTraceCodeUnit<DBTraceInstructi
}
}
space.trace.setChanged(
new TraceChangeRecord<>(TraceInstructionChangeType.FLOW_OVERRIDE_CHANGED, space, this,
new TraceChangeRecord<>(TraceEvents.INSTRUCTION_FLOW_OVERRIDE_CHANGED, space, this,
oldFlowOverride, flowOverride));
}
@ -604,7 +603,7 @@ public class DBTraceInstruction extends AbstractDBTraceCodeUnit<DBTraceInstructi
updateLengthOverride(length);
}
space.trace.setChanged(
new TraceChangeRecord<>(TraceInstructionChangeType.LENGTH_OVERRIDE_CHANGED, space, this,
new TraceChangeRecord<>(TraceEvents.INSTRUCTION_LENGTH_OVERRIDE_CHANGED, space, this,
oldLengthOverride, length));
}
@ -731,7 +730,7 @@ public class DBTraceInstruction extends AbstractDBTraceCodeUnit<DBTraceInstructi
}
update(FLAGS_COLUMN);
space.trace.setChanged(
new TraceChangeRecord<>(TraceInstructionChangeType.FALL_THROUGH_OVERRIDE_CHANGED, space,
new TraceChangeRecord<>(TraceEvents.INSTRUCTION_FALL_THROUGH_OVERRIDE_CHANGED, space,
this, !overridden, overridden));
}

23
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/listing/DBTraceInstructionsView.java
View file

@ -30,11 +30,9 @@ import ghidra.trace.database.context.DBTraceRegisterContextManager;
import ghidra.trace.database.context.DBTraceRegisterContextSpace;
import ghidra.trace.database.guest.InternalTracePlatform;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.TraceCodeChangeType;
import ghidra.trace.model.guest.TracePlatform;
import ghidra.trace.model.listing.*;
import ghidra.trace.util.OverlappingObjectIterator;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.*;
import ghidra.util.LockHold;
import ghidra.util.exception.CancelledException;
import ghidra.util.task.TaskMonitor;
@ -343,14 +341,15 @@ public class DBTraceInstructionsView extends AbstractBaseDBTraceDefinedUnitsView
* @param platform the platform (language, compiler) for the instruction
* @param prototype the instruction's prototype
* @param context the initial context for parsing the instruction
* @param length instruction byte-length (must be in the range 0..prototype.getLength()).
* If smaller than the prototype length it must have a value no greater than 7, otherwise
* an error will be thrown. A value of 0 or greater-than-or-equal the prototype length
* will be ignored and not impose and override length. The length value must be a multiple
* of the {@link Language#getInstructionAlignment() instruction alignment} .
* @param length instruction byte-length (must be in the range 0..prototype.getLength()). If
* smaller than the prototype length it must have a value no greater than 7,
* otherwise an error will be thrown. A value of 0 or greater-than-or-equal the
* prototype length will be ignored and not impose and override length. The length
* value must be a multiple of the {@link Language#getInstructionAlignment()
* instruction alignment} .
* @return the newly created instruction.
* @throws CodeUnitInsertionException thrown if the new Instruction would overlap and
* existing {@link CodeUnit} or the specified {@code length} is unsupported.
* @throws CodeUnitInsertionException thrown if the new Instruction would overlap and existing
* {@link CodeUnit} or the specified {@code length} is unsupported.
* @throws IllegalArgumentException if a negative {@code length} is specified.
* @throws AddressOverflowException if the instruction would fall off the address space
*/
@ -403,7 +402,7 @@ public class DBTraceInstructionsView extends AbstractBaseDBTraceDefinedUnitsView
DBTraceInstruction created =
doCreate(lifespan, address, dbPlatform, prototype, context, forcedLengthOverride);
space.trace.setChanged(
new TraceChangeRecord<>(TraceCodeChangeType.ADDED, space, created, created));
new TraceChangeRecord<>(TraceEvents.CODE_ADDED, space, created, created));
return created;
}
catch (AddressOverflowException e) {
@ -584,7 +583,7 @@ public class DBTraceInstructionsView extends AbstractBaseDBTraceDefinedUnitsView
if (lastInstruction != null) {
Address maxAddress = DBTraceCodeManager.instructionMax(lastInstruction, true);
result.addRange(block.getStartAddress(), maxAddress);
space.trace.setChanged(new TraceChangeRecord<>(TraceCodeChangeType.ADDED, space,
space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.CODE_ADDED, space,
new ImmutableTraceAddressSnapRange(block.getStartAddress(), maxAddress,
lifespan)));
}

20
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/memory/DBTraceMemoryRegion.java
View file

@ -25,9 +25,9 @@ import ghidra.trace.database.DBTraceUtils;
import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceMemoryRegionChangeType;
import ghidra.trace.model.memory.*;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.DBCachedObjectStore;
import ghidra.util.database.DBObjectColumn;
@ -151,8 +151,7 @@ public class DBTraceMemoryRegion
update(NAME_COLUMN);
space.trace.updateViewsChangeRegionBlockName(this);
}
space.trace.setChanged(
new TraceChangeRecord<>(TraceMemoryRegionChangeType.CHANGED, space, this));
space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.REGION_CHANGED, space, this));
}
@Override
@ -171,8 +170,7 @@ public class DBTraceMemoryRegion
Lifespan oldLifespan = getLifespan();
doSetLifespan(newLifespan);
space.trace.updateViewsChangeRegionBlockLifespan(this, oldLifespan, newLifespan);
space.trace.setChanged(
new TraceChangeRecord<>(TraceMemoryRegionChangeType.LIFESPAN_CHANGED,
space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.REGION_LIFESPAN_CHANGED,
space, this, oldLifespan, newLifespan));
}
}
@ -215,8 +213,7 @@ public class DBTraceMemoryRegion
doSetRange(newRange);
space.trace.updateViewsChangeRegionBlockRange(this, oldRange, newRange);
}
space.trace.setChanged(
new TraceChangeRecord<>(TraceMemoryRegionChangeType.CHANGED, space, this));
space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.REGION_CHANGED, space, this));
}
@Override
@ -272,8 +269,7 @@ public class DBTraceMemoryRegion
update(FLAGS_COLUMN);
space.trace.updateViewsChangeRegionBlockFlags(this, lifespan);
}
space.trace.setChanged(
new TraceChangeRecord<>(TraceMemoryRegionChangeType.CHANGED, space, this));
space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.REGION_CHANGED, space, this));
}
@SuppressWarnings("hiding")
@ -285,8 +281,7 @@ public class DBTraceMemoryRegion
update(FLAGS_COLUMN);
space.trace.updateViewsChangeRegionBlockFlags(this, lifespan);
}
space.trace.setChanged(
new TraceChangeRecord<>(TraceMemoryRegionChangeType.CHANGED, space, this));
space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.REGION_CHANGED, space, this));
}
@SuppressWarnings("hiding")
@ -298,8 +293,7 @@ public class DBTraceMemoryRegion
update(FLAGS_COLUMN);
space.trace.updateViewsChangeRegionBlockFlags(this, lifespan);
}
space.trace.setChanged(
new TraceChangeRecord<>(TraceMemoryRegionChangeType.CHANGED, space, this));
space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.REGION_CHANGED, space, this));
}
@Override

17
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/memory/DBTraceMemorySpace.java
View file

@ -36,10 +36,10 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAdd
import ghidra.trace.database.space.AbstractDBTraceSpaceBasedManager.DBTraceSpaceEntry;
import ghidra.trace.database.space.DBTraceSpaceBased;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.*;
import ghidra.trace.model.memory.*;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.*;
import ghidra.util.AddressIteratorAdapter;
import ghidra.util.database.*;
@ -160,8 +160,7 @@ public class DBTraceMemorySpace
regionMapSpace.put(new ImmutableTraceAddressSnapRange(range, lifespan), null);
region.set(path, path, flags);
trace.updateViewsAddRegionBlock(region);
trace.setChanged(
new TraceChangeRecord<>(TraceMemoryRegionChangeType.ADDED, this, region));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.REGION_ADDED, this, region));
return region;
}
}
@ -244,7 +243,7 @@ public class DBTraceMemorySpace
regionCache.remove(region);
trace.updateViewsDeleteRegionBlock(region);
trace.setChanged(
new TraceChangeRecord<>(TraceMemoryRegionChangeType.DELETED, this, region));
new TraceChangeRecord<>(TraceEvents.REGION_DELETED, this, region));
}
}
@ -316,7 +315,7 @@ public class DBTraceMemorySpace
}.set(start, end, state);
if (l.changed) {
trace.setChanged(new TraceChangeRecord<>(TraceMemoryStateChangeType.CHANGED, this,
trace.setChanged(new TraceChangeRecord<>(TraceEvents.BYTES_STATE_CHANGED, this,
new ImmutableTraceAddressSnapRange(start, end, snap, snap), state));
}
}
@ -663,8 +662,8 @@ public class DBTraceMemorySpace
buf.get(pos, bytes);
ImmutableTraceAddressSnapRange tasr = new ImmutableTraceAddressSnapRange(start,
start.add(result - 1), snap, lastSnap.snap);
trace.setChanged(new TraceChangeRecord<>(TraceMemoryBytesChangeType.CHANGED,
this, tasr, oldBytes.array(), bytes));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.BYTES_CHANGED, this, tasr,
oldBytes.array(), bytes));
// Fixup affected code units
DBTraceCodeSpace codeSpace = trace.getCodeManager().get(this, false);
@ -993,8 +992,8 @@ public class DBTraceMemorySpace
doSetState(snap, start, end, TraceMemoryState.UNKNOWN);
// Fire event
trace.setChanged(new TraceChangeRecord<>(TraceMemoryBytesChangeType.CHANGED,
this, new ImmutableTraceAddressSnapRange(start,
trace.setChanged(new TraceChangeRecord<>(
TraceEvents.BYTES_CHANGED, this, new ImmutableTraceAddressSnapRange(start,
start.add(newBytes.position() - 1), snap, lastSnap.snap),
oldBytes.array(), newBytes.array()));

20
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/memory/DBTraceObjectMemoryRegion.java
View file

@ -27,13 +27,11 @@ import ghidra.trace.database.target.DBTraceObject;
import ghidra.trace.database.target.DBTraceObjectInterface;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceMemoryRegionChangeType;
import ghidra.trace.model.memory.*;
import ghidra.trace.model.target.TraceObject;
import ghidra.trace.model.target.TraceObjectValue;
import ghidra.trace.model.target.annot.TraceObjectInterfaceUtils;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceChangeType;
import ghidra.trace.util.*;
import ghidra.util.LockHold;
import ghidra.util.exception.DuplicateNameException;
@ -82,18 +80,18 @@ public class DBTraceObjectMemoryRegion implements TraceObjectMemoryRegion, DBTra
}
@Override
protected TraceChangeType<TraceMemoryRegion, Void> getAddedType() {
return TraceMemoryRegionChangeType.ADDED;
protected TraceEvent<TraceMemoryRegion, Void> getAddedType() {
return TraceEvents.REGION_ADDED;
}
@Override
protected TraceChangeType<TraceMemoryRegion, Lifespan> getLifespanChangedType() {
return TraceMemoryRegionChangeType.LIFESPAN_CHANGED;
protected TraceEvent<TraceMemoryRegion, Lifespan> getLifespanChangedType() {
return TraceEvents.REGION_LIFESPAN_CHANGED;
}
@Override
protected TraceChangeType<TraceMemoryRegion, Void> getChangedType() {
return TraceMemoryRegionChangeType.CHANGED;
protected TraceEvent<TraceMemoryRegion, Void> getChangedType() {
return TraceEvents.REGION_CHANGED;
}
@Override
@ -102,8 +100,8 @@ public class DBTraceObjectMemoryRegion implements TraceObjectMemoryRegion, DBTra
}
@Override
protected TraceChangeType<TraceMemoryRegion, Void> getDeletedType() {
return TraceMemoryRegionChangeType.DELETED;
protected TraceEvent<TraceMemoryRegion, Void> getDeletedType() {
return TraceEvents.REGION_DELETED;
}
@Override

8
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/DBTraceModule.java
View file

@ -24,10 +24,10 @@ import ghidra.trace.database.DBTraceUtils;
import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceModuleChangeType;
import ghidra.trace.model.modules.TraceModule;
import ghidra.trace.model.modules.TraceSection;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.DBCachedObjectStore;
import ghidra.util.database.DBObjectColumn;
@ -110,7 +110,7 @@ public class DBTraceModule extends AbstractDBTraceAddressSnapRangePropertyMapDat
this.name = name;
update(NAME_COLUMN);
}
space.trace.setChanged(new TraceChangeRecord<>(TraceModuleChangeType.CHANGED, null, this));
space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.MODULE_CHANGED, null, this));
}
@Override
@ -128,7 +128,7 @@ public class DBTraceModule extends AbstractDBTraceAddressSnapRangePropertyMapDat
}
doSetRange(range);
}
space.trace.setChanged(new TraceChangeRecord<>(TraceModuleChangeType.CHANGED, space, this));
space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.MODULE_CHANGED, space, this));
}
@Override
@ -190,7 +190,7 @@ public class DBTraceModule extends AbstractDBTraceAddressSnapRangePropertyMapDat
traceSection.doSetLifespan(newLifespan);
}
}
space.trace.setChanged(new TraceChangeRecord<>(TraceModuleChangeType.LIFESPAN_CHANGED,
space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.MODULE_LIFESPAN_CHANGED,
null, this, oldLifespan, newLifespan));
}

4
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/DBTraceModuleManager.java
View file

@ -29,10 +29,10 @@ import ghidra.trace.database.DBTrace;
import ghidra.trace.database.space.AbstractDBTraceSpaceBasedManager;
import ghidra.trace.database.space.DBTraceDelegatingManager;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceModuleChangeType;
import ghidra.trace.model.modules.*;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.DBOpenMode;
import ghidra.util.exception.DuplicateNameException;
@ -298,6 +298,6 @@ public class DBTraceModuleManager extends AbstractDBTraceSpaceBasedManager<DBTra
}
module.space.moduleMapSpace.deleteData(module);
}
trace.setChanged(new TraceChangeRecord<>(TraceModuleChangeType.DELETED, null, module));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.MODULE_DELETED, null, module));
}
}

7
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/DBTraceModuleSpace.java
View file

@ -27,10 +27,9 @@ import ghidra.trace.database.space.DBTraceSpaceBased;
import ghidra.trace.database.thread.DBTraceThread;
import ghidra.trace.model.ImmutableTraceAddressSnapRange;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceModuleChangeType;
import ghidra.trace.model.Trace.TraceSectionChangeType;
import ghidra.trace.model.modules.TraceModuleSpace;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.database.DBCachedObjectIndex;
import ghidra.util.exception.VersionException;
@ -98,7 +97,7 @@ public class DBTraceModuleSpace implements TraceModuleSpace, DBTraceSpaceBased {
DBTraceModule module = moduleMapSpace
.put(new ImmutableTraceAddressSnapRange(range, lifespan), null);
module.set(modulePath, moduleName);
trace.setChanged(new TraceChangeRecord<>(TraceModuleChangeType.ADDED, null, module));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.MODULE_ADDED, null, module));
return module;
}
@ -136,7 +135,7 @@ public class DBTraceModuleSpace implements TraceModuleSpace, DBTraceSpaceBased {
DBTraceSection section = sectionMapSpace
.put(new ImmutableTraceAddressSnapRange(range, module.getLifespan()), null);
section.set(module, sectionPath, sectionName);
trace.setChanged(new TraceChangeRecord<>(TraceSectionChangeType.ADDED, null, section));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.SECTION_ADDED, null, section));
return section;
}

20
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/DBTraceObjectModule.java
View file

@ -28,12 +28,10 @@ import ghidra.trace.database.DBTraceUtils;
import ghidra.trace.database.target.*;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceModuleChangeType;
import ghidra.trace.model.modules.*;
import ghidra.trace.model.target.TraceObject;
import ghidra.trace.model.target.annot.TraceObjectInterfaceUtils;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceChangeType;
import ghidra.trace.util.*;
import ghidra.util.LockHold;
import ghidra.util.exception.DuplicateNameException;
@ -56,18 +54,18 @@ public class DBTraceObjectModule implements TraceObjectModule, DBTraceObjectInte
}
@Override
protected TraceChangeType<TraceModule, Void> getAddedType() {
return TraceModuleChangeType.ADDED;
protected TraceEvent<TraceModule, Void> getAddedType() {
return TraceEvents.MODULE_ADDED;
}
@Override
protected TraceChangeType<TraceModule, Lifespan> getLifespanChangedType() {
return TraceModuleChangeType.LIFESPAN_CHANGED;
protected TraceEvent<TraceModule, Lifespan> getLifespanChangedType() {
return TraceEvents.MODULE_LIFESPAN_CHANGED;
}
@Override
protected TraceChangeType<TraceModule, Void> getChangedType() {
return TraceModuleChangeType.CHANGED;
protected TraceEvent<TraceModule, Void> getChangedType() {
return TraceEvents.MODULE_CHANGED;
}
@Override
@ -76,8 +74,8 @@ public class DBTraceObjectModule implements TraceObjectModule, DBTraceObjectInte
}
@Override
protected TraceChangeType<TraceModule, Void> getDeletedType() {
return TraceModuleChangeType.DELETED;
protected TraceEvent<TraceModule, Void> getDeletedType() {
return TraceEvents.MODULE_DELETED;
}
}

18
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/DBTraceObjectSection.java
View file

@ -25,13 +25,11 @@ import ghidra.trace.database.target.DBTraceObject;
import ghidra.trace.database.target.DBTraceObjectInterface;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceSectionChangeType;
import ghidra.trace.model.modules.TraceObjectModule;
import ghidra.trace.model.modules.TraceSection;
import ghidra.trace.model.target.TraceObject;
import ghidra.trace.model.target.annot.TraceObjectInterfaceUtils;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceChangeType;
import ghidra.trace.util.*;
import ghidra.util.LockHold;
public class DBTraceObjectSection implements TraceObjectSection, DBTraceObjectInterface {
@ -53,18 +51,18 @@ public class DBTraceObjectSection implements TraceObjectSection, DBTraceObjectIn
}
@Override
protected TraceChangeType<TraceSection, Void> getAddedType() {
return TraceSectionChangeType.ADDED;
protected TraceEvent<TraceSection, Void> getAddedType() {
return TraceEvents.SECTION_ADDED;
}
@Override
protected TraceChangeType<TraceSection, Lifespan> getLifespanChangedType() {
protected TraceEvent<TraceSection, Lifespan> getLifespanChangedType() {
return null; // it's the module's lifespan that matters.
}
@Override
protected TraceChangeType<TraceSection, Void> getChangedType() {
return TraceSectionChangeType.CHANGED;
protected TraceEvent<TraceSection, Void> getChangedType() {
return TraceEvents.SECTION_CHANGED;
}
@Override
@ -73,8 +71,8 @@ public class DBTraceObjectSection implements TraceObjectSection, DBTraceObjectIn
}
@Override
protected TraceChangeType<TraceSection, Void> getDeletedType() {
return TraceSectionChangeType.DELETED;
protected TraceEvent<TraceSection, Void> getDeletedType() {
return TraceEvents.SECTION_DELETED;
}
}

8
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/DBTraceSection.java
View file

@ -25,9 +25,9 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree;
import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceSectionChangeType;
import ghidra.trace.model.modules.TraceSection;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.DBCachedObjectStore;
import ghidra.util.database.DBObjectColumn;
@ -140,8 +140,8 @@ public class DBTraceSection extends AbstractDBTraceAddressSnapRangePropertyMapDa
}
this.name = name;
update(NAME_COLUMN);
module.space.trace.setChanged(
new TraceChangeRecord<>(TraceSectionChangeType.CHANGED, null, this));
module.space.trace
.setChanged(new TraceChangeRecord<>(TraceEvents.SECTION_CHANGED, null, this));
}
}
@ -155,6 +155,6 @@ public class DBTraceSection extends AbstractDBTraceAddressSnapRangePropertyMapDa
@Override
public void delete() {
space.sectionMapSpace.deleteData(this);
space.trace.setChanged(new TraceChangeRecord<>(TraceSectionChangeType.DELETED, null, this));
space.trace.setChanged(new TraceChangeRecord<>(TraceEvents.SECTION_DELETED, null, this));
}
}

8
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/module/DBTraceStaticMappingManager.java
View file

@ -27,10 +27,10 @@ import ghidra.trace.database.DBTrace;
import ghidra.trace.database.DBTraceManager;
import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceStaticMappingChangeType;
import ghidra.trace.model.modules.TraceConflictedMappingException;
import ghidra.trace.model.modules.TraceStaticMappingManager;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.*;
import ghidra.util.exception.VersionException;
@ -106,8 +106,7 @@ public class DBTraceStaticMappingManager implements TraceStaticMappingManager, D
}
DBTraceStaticMapping mapping = mappingStore.create();
mapping.set(range, lifespan, toProgramURL, toAddress);
trace.setChanged(
new TraceChangeRecord<>(TraceStaticMappingChangeType.ADDED, null, mapping));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.MAPPING_ADDED, null, mapping));
return mapping;
}
}
@ -173,7 +172,6 @@ public class DBTraceStaticMappingManager implements TraceStaticMappingManager, D
public void delete(DBTraceStaticMapping mapping) {
mappingStore.delete(mapping);
trace.setChanged(
new TraceChangeRecord<>(TraceStaticMappingChangeType.DELETED, null, mapping));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.MAPPING_DELETED, null, mapping));
}
}

104
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/program/DBTraceProgramView.java
View file

@ -49,7 +49,6 @@ import ghidra.trace.database.listing.DBTraceCodeSpace;
import ghidra.trace.database.listing.DBTraceDefinedUnitsView;
import ghidra.trace.database.memory.DBTraceMemorySpace;
import ghidra.trace.model.*;
import ghidra.trace.model.Trace.*;
import ghidra.trace.model.TraceTimeViewport.Occlusion;
import ghidra.trace.model.TraceTimeViewport.RangeQueryOcclusion;
import ghidra.trace.model.bookmark.TraceBookmark;
@ -61,7 +60,7 @@ import ghidra.trace.model.memory.TraceMemoryState;
import ghidra.trace.model.program.TraceProgramView;
import ghidra.trace.model.symbol.*;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceAddressSpace;
import ghidra.trace.util.*;
import ghidra.util.*;
import ghidra.util.datastruct.WeakValueHashMap;
import ghidra.util.exception.*;
@ -92,71 +91,68 @@ public class DBTraceProgramView implements TraceProgramView {
listenForUntyped(DomainObjectEvent.CLOSED, this::eventPassthrough);
listenForUntyped(DomainObjectEvent.ERROR, this::eventPassthrough);
listenFor(TraceBookmarkChangeType.TYPE_ADDED, this::bookmarkTypeAdded);
listenFor(TraceBookmarkChangeType.ADDED, this::bookmarkAdded);
listenFor(TraceBookmarkChangeType.CHANGED, this::bookmarkChanged);
listenFor(TraceBookmarkChangeType.LIFESPAN_CHANGED, this::bookmarkLifespanChanged);
listenFor(TraceBookmarkChangeType.DELETED, this::bookmarkDeleted);
listenFor(TraceEvents.BOOKMARK_TYPE_ADDED, this::bookmarkTypeAdded);
listenFor(TraceEvents.BOOKMARK_ADDED, this::bookmarkAdded);
listenFor(TraceEvents.BOOKMARK_CHANGED, this::bookmarkChanged);
listenFor(TraceEvents.BOOKMARK_LIFESPAN_CHANGED, this::bookmarkLifespanChanged);
listenFor(TraceEvents.BOOKMARK_DELETED, this::bookmarkDeleted);
listenFor(TraceCategoryChangeType.ADDED, this::categoryAdded);
listenFor(TraceCategoryChangeType.MOVED, this::categoryMoved);
listenFor(TraceCategoryChangeType.RENAMED, this::categoryRenamed);
listenFor(TraceCategoryChangeType.DELETED, this::categoryDeleted);
listenFor(TraceEvents.TYPE_CATEGORY_ADDED, this::categoryAdded);
listenFor(TraceEvents.TYPE_CATEGORY_MOVED, this::categoryMoved);
listenFor(TraceEvents.TYPE_CATEGORY_RENAMED, this::categoryRenamed);
listenFor(TraceEvents.TYPE_CATEGORY_DELETED, this::categoryDeleted);
listenFor(TraceCodeChangeType.ADDED, this::codeAdded);
listenFor(TraceCodeChangeType.LIFESPAN_CHANGED, this::codeLifespanChanged);
listenFor(TraceCodeChangeType.REMOVED, this::codeRemoved);
listenFor(TraceCodeChangeType.FRAGMENT_CHANGED, this::codeFragmentChanged);
listenFor(TraceCodeChangeType.DATA_TYPE_REPLACED, this::codeDataTypeReplaced);
listenFor(TraceCodeChangeType.DATA_TYPE_SETTINGS_CHANGED,
this::codeDataTypeSettingsChanged);
listenFor(TraceEvents.CODE_ADDED, this::codeAdded);
listenFor(TraceEvents.CODE_LIFESPAN_CHANGED, this::codeLifespanChanged);
listenFor(TraceEvents.CODE_REMOVED, this::codeRemoved);
listenFor(TraceEvents.CODE_FRAGMENT_CHANGED, this::codeFragmentChanged);
listenFor(TraceEvents.CODE_DATA_TYPE_REPLACED, this::codeDataTypeReplaced);
listenFor(TraceEvents.CODE_DATA_SETTINGS_CHANGED, this::codeDataTypeSettingsChanged);
listenFor(TraceCommentChangeType.EOL_CHANGED, this::commentEolChanged);
listenFor(TraceCommentChangeType.PLATE_CHANGED, this::commentPlateChanged);
listenFor(TraceCommentChangeType.POST_CHANGED, this::commentPostChanged);
listenFor(TraceCommentChangeType.PRE_CHANGED, this::commentPreChanged);
listenFor(TraceCommentChangeType.REPEATABLE_CHANGED, this::commentRepeatableChanged);
listenFor(TraceEvents.EOL_COMMENT_CHANGED, this::commentEolChanged);
listenFor(TraceEvents.PLATE_COMMENT_CHANGED, this::commentPlateChanged);
listenFor(TraceEvents.POST_COMMENT_CHANGED, this::commentPostChanged);
listenFor(TraceEvents.PRE_COMMENT_CHANGED, this::commentPreChanged);
listenFor(TraceEvents.REPEATABLE_COMMENT_CHANGED, this::commentRepeatableChanged);
listenFor(TraceCompositeDataChangeType.ADDED, this::compositeDataAdded);
listenFor(TraceCompositeDataChangeType.LIFESPAN_CHANGED,
this::compositeLifespanChanged);
listenFor(TraceCompositeDataChangeType.REMOVED, this::compositeDataRemoved);
listenFor(TraceEvents.COMPOSITE_DATA_ADDED, this::compositeDataAdded);
listenFor(TraceEvents.COMPOSITE_DATA_LIFESPAN_CHANGED, this::compositeLifespanChanged);
listenFor(TraceEvents.COMPOSITE_DATA_REMOVED, this::compositeDataRemoved);
listenFor(TraceDataTypeChangeType.ADDED, this::dataTypeAdded);
listenFor(TraceDataTypeChangeType.CHANGED, this::dataTypeChanged);
listenFor(TraceDataTypeChangeType.REPLACED, this::dataTypeReplaced);
listenFor(TraceDataTypeChangeType.MOVED, this::dataTypeMoved);
listenFor(TraceDataTypeChangeType.RENAMED, this::dataTypeRenamed);
listenFor(TraceDataTypeChangeType.DELETED, this::dataTypeDeleted);
listenFor(TraceEvents.DATA_TYPE_ADDED, this::dataTypeAdded);
listenFor(TraceEvents.DATA_TYPE_CHANGED, this::dataTypeChanged);
listenFor(TraceEvents.DATA_TYPE_REPLACED, this::dataTypeReplaced);
listenFor(TraceEvents.DATA_TYPE_MOVED, this::dataTypeMoved);
listenFor(TraceEvents.DATA_TYPE_RENAMED, this::dataTypeRenamed);
listenFor(TraceEvents.DATA_TYPE_DELETED, this::dataTypeDeleted);
listenFor(TraceInstructionChangeType.LENGTH_OVERRIDE_CHANGED,
listenFor(TraceEvents.INSTRUCTION_LENGTH_OVERRIDE_CHANGED,
this::instructionLengthOverrideChanged);
listenFor(TraceInstructionChangeType.FLOW_OVERRIDE_CHANGED,
listenFor(TraceEvents.INSTRUCTION_FLOW_OVERRIDE_CHANGED,
this::instructionFlowOverrideChanged);
listenFor(TraceInstructionChangeType.FALL_THROUGH_OVERRIDE_CHANGED,
listenFor(TraceEvents.INSTRUCTION_FALL_THROUGH_OVERRIDE_CHANGED,
this::instructionFallThroughChanged);
listenFor(TraceMemoryBytesChangeType.CHANGED, this::memoryBytesChanged);
listenFor(TraceEvents.BYTES_CHANGED, this::memoryBytesChanged);
listenFor(TraceMemoryRegionChangeType.ADDED, this::memoryRegionAdded);
listenFor(TraceMemoryRegionChangeType.CHANGED, this::memoryRegionChanged);
listenFor(TraceMemoryRegionChangeType.LIFESPAN_CHANGED,
this::memoryRegionLifespanChanged);
listenFor(TraceMemoryRegionChangeType.DELETED, this::memoryRegionDeleted);
listenFor(TraceEvents.REGION_ADDED, this::memoryRegionAdded);
listenFor(TraceEvents.REGION_CHANGED, this::memoryRegionChanged);
listenFor(TraceEvents.REGION_LIFESPAN_CHANGED, this::memoryRegionLifespanChanged);
listenFor(TraceEvents.REGION_DELETED, this::memoryRegionDeleted);
listenFor(TraceSourceArchiveChangeType.ADDED, this::sourceArchiveAdded);
listenFor(TraceSourceArchiveChangeType.CHANGED, this::sourceArchiveChanged);
listenFor(TraceEvents.SOURCE_TYPE_ARCHIVE_ADDED, this::sourceArchiveAdded);
listenFor(TraceEvents.SOURCE_TYPE_ARCHIVE_CHANGED, this::sourceArchiveChanged);
listenFor(TraceSymbolChangeType.ADDED, this::symbolAdded);
listenFor(TraceSymbolChangeType.SOURCE_CHANGED, this::symbolSourceChanged);
listenFor(TraceSymbolChangeType.SET_AS_PRIMARY, this::symbolSetAsPrimary);
listenFor(TraceSymbolChangeType.RENAMED, this::symbolRenamed);
listenFor(TraceSymbolChangeType.PARENT_CHANGED, this::symbolParentChanged);
listenFor(TraceSymbolChangeType.ASSOCIATION_ADDED, this::symbolAssociationAdded);
listenFor(TraceSymbolChangeType.ASSOCIATION_REMOVED, this::symbolAssociationRemoved);
listenFor(TraceSymbolChangeType.ADDRESS_CHANGED, this::symbolAddressChanged);
listenFor(TraceSymbolChangeType.LIFESPAN_CHANGED, this::symbolLifespanChanged);
listenFor(TraceSymbolChangeType.DELETED, this::symbolDeleted);
listenFor(TraceEvents.SYMBOL_ADDED, this::symbolAdded);
listenFor(TraceEvents.SYMBOL_SOURCE_CHANGED, this::symbolSourceChanged);
listenFor(TraceEvents.SYMBOL_PRIMARY_CHANGED, this::symbolSetAsPrimary);
listenFor(TraceEvents.SYMBOL_RENAMED, this::symbolRenamed);
listenFor(TraceEvents.SYMBOL_PARENT_CHANGED, this::symbolParentChanged);
listenFor(TraceEvents.SYMBOL_ASSOCIATION_ADDED, this::symbolAssociationAdded);
listenFor(TraceEvents.SYMBOL_ASSOCIATION_REMOVED, this::symbolAssociationRemoved);
listenFor(TraceEvents.SYMBOL_ADDRESS_CHANGED, this::symbolAddressChanged);
listenFor(TraceEvents.SYMBOL_LIFESPAN_CHANGED, this::symbolLifespanChanged);
listenFor(TraceEvents.SYMBOL_DELETED, this::symbolDeleted);
}
@Override

18
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/stack/DBTraceObjectStack.java
View file

@ -25,13 +25,11 @@ import ghidra.dbg.util.*;
import ghidra.trace.database.target.DBTraceObject;
import ghidra.trace.database.target.DBTraceObjectInterface;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceStackChangeType;
import ghidra.trace.model.stack.*;
import ghidra.trace.model.target.TraceObject;
import ghidra.trace.model.thread.TraceObjectThread;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceChangeType;
import ghidra.trace.util.*;
import ghidra.util.LockHold;
public class DBTraceObjectStack implements TraceObjectStack, DBTraceObjectInterface {
@ -42,18 +40,18 @@ public class DBTraceObjectStack implements TraceObjectStack, DBTraceObjectInterf
}
@Override
protected TraceChangeType<TraceStack, Void> getAddedType() {
return TraceStackChangeType.ADDED;
protected TraceEvent<TraceStack, Void> getAddedType() {
return TraceEvents.STACK_ADDED;
}
@Override
protected TraceChangeType<TraceStack, Lifespan> getLifespanChangedType() {
protected TraceEvent<TraceStack, Lifespan> getLifespanChangedType() {
return null;
}
@Override
protected TraceChangeType<TraceStack, ?> getChangedType() {
return TraceStackChangeType.CHANGED;
protected TraceEvent<TraceStack, ?> getChangedType() {
return TraceEvents.STACK_CHANGED;
}
@Override
@ -62,8 +60,8 @@ public class DBTraceObjectStack implements TraceObjectStack, DBTraceObjectInterf
}
@Override
protected TraceChangeType<TraceStack, Void> getDeletedType() {
return TraceStackChangeType.DELETED;
protected TraceEvent<TraceStack, Void> getDeletedType() {
return TraceEvents.STACK_DELETED;
}
}

18
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/stack/DBTraceObjectStackFrame.java
View file

@ -28,14 +28,13 @@ import ghidra.trace.database.target.DBTraceObjectInterface;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Lifespan.DefaultLifeSet;
import ghidra.trace.model.Lifespan.LifeSet;
import ghidra.trace.model.Trace.TraceObjectChangeType;
import ghidra.trace.model.Trace.TraceStackChangeType;
import ghidra.trace.model.stack.TraceObjectStack;
import ghidra.trace.model.stack.TraceObjectStackFrame;
import ghidra.trace.model.target.TraceObject;
import ghidra.trace.model.target.TraceObjectValue;
import ghidra.trace.model.target.annot.TraceObjectInterfaceUtils;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
public class DBTraceObjectStackFrame implements TraceObjectStackFrame, DBTraceObjectInterface {
@ -143,8 +142,7 @@ public class DBTraceObjectStackFrame implements TraceObjectStackFrame, DBTraceOb
}
protected boolean changeApplies(TraceChangeRecord<?, ?> rec) {
TraceChangeRecord<TraceObjectValue, Void> cast =
TraceObjectChangeType.VALUE_CREATED.cast(rec);
TraceChangeRecord<TraceObjectValue, Void> cast = TraceEvents.VALUE_CREATED.cast(rec);
TraceObjectValue affected = cast.getAffectedObject();
assert affected.getParent() == object;
if (!keys.contains(affected.getEntryKey())) {
@ -166,31 +164,31 @@ public class DBTraceObjectStackFrame implements TraceObjectStackFrame, DBTraceOb
}
protected long snapFor(TraceChangeRecord<?, ?> rec) {
if (rec.getEventType() == TraceObjectChangeType.VALUE_CREATED.getEventType()) {
return TraceObjectChangeType.VALUE_CREATED.cast(rec).getAffectedObject().getMinSnap();
if (rec.getEventType() == TraceEvents.VALUE_CREATED) {
return TraceEvents.VALUE_CREATED.cast(rec).getAffectedObject().getMinSnap();
}
return computeMinSnap();
}
protected TraceChangeRecord<?, ?> createChangeRecord() {
return new TraceChangeRecord<>(TraceStackChangeType.CHANGED, null, getStack(), 0L,
return new TraceChangeRecord<>(TraceEvents.STACK_CHANGED, null, getStack(), 0L,
life.bound().lmin());
}
@Override
public TraceChangeRecord<?, ?> translateEvent(TraceChangeRecord<?, ?> rec) {
EventType type = rec.getEventType();
if (type == TraceObjectChangeType.LIFE_CHANGED.getEventType()) {
if (type == TraceEvents.OBJECT_LIFE_CHANGED) {
LifeSet newLife = object.getLife();
if (!newLife.isEmpty()) {
life = newLife;
}
return createChangeRecord();
}
else if (type == TraceObjectChangeType.VALUE_CREATED.getEventType() && changeApplies(rec)) {
else if (type == TraceEvents.VALUE_CREATED && changeApplies(rec)) {
return createChangeRecord();
}
else if (type == TraceObjectChangeType.DELETED.getEventType()) {
else if (type == TraceEvents.OBJECT_DELETED) {
if (life.isEmpty()) {
return null;
}

7
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/stack/DBTraceStack.java
View file

@ -22,11 +22,11 @@ import java.util.*;
import db.BinaryField;
import db.DBRecord;
import ghidra.trace.model.Trace.TraceStackChangeType;
import ghidra.trace.model.stack.TraceStack;
import ghidra.trace.model.stack.TraceStackFrame;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.*;
import ghidra.util.database.DBCachedObjectStoreFactory.AbstractDBFieldCodec;
@ -213,7 +213,7 @@ public class DBTraceStack extends DBAnnotatedObject implements TraceStack {
doUpdateFrameKeys();
}
manager.trace.setChanged(
new TraceChangeRecord<>(TraceStackChangeType.CHANGED, null, this, 0L, getSnap()));
new TraceChangeRecord<>(TraceEvents.STACK_CHANGED, null, this, 0L, getSnap()));
}
@Override
@ -251,8 +251,7 @@ public class DBTraceStack extends DBAnnotatedObject implements TraceStack {
}
manager.deleteStack(this);
}
manager.trace
.setChanged(new TraceChangeRecord<>(TraceStackChangeType.DELETED, null, this));
manager.trace.setChanged(new TraceChangeRecord<>(TraceEvents.STACK_DELETED, null, this));
}
@Override

8
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/stack/DBTraceStackFrame.java
View file

@ -25,9 +25,9 @@ import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter;
import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter.AddressDBFieldCodec;
import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter.DecodesAddresses;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceStackChangeType;
import ghidra.trace.model.stack.TraceStackFrame;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.*;
import ghidra.util.database.annot.*;
@ -130,8 +130,7 @@ public class DBTraceStackFrame extends DBAnnotatedObject
update(PC_COLUMN);
}
manager.trace.setChanged(
new TraceChangeRecord<>(TraceStackChangeType.CHANGED, null, stack, 0L,
stack.getSnap()));
new TraceChangeRecord<>(TraceEvents.STACK_CHANGED, null, stack, 0L, stack.getSnap()));
}
@Override
@ -146,8 +145,7 @@ public class DBTraceStackFrame extends DBAnnotatedObject
update(COMMENT_COLUMN);
}
manager.trace.setChanged(
new TraceChangeRecord<>(TraceStackChangeType.CHANGED, null, stack, 0L,
stack.getSnap()));
new TraceChangeRecord<>(TraceEvents.STACK_CHANGED, null, stack, 0L, stack.getSnap()));
}
@Internal

4
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/stack/DBTraceStackManager.java
View file

@ -31,13 +31,13 @@ import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter;
import ghidra.trace.database.stack.DBTraceStack.ThreadSnap;
import ghidra.trace.database.thread.DBTraceThreadManager;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceStackChangeType;
import ghidra.trace.model.stack.*;
import ghidra.trace.model.target.TraceObject;
import ghidra.trace.model.target.TraceObjectKeyPath;
import ghidra.trace.model.thread.TraceObjectThread;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.*;
import ghidra.util.exception.VersionException;
@ -156,7 +156,7 @@ public class DBTraceStackManager implements TraceStackManager, DBTraceManager {
stack = stackStore.create();
stack.set(thread, snap);
}
trace.setChanged(new TraceChangeRecord<>(TraceStackChangeType.ADDED, null, stack));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.STACK_ADDED, null, stack));
return stack;
}
return stacksByThreadSnap.getOne(key);

10
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/AbstractDBTraceSymbol.java
View file

@ -35,12 +35,10 @@ import ghidra.trace.database.program.DBTraceProgramView;
import ghidra.trace.database.symbol.DBTraceSymbolManager.DBTraceSymbolIDEntry;
import ghidra.trace.database.symbol.DBTraceSymbolManager.MySymbolTypes;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceSymbolChangeType;
import ghidra.trace.model.TraceAddressSnapRange;
import ghidra.trace.model.symbol.TraceSymbol;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceAddressSpace;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.*;
import ghidra.util.LockHold;
import ghidra.util.database.*;
import ghidra.util.database.annot.DBAnnotatedColumn;
@ -340,7 +338,7 @@ public abstract class AbstractDBTraceSymbol extends DBAnnotatedObject
return null;
}
this.name = newName;
return new TraceChangeRecord<>(TraceSymbolChangeType.RENAMED, getSpace(), this, oldName,
return new TraceChangeRecord<>(TraceEvents.SYMBOL_RENAMED, getSpace(), this, oldName,
newName);
}
@ -365,7 +363,7 @@ public abstract class AbstractDBTraceSymbol extends DBAnnotatedObject
DBTraceNamespaceSymbol checkedParent = checkCircular(newParent);
this.parent = checkedParent;
this.parentID = parent.getID();
return new TraceChangeRecord<>(TraceSymbolChangeType.PARENT_CHANGED, getSpace(), this,
return new TraceChangeRecord<>(TraceEvents.SYMBOL_PARENT_CHANGED, getSpace(), this,
oldParent, checkedParent);
}
@ -389,7 +387,7 @@ public abstract class AbstractDBTraceSymbol extends DBAnnotatedObject
return null;
}
doSetSource(newSource);
return new TraceChangeRecord<>(TraceSymbolChangeType.SOURCE_CHANGED, getSpace(), this,
return new TraceChangeRecord<>(TraceEvents.SYMBOL_SOURCE_CHANGED, getSpace(), this,
oldSource, newSource);
}

5
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceClassSymbolView.java
View file

@ -16,10 +16,10 @@
package ghidra.trace.database.symbol;
import ghidra.program.model.symbol.*;
import ghidra.trace.model.Trace.TraceSymbolChangeType;
import ghidra.trace.model.symbol.TraceClassSymbolView;
import ghidra.trace.model.symbol.TraceNamespaceSymbol;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.exception.DuplicateNameException;
import ghidra.util.exception.InvalidInputException;
@ -43,8 +43,7 @@ public class DBTraceClassSymbolView extends AbstractDBTraceSymbolSingleTypeView<
manager.assertUniqueName(name, dbnsParent);
DBTraceClassSymbol cls = store.create();
cls.set(name, dbnsParent, source);
manager.trace.setChanged(
new TraceChangeRecord<>(TraceSymbolChangeType.ADDED, null, cls));
manager.trace.setChanged(new TraceChangeRecord<>(TraceEvents.SYMBOL_ADDED, null, cls));
return cls;
}
}

10
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceLabelSymbol.java
View file

@ -26,11 +26,9 @@ import ghidra.trace.database.address.DBTraceOverlaySpaceAdapter.DecodesAddresses
import ghidra.trace.database.listing.*;
import ghidra.trace.database.space.DBTraceSpaceKey;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceSymbolChangeType;
import ghidra.trace.model.symbol.TraceLabelSymbol;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceAddressSpace;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.*;
import ghidra.util.LockHold;
import ghidra.util.database.DBCachedObjectStore;
import ghidra.util.database.DBObjectColumn;
@ -139,7 +137,7 @@ public class DBTraceLabelSymbol extends AbstractDBTraceSymbol
Lifespan oldLifespan = lifespan;
this.lifespan = newLifespan;
manager.trace.setChanged(new TraceChangeRecord<>(TraceSymbolChangeType.LIFESPAN_CHANGED,
manager.trace.setChanged(new TraceChangeRecord<>(TraceEvents.SYMBOL_LIFESPAN_CHANGED,
getSpace(), this, oldLifespan, newLifespan));
}
}
@ -253,13 +251,13 @@ public class DBTraceLabelSymbol extends AbstractDBTraceSymbol
if (other.doSetPrimary(false)) {
other.update(AbstractDBTraceSymbol.FLAGS_COLUMN);
manager.trace.setChanged(new TraceChangeRecord<>(
TraceSymbolChangeType.SET_AS_PRIMARY, getSpace(), this, other, this));
TraceEvents.SYMBOL_PRIMARY_CHANGED, getSpace(), this, other, this));
firedEvent = true;
}
}
if (!firedEvent) {
manager.trace.setChanged(new TraceChangeRecord<>(
TraceSymbolChangeType.SET_AS_PRIMARY, getSpace(), this));
TraceEvents.SYMBOL_PRIMARY_CHANGED, getSpace(), this));
}
return true;
}

4
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceLabelSymbolView.java
View file

@ -18,11 +18,11 @@ package ghidra.trace.database.symbol;
import ghidra.program.model.address.Address;
import ghidra.program.model.symbol.*;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceSymbolChangeType;
import ghidra.trace.model.symbol.TraceLabelSymbolView;
import ghidra.trace.model.symbol.TraceNamespaceSymbol;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.exception.InvalidInputException;
@ -54,7 +54,7 @@ public class DBTraceLabelSymbolView
cacheForAt.notifyNewEntry(lifespan, address, label);
manager.trace.setChanged(
new TraceChangeRecord<>(TraceSymbolChangeType.ADDED, label.getSpace(), label));
new TraceChangeRecord<>(TraceEvents.SYMBOL_ADDED, label.getSpace(), label));
return label;
}
}

6
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceNamespaceSymbolView.java
View file

@ -19,10 +19,10 @@ import java.util.Collection;
import java.util.Collections;
import ghidra.program.model.symbol.*;
import ghidra.trace.model.Trace.TraceSymbolChangeType;
import ghidra.trace.model.symbol.TraceNamespaceSymbol;
import ghidra.trace.model.symbol.TraceNamespaceSymbolView;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.exception.DuplicateNameException;
import ghidra.util.exception.InvalidInputException;
@ -47,8 +47,8 @@ public class DBTraceNamespaceSymbolView
manager.assertUniqueName(name, dbnsParent);
DBTraceNamespaceSymbol namespace = store.create();
namespace.set(name, dbnsParent, source);
manager.trace.setChanged(
new TraceChangeRecord<>(TraceSymbolChangeType.ADDED, null, namespace));
manager.trace
.setChanged(new TraceChangeRecord<>(TraceEvents.SYMBOL_ADDED, null, namespace));
return namespace;
}
}

18
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceReference.java
View file

@ -23,11 +23,10 @@ import ghidra.program.model.symbol.*;
import ghidra.trace.database.DBTrace;
import ghidra.trace.database.symbol.DBTraceReferenceSpace.DBTraceReferenceEntry;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceReferenceChangeType;
import ghidra.trace.model.Trace.TraceSymbolChangeType;
import ghidra.trace.model.symbol.*;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
public class DBTraceReference implements TraceReference {
@ -51,7 +50,7 @@ public class DBTraceReference implements TraceReference {
try (LockHold hold = LockHold.lock(ent.space.lock.writeLock())) {
ent.doDelete();
ent.space.trace.setChanged(
new TraceChangeRecord<>(TraceReferenceChangeType.DELETED, ent.space, ent, this));
new TraceChangeRecord<>(TraceEvents.REFERENCE_DELETED, ent.space, ent, this));
if (isPrimary()) {
Collection<? extends DBTraceReference> remaining = ent.space.getReferencesFrom(
getStartSnap(), getFromAddress(), getOperandIndex());
@ -61,7 +60,7 @@ public class DBTraceReference implements TraceReference {
DBTraceReference newPrimary = remaining.iterator().next();
newPrimary.ent.setPrimary(true);
ent.space.trace.setChanged(new TraceChangeRecord<>(
TraceReferenceChangeType.PRIMARY_CHANGED, ent.space, this, false, true));
TraceEvents.REFERENCE_PRIMARY_CHANGED, ent.space, this, false, true));
}
}
}
@ -98,13 +97,12 @@ public class DBTraceReference implements TraceReference {
getFromAddress(), getOperandIndex());
if (oldPrimary != null) {
oldPrimary.ent.setPrimary(false);
ent.space.trace.setChanged(
new TraceChangeRecord<>(TraceReferenceChangeType.PRIMARY_CHANGED, ent.space,
oldPrimary, true, false));
ent.space.trace.setChanged(new TraceChangeRecord<>(
TraceEvents.REFERENCE_PRIMARY_CHANGED, ent.space, oldPrimary, true, false));
}
ent.setPrimary(true);
ent.space.trace.setChanged(new TraceChangeRecord<>(
TraceReferenceChangeType.PRIMARY_CHANGED, ent.space, this, false, true));
TraceEvents.REFERENCE_PRIMARY_CHANGED, ent.space, this, false, true));
}
}
@ -164,7 +162,7 @@ public class DBTraceReference implements TraceReference {
}
}
ent.setSymbolId(symbol.getID());
getTrace().setChanged(new TraceChangeRecord<>(TraceSymbolChangeType.ASSOCIATION_ADDED,
getTrace().setChanged(new TraceChangeRecord<>(TraceEvents.SYMBOL_ASSOCIATION_ADDED,
ent.space, dbSym, null, this));
}
}
@ -177,7 +175,7 @@ public class DBTraceReference implements TraceReference {
}
TraceSymbol oldSymbol = getTrace().getSymbolManager().getSymbolByID(ent.symbolId);
ent.setSymbolId(-1);
getTrace().setChanged(new TraceChangeRecord<>(TraceSymbolChangeType.ASSOCIATION_REMOVED,
getTrace().setChanged(new TraceChangeRecord<>(TraceEvents.SYMBOL_ASSOCIATION_REMOVED,
ent.space, oldSymbol, this, null));
}
}

11
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceReferenceSpace.java
View file

@ -39,13 +39,12 @@ import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAdd
import ghidra.trace.database.space.AbstractDBTraceSpaceBasedManager.DBTraceSpaceEntry;
import ghidra.trace.database.space.DBTraceSpaceBased;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceReferenceChangeType;
import ghidra.trace.model.Trace.TraceSymbolChangeType;
import ghidra.trace.model.memory.TraceMemoryRegion;
import ghidra.trace.model.symbol.TraceReference;
import ghidra.trace.model.symbol.TraceReferenceSpace;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.*;
import ghidra.util.database.*;
import ghidra.util.database.annot.*;
@ -229,11 +228,11 @@ public class DBTraceReferenceSpace implements DBTraceSpaceBased, TraceReferenceS
if (oldSymbol != null) {
space.trace.setChanged(new TraceChangeRecord<>(
TraceSymbolChangeType.ASSOCIATION_REMOVED, space, oldSymbol, ref));
TraceEvents.SYMBOL_ASSOCIATION_REMOVED, space, oldSymbol, ref));
}
if (newSymbol != null) {
space.trace.setChanged(new TraceChangeRecord<>(
TraceSymbolChangeType.ASSOCIATION_ADDED, space, newSymbol, ref));
TraceEvents.SYMBOL_ASSOCIATION_ADDED, space, newSymbol, ref));
}
}
@ -692,8 +691,8 @@ public class DBTraceReferenceSpace implements DBTraceSpaceBased, TraceReferenceS
if (ref.getLifespan().lmin() < otherStartSnap) {
Lifespan oldSpan = ref.getLifespan();
ref.setEndSnap(otherStartSnap - 1);
trace.setChanged(new TraceChangeRecord<>(TraceReferenceChangeType.LIFESPAN_CHANGED,
this, ref.ref, oldSpan, ref.getLifespan()));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.REFERENCE_LIFESPAN_CHANGED, this,
ref.ref, oldSpan, ref.getLifespan()));
}
else {
ref.ref.delete();

9
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/symbol/DBTraceSymbolManager.java
View file

@ -39,10 +39,10 @@ import ghidra.trace.database.space.DBTraceSpaceKey;
import ghidra.trace.database.thread.DBTraceThreadManager;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceSymbolChangeType;
import ghidra.trace.model.symbol.*;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.*;
import ghidra.util.database.DBCachedObjectStoreFactory.AbstractDBFieldCodec;
@ -138,7 +138,10 @@ public class DBTraceSymbolManager implements TraceSymbolManager, DBTraceManager
@DBAnnotatedColumn(STORAGE_COLUMN_NAME)
static DBObjectColumn STORAGE_COLUMN;
@DBAnnotatedField(column = STORAGE_COLUMN_NAME, indexed = true, codec = VariableStorageDBFieldCodec.class)
@DBAnnotatedField(
column = STORAGE_COLUMN_NAME,
indexed = true,
codec = VariableStorageDBFieldCodec.class)
private VariableStorage storage;
protected final DBTraceSymbolManager manager;
@ -516,7 +519,7 @@ public class DBTraceSymbolManager implements TraceSymbolManager, DBTraceManager
delID(thread, symbol.getAddress().getAddressSpace(), symbol.getID());
}
// TODO: Remove from other space maps, once implemented.
trace.setChanged(new TraceChangeRecord<>(TraceSymbolChangeType.DELETED, symbol.getSpace(),
trace.setChanged(new TraceChangeRecord<>(TraceEvents.SYMBOL_DELETED, symbol.getSpace(),
symbol, null, null));
return true;
}

4
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/target/DBTraceObject.java
View file

@ -43,7 +43,6 @@ import ghidra.trace.database.target.visitors.TreeTraversal.Visitor;
import ghidra.trace.database.thread.DBTraceObjectThread;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Lifespan.*;
import ghidra.trace.model.Trace.TraceObjectChangeType;
import ghidra.trace.model.breakpoint.TraceObjectBreakpointLocation;
import ghidra.trace.model.breakpoint.TraceObjectBreakpointSpec;
import ghidra.trace.model.memory.TraceObjectMemoryRegion;
@ -55,6 +54,7 @@ import ghidra.trace.model.target.*;
import ghidra.trace.model.target.annot.TraceObjectInterfaceUtils;
import ghidra.trace.model.thread.TraceObjectThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.Msg;
import ghidra.util.database.*;
@ -647,7 +647,7 @@ public class DBTraceObject extends DBAnnotatedObject implements TraceObject {
DBTraceObject child = setter.canonicalLifeChanged;
if (child != null) {
child.emitEvents(
new TraceChangeRecord<>(TraceObjectChangeType.LIFE_CHANGED, null, child));
new TraceChangeRecord<>(TraceEvents.OBJECT_LIFE_CHANGED, null, child));
}
return result;
}

25
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/target/DBTraceObjectInterface.java
View file

@ -22,7 +22,6 @@ import ghidra.trace.database.space.DBTraceSpaceKey.DefaultDBTraceSpaceKey;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Lifespan.DefaultLifeSet;
import ghidra.trace.model.Lifespan.LifeSet;
import ghidra.trace.model.Trace.TraceObjectChangeType;
import ghidra.trace.model.TraceUniqueObject;
import ghidra.trace.model.target.*;
import ghidra.trace.util.*;
@ -50,15 +49,15 @@ public interface DBTraceObjectInterface extends TraceObjectInterface, TraceUniqu
this.iface = iface;
}
protected abstract TraceChangeType<T, Void> getAddedType();
protected abstract TraceEvent<T, Void> getAddedType();
protected abstract TraceChangeType<T, Lifespan> getLifespanChangedType();
protected abstract TraceEvent<T, Lifespan> getLifespanChangedType();
protected abstract TraceChangeType<T, ?> getChangedType();
protected abstract TraceEvent<T, ?> getChangedType();
protected abstract boolean appliesToKey(String key);
protected abstract TraceChangeType<T, Void> getDeletedType();
protected abstract TraceEvent<T, Void> getDeletedType();
protected void emitExtraAdded() {
// Extension point
@ -86,7 +85,7 @@ public interface DBTraceObjectInterface extends TraceObjectInterface, TraceUniqu
}
protected TraceChangeRecord<?, ?> translateAdded() {
TraceChangeType<T, Void> type = getAddedType();
TraceEvent<T, Void> type = getAddedType();
if (type == null) {
return null;
}
@ -95,7 +94,7 @@ public interface DBTraceObjectInterface extends TraceObjectInterface, TraceUniqu
}
protected TraceChangeRecord<?, ?> translateLifespanChanged(LifeSet oldLife) {
TraceChangeType<T, Lifespan> type = getLifespanChangedType();
TraceEvent<T, Lifespan> type = getLifespanChangedType();
if (type == null) {
return null;
}
@ -106,7 +105,7 @@ public interface DBTraceObjectInterface extends TraceObjectInterface, TraceUniqu
}
protected TraceChangeRecord<?, ?> translateDeleted(LifeSet life) {
TraceChangeType<T, Void> type = getDeletedType();
TraceEvent<T, Void> type = getDeletedType();
if (type == null) {
return null;
}
@ -115,7 +114,7 @@ public interface DBTraceObjectInterface extends TraceObjectInterface, TraceUniqu
}
public TraceChangeRecord<?, ?> translate(TraceChangeRecord<?, ?> rec) {
if (rec.getEventType() == TraceObjectChangeType.LIFE_CHANGED.getEventType()) {
if (rec.getEventType() == TraceEvents.OBJECT_LIFE_CHANGED) {
if (object.isDeleted()) {
return null;
}
@ -137,16 +136,16 @@ public interface DBTraceObjectInterface extends TraceObjectInterface, TraceUniqu
throw new AssertionError("Life changed from empty to empty?");
}
}
if (rec.getEventType() == TraceObjectChangeType.VALUE_CREATED.getEventType()) {
if (rec.getEventType() == TraceEvents.VALUE_CREATED) {
if (object.isDeleted()) {
return null;
}
TraceChangeType<T, ?> type = getChangedType();
TraceEvent<T, ?> type = getChangedType();
if (type == null) {
return null;
}
TraceChangeRecord<TraceObjectValue, Void> cast =
TraceObjectChangeType.VALUE_CREATED.cast(rec);
TraceEvents.VALUE_CREATED.cast(rec);
TraceObjectValue affected = cast.getAffectedObject();
String key = affected.getEntryKey();
if (!appliesToKey(key)) {
@ -160,7 +159,7 @@ public interface DBTraceObjectInterface extends TraceObjectInterface, TraceUniqu
cast.getNewValue());
return new TraceChangeRecord<>(type, getSpace(life), iface, null, null);
}
if (rec.getEventType() == TraceObjectChangeType.DELETED.getEventType()) {
if (rec.getEventType() == TraceEvents.OBJECT_DELETED) {
return translateDeleted(life);
}
return null;

9
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/target/DBTraceObjectManager.java
View file

@ -44,7 +44,6 @@ import ghidra.trace.database.target.visitors.SuccessorsRelativeVisitor;
import ghidra.trace.database.thread.DBTraceObjectThread;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceObjectChangeType;
import ghidra.trace.model.breakpoint.*;
import ghidra.trace.model.memory.*;
import ghidra.trace.model.modules.TraceObjectModule;
@ -57,6 +56,7 @@ import ghidra.trace.model.target.annot.TraceObjectInterfaceUtils;
import ghidra.trace.model.thread.TraceObjectThread;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.Msg;
import ghidra.util.database.*;
@ -272,8 +272,7 @@ public class DBTraceObjectManager implements TraceObjectManager, DBTraceManager
// Don't need event for root value created
return;
}
parent.emitEvents(
new TraceChangeRecord<>(TraceObjectChangeType.VALUE_CREATED, null, entry));
parent.emitEvents(new TraceChangeRecord<>(TraceEvents.VALUE_CREATED, null, entry));
}
protected InternalTraceObjectValue doCreateValue(Lifespan lifespan,
@ -305,7 +304,7 @@ public class DBTraceObjectManager implements TraceObjectManager, DBTraceManager
}
obj = objectStore.create();
obj.set(path);
obj.emitEvents(new TraceChangeRecord<>(TraceObjectChangeType.CREATED, null, obj));
obj.emitEvents(new TraceChangeRecord<>(TraceEvents.OBJECT_CREATED, null, obj));
return obj;
}
@ -461,7 +460,7 @@ public class DBTraceObjectManager implements TraceObjectManager, DBTraceManager
protected void doDeleteObject(DBTraceObject object) {
objectStore.delete(object);
object.emitEvents(new TraceChangeRecord<>(TraceObjectChangeType.DELETED, null, object));
object.emitEvents(new TraceChangeRecord<>(TraceEvents.OBJECT_DELETED, null, object));
}
protected void doDeleteEdge(DBTraceObjectValueData edge) {

12
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/target/InternalTraceObjectValue.java
View file

@ -21,10 +21,10 @@ import org.apache.commons.collections4.IterableUtils;
import ghidra.trace.database.DBTraceUtils.LifespanMapSetter;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceObjectChangeType;
import ghidra.trace.model.target.TraceObject.ConflictResolution;
import ghidra.trace.model.target.TraceObjectValue;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
interface InternalTraceObjectValue extends TraceObjectValue {
@ -119,8 +119,8 @@ interface InternalTraceObjectValue extends TraceObjectValue {
default void doSetLifespanAndEmit(Lifespan lifespan) {
Lifespan oldLifespan = getLifespan();
doSetLifespan(lifespan);
getParent().emitEvents(new TraceChangeRecord<>(
TraceObjectChangeType.VALUE_LIFESPAN_CHANGED, null, this, oldLifespan, lifespan));
getParent().emitEvents(new TraceChangeRecord<>(TraceEvents.VALUE_LIFESPAN_CHANGED, null,
this, oldLifespan, lifespan));
}
@Override
@ -157,7 +157,7 @@ interface InternalTraceObjectValue extends TraceObjectValue {
if (isObject()) {
DBTraceObject child = getChild();
child.emitEvents(
new TraceChangeRecord<>(TraceObjectChangeType.LIFE_CHANGED, null, child));
new TraceChangeRecord<>(TraceEvents.OBJECT_LIFE_CHANGED, null, child));
}
}
}
@ -167,7 +167,7 @@ interface InternalTraceObjectValue extends TraceObjectValue {
default void doDeleteAndEmit() {
DBTraceObject parent = getParent();
doDelete();
parent.emitEvents(new TraceChangeRecord<>(TraceObjectChangeType.VALUE_DELETED, null, this));
parent.emitEvents(new TraceChangeRecord<>(TraceEvents.VALUE_DELETED, null, this));
}
@Override
@ -179,7 +179,7 @@ interface InternalTraceObjectValue extends TraceObjectValue {
}
DBTraceObject child = getChildOrNull();
InternalTraceObjectValue result = doTruncateOrDelete(span);
child.emitEvents(new TraceChangeRecord<>(TraceObjectChangeType.LIFE_CHANGED, null, child));
child.emitEvents(new TraceChangeRecord<>(TraceEvents.OBJECT_LIFE_CHANGED, null, child));
return result;
}

20
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/thread/DBTraceObjectThread.java
View file

@ -23,12 +23,10 @@ import ghidra.trace.database.target.DBTraceObject;
import ghidra.trace.database.target.DBTraceObjectInterface;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceThreadChangeType;
import ghidra.trace.model.target.annot.TraceObjectInterfaceUtils;
import ghidra.trace.model.thread.TraceObjectThread;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceChangeType;
import ghidra.trace.util.*;
import ghidra.util.LockHold;
import ghidra.util.exception.DuplicateNameException;
@ -51,18 +49,18 @@ public class DBTraceObjectThread implements TraceObjectThread, DBTraceObjectInte
}
@Override
protected TraceChangeType<TraceThread, Void> getAddedType() {
return TraceThreadChangeType.ADDED;
protected TraceEvent<TraceThread, Void> getAddedType() {
return TraceEvents.THREAD_ADDED;
}
@Override
protected TraceChangeType<TraceThread, Lifespan> getLifespanChangedType() {
return TraceThreadChangeType.LIFESPAN_CHANGED;
protected TraceEvent<TraceThread, Lifespan> getLifespanChangedType() {
return TraceEvents.THREAD_LIFESPAN_CHANGED;
}
@Override
protected TraceChangeType<TraceThread, Void> getChangedType() {
return TraceThreadChangeType.CHANGED;
protected TraceEvent<TraceThread, Void> getChangedType() {
return TraceEvents.THREAD_CHANGED;
}
@Override
@ -71,8 +69,8 @@ public class DBTraceObjectThread implements TraceObjectThread, DBTraceObjectInte
}
@Override
protected TraceChangeType<TraceThread, Void> getDeletedType() {
return TraceThreadChangeType.DELETED;
protected TraceEvent<TraceThread, Void> getDeletedType() {
return TraceEvents.THREAD_DELETED;
}
}

11
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/thread/DBTraceThread.java
View file

@ -20,9 +20,9 @@ import java.io.IOException;
import db.DBRecord;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace;
import ghidra.trace.model.Trace.TraceThreadChangeType;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.*;
import ghidra.util.database.annot.*;
@ -118,7 +118,7 @@ public class DBTraceThread extends DBAnnotatedObject implements TraceThread {
this.name = name;
update(NAME_COLUMN);
manager.trace
.setChanged(new TraceChangeRecord<>(TraceThreadChangeType.CHANGED, null, this));
.setChanged(new TraceChangeRecord<>(TraceEvents.THREAD_CHANGED, null, this));
}
}
@ -155,9 +155,8 @@ public class DBTraceThread extends DBAnnotatedObject implements TraceThread {
this.lifespan = newLifespan;
manager.trace.setChanged(
new TraceChangeRecord<>(TraceThreadChangeType.LIFESPAN_CHANGED, null,
this, oldLifespan, newLifespan));
manager.trace.setChanged(new TraceChangeRecord<>(TraceEvents.THREAD_LIFESPAN_CHANGED,
null, this, oldLifespan, newLifespan));
}
}
@ -172,7 +171,7 @@ public class DBTraceThread extends DBAnnotatedObject implements TraceThread {
this.comment = comment;
update(COMMENT_COLUMN);
manager.trace
.setChanged(new TraceChangeRecord<>(TraceThreadChangeType.CHANGED, null, this));
.setChanged(new TraceChangeRecord<>(TraceEvents.THREAD_CHANGED, null, this));
}
}

6
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/thread/DBTraceThreadManager.java
View file

@ -26,9 +26,9 @@ import ghidra.trace.database.DBTraceManager;
import ghidra.trace.database.target.DBTraceObject;
import ghidra.trace.database.target.DBTraceObjectManager;
import ghidra.trace.model.Lifespan;
import ghidra.trace.model.Trace.TraceThreadChangeType;
import ghidra.trace.model.thread.*;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.*;
import ghidra.util.exception.DuplicateNameException;
@ -122,7 +122,7 @@ public class DBTraceThreadManager implements TraceThreadManager, DBTraceManager
thread = threadStore.create();
thread.set(path, display, lifespan);
}
trace.setChanged(new TraceChangeRecord<>(TraceThreadChangeType.ADDED, null, thread));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.THREAD_ADDED, null, thread));
return thread;
}
@ -192,6 +192,6 @@ public class DBTraceThreadManager implements TraceThreadManager, DBTraceManager
public void deleteThread(DBTraceThread thread) {
threadStore.delete(thread);
trace.setChanged(new TraceChangeRecord<>(TraceThreadChangeType.DELETED, null, thread));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.THREAD_DELETED, null, thread));
}
}

8
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/time/DBTraceTimeManager.java
View file

@ -25,11 +25,11 @@ import db.DBHandle;
import ghidra.trace.database.DBTrace;
import ghidra.trace.database.DBTraceManager;
import ghidra.trace.database.thread.DBTraceThreadManager;
import ghidra.trace.model.Trace.TraceSnapshotChangeType;
import ghidra.trace.model.time.TraceSnapshot;
import ghidra.trace.model.time.TraceTimeManager;
import ghidra.trace.model.time.schedule.TraceSchedule;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.*;
import ghidra.util.exception.VersionException;
@ -70,17 +70,17 @@ public class DBTraceTimeManager implements TraceTimeManager, DBTraceManager {
protected void notifySnapshotAdded(DBTraceSnapshot snapshot) {
trace.updateViewportsSnapshotAdded(snapshot);
trace.setChanged(new TraceChangeRecord<>(TraceSnapshotChangeType.ADDED, null, snapshot));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.SNAPSHOT_ADDED, null, snapshot));
}
protected void notifySnapshotChanged(DBTraceSnapshot snapshot) {
trace.updateViewportsSnapshotChanged(snapshot);
trace.setChanged(new TraceChangeRecord<>(TraceSnapshotChangeType.CHANGED, null, snapshot));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.SNAPSHOT_CHANGED, null, snapshot));
}
protected void notifySnapshotDeleted(DBTraceSnapshot snapshot) {
trace.updateViewportsSnapshotDeleted(snapshot);
trace.setChanged(new TraceChangeRecord<>(TraceSnapshotChangeType.DELETED, null, snapshot));
trace.setChanged(new TraceChangeRecord<>(TraceEvents.SNAPSHOT_DELETED, null, snapshot));
}
@Override

328
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/model/Trace.java
View file

@ -15,40 +15,38 @@
*/
package ghidra.trace.model;
import java.util.*;
import java.util.Collection;
import javax.swing.Icon;
import generic.theme.GIcon;
import ghidra.program.model.address.*;
import ghidra.program.model.data.*;
import ghidra.lifecycle.Transitional;
import ghidra.program.model.address.AddressFactory;
import ghidra.program.model.data.DataTypeManagerDomainObject;
import ghidra.program.model.lang.CompilerSpec;
import ghidra.program.model.lang.Language;
import ghidra.program.model.listing.*;
import ghidra.program.model.symbol.SourceType;
import ghidra.trace.model.bookmark.*;
import ghidra.program.model.listing.Program;
import ghidra.trace.model.bookmark.TraceBookmarkManager;
import ghidra.trace.model.breakpoint.TraceBreakpoint;
import ghidra.trace.model.breakpoint.TraceBreakpointManager;
import ghidra.trace.model.context.TraceRegisterContextManager;
import ghidra.trace.model.data.TraceBasedDataTypeManager;
import ghidra.trace.model.guest.*;
import ghidra.trace.model.listing.*;
import ghidra.trace.model.memory.*;
import ghidra.trace.model.guest.TracePlatformManager;
import ghidra.trace.model.listing.TraceCodeManager;
import ghidra.trace.model.listing.TraceCodeUnit;
import ghidra.trace.model.memory.TraceMemoryManager;
import ghidra.trace.model.modules.*;
import ghidra.trace.model.program.TraceProgramView;
import ghidra.trace.model.program.TraceVariableSnapProgramView;
import ghidra.trace.model.property.TraceAddressPropertyManager;
import ghidra.trace.model.stack.TraceStack;
import ghidra.trace.model.stack.TraceStackManager;
import ghidra.trace.model.symbol.*;
import ghidra.trace.model.target.*;
import ghidra.trace.model.target.TraceObjectManager;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.model.thread.TraceThreadManager;
import ghidra.trace.model.time.TraceSnapshot;
import ghidra.trace.model.time.TraceTimeManager;
import ghidra.trace.util.DefaultTraceChangeType;
import ghidra.util.LockHold;
import ghidra.util.UniversalID;
/**
* An indexed record of observations over the course of a target's execution
@ -70,313 +68,11 @@ public interface Trace extends DataTypeManagerDomainObject {
* @param trace the trace, or null
* @return true if the trace is non-null and has no root schema
*/
@Transitional
public static boolean isLegacy(Trace trace) {
return trace != null && trace.getObjectManager().getRootSchema() == null;
}
public static final class TraceObjectChangeType<T, U> extends DefaultTraceChangeType<T, U> {
/**
* An object was created, but not yet inserted.
*
* <p>
* Between the {@link #CREATED} event and the first {@link #LIFE_CHANGED} event, an object
* is considered "incomplete," because it is likely missing its attributes. Thus, a trace
* client must take care to ensure all attributes, especially fixed attributes, are added to
* the object before it is inserted at its canonical path. Listeners may use
* {@link TraceObject#getCanonicalParent(long)} to check if an object is complete for a
* given snapshot.
*/
public static final TraceObjectChangeType<TraceObject, Void> CREATED =
new TraceObjectChangeType<>();
/**
* An object's life changed.
*
* <p>
* One of its canonical parents was created, deleted, or had its lifespan change.
*/
public static final TraceObjectChangeType<TraceObject, Void> LIFE_CHANGED =
new TraceObjectChangeType<>();
/**
* An object was deleted.
*/
public static final TraceObjectChangeType<TraceObject, Void> DELETED =
new TraceObjectChangeType<>();
/**
* A value entry was created.
*/
public static final TraceObjectChangeType<TraceObjectValue, Void> VALUE_CREATED =
new TraceObjectChangeType<>();
/**
* A value entry changed in lifespan.
*/
public static final TraceObjectChangeType<TraceObjectValue, Lifespan> //
VALUE_LIFESPAN_CHANGED = new TraceObjectChangeType<>();
/**
* A value entry was deleted.
*/
public static final TraceObjectChangeType<TraceObjectValue, Void> VALUE_DELETED =
new TraceObjectChangeType<>();
}
public static final class TraceBookmarkChangeType<T, U> extends DefaultTraceChangeType<T, U> {
public static final TraceBookmarkChangeType<TraceBookmarkType, Void> TYPE_ADDED =
new TraceBookmarkChangeType<>();
public static final TraceBookmarkChangeType<TraceBookmark, Void> ADDED =
new TraceBookmarkChangeType<>();
public static final TraceBookmarkChangeType<TraceBookmark, Void> CHANGED =
new TraceBookmarkChangeType<>();
public static final TraceBookmarkChangeType<TraceBookmark, Lifespan> LIFESPAN_CHANGED =
new TraceBookmarkChangeType<>();
public static final TraceBookmarkChangeType<TraceBookmark, Void> DELETED =
new TraceBookmarkChangeType<>();
}
public static final class TraceBreakpointChangeType<U>
extends DefaultTraceChangeType<TraceBreakpoint, U> {
public static final TraceBreakpointChangeType<Void> ADDED =
new TraceBreakpointChangeType<>();
public static final TraceBreakpointChangeType<Void> CHANGED =
new TraceBreakpointChangeType<>();
public static final TraceBreakpointChangeType<Lifespan> LIFESPAN_CHANGED =
new TraceBreakpointChangeType<>();
public static final TraceBreakpointChangeType<Void> DELETED =
new TraceBreakpointChangeType<>();
}
public static final class TraceCategoryChangeType<U> extends DefaultTraceChangeType<Long, U> {
// Long is category ID
public static final TraceCategoryChangeType<Category> ADDED =
new TraceCategoryChangeType<>();
public static final TraceCategoryChangeType<CategoryPath> MOVED =
new TraceCategoryChangeType<>();
public static final TraceCategoryChangeType<String> RENAMED =
new TraceCategoryChangeType<>();
public static final TraceCategoryChangeType<CategoryPath> DELETED =
new TraceCategoryChangeType<>();
}
public static final class TraceCodeChangeType<T, U> extends DefaultTraceChangeType<T, U> {
// May be a single unit or a whole block. "newValue" is first unit
public static final TraceCodeChangeType<TraceAddressSnapRange, TraceCodeUnit> ADDED =
new TraceCodeChangeType<>();
public static final TraceCodeChangeType<TraceCodeUnit, Lifespan> LIFESPAN_CHANGED =
new TraceCodeChangeType<>();
// May be a single unit or a coalesced range. "oldValue" is null or first unit
public static final TraceCodeChangeType<TraceAddressSnapRange, TraceCodeUnit> REMOVED =
new TraceCodeChangeType<>();
// TODO: Probably make a TraceFragment?
// TODO: Probably a separate change type for tree changes
public static final TraceCodeChangeType<TraceAddressSnapRange, ProgramFragment> FRAGMENT_CHANGED =
new TraceCodeChangeType<>();
// Long is data type ID
public static final TraceCodeChangeType<TraceAddressSnapRange, Long> DATA_TYPE_REPLACED =
new TraceCodeChangeType<>();
public static final TraceCodeChangeType<TraceAddressSnapRange, Void> DATA_TYPE_SETTINGS_CHANGED =
new TraceCodeChangeType<>();
}
public static final class TraceCommentChangeType
extends DefaultTraceChangeType<TraceAddressSnapRange, String> {
private static final Map<Integer, TraceCommentChangeType> BY_TYPE = new HashMap<>();
public static final TraceCommentChangeType PLATE_CHANGED =
new TraceCommentChangeType(CodeUnit.PLATE_COMMENT);
public static final TraceCommentChangeType PRE_CHANGED =
new TraceCommentChangeType(CodeUnit.PRE_COMMENT);
public static final TraceCommentChangeType POST_CHANGED =
new TraceCommentChangeType(CodeUnit.POST_COMMENT);
public static final TraceCommentChangeType EOL_CHANGED =
new TraceCommentChangeType(CodeUnit.EOL_COMMENT);
public static final TraceCommentChangeType REPEATABLE_CHANGED =
new TraceCommentChangeType(CodeUnit.REPEATABLE_COMMENT);
public static TraceCommentChangeType byType(int type) {
return Objects.requireNonNull(BY_TYPE.get(type));
}
public final int type;
private TraceCommentChangeType(int type) {
this.type = type;
BY_TYPE.put(type, this);
}
}
public static final class TraceCompositeDataChangeType<T, U>
extends DefaultTraceChangeType<T, U> {
public static final TraceCompositeDataChangeType<TraceAddressSnapRange, TraceData> ADDED =
new TraceCompositeDataChangeType<>();
public static final TraceCompositeDataChangeType<TraceData, Lifespan> LIFESPAN_CHANGED =
new TraceCompositeDataChangeType<>();
public static final TraceCompositeDataChangeType<TraceAddressSnapRange, TraceData> REMOVED =
new TraceCompositeDataChangeType<>();
}
public static final class TraceDataTypeChangeType<U> extends DefaultTraceChangeType<Long, U> {
public static final TraceDataTypeChangeType<DataType> ADDED =
new TraceDataTypeChangeType<>();
// Old is null
public static final TraceDataTypeChangeType<DataType> CHANGED =
new TraceDataTypeChangeType<>();
public static final TraceDataTypeChangeType<DataTypePath> REPLACED =
new TraceDataTypeChangeType<>();
public static final TraceDataTypeChangeType<DataTypePath> MOVED =
new TraceDataTypeChangeType<>();
public static final TraceDataTypeChangeType<String> RENAMED =
new TraceDataTypeChangeType<>();
public static final TraceDataTypeChangeType<DataTypePath> DELETED =
new TraceDataTypeChangeType<>();
}
public static final class TraceInstructionChangeType<U>
extends DefaultTraceChangeType<TraceInstruction, U> {
public static final TraceInstructionChangeType<FlowOverride> FLOW_OVERRIDE_CHANGED =
new TraceInstructionChangeType<>();
public static final TraceInstructionChangeType<Boolean> FALL_THROUGH_OVERRIDE_CHANGED =
new TraceInstructionChangeType<>();
public static final TraceInstructionChangeType<Integer> LENGTH_OVERRIDE_CHANGED =
new TraceInstructionChangeType<>();
}
public static final class TraceMemoryBytesChangeType
extends DefaultTraceChangeType<TraceAddressSnapRange, byte[]> {
// byte array may be larger than actual change
public static final TraceMemoryBytesChangeType CHANGED = new TraceMemoryBytesChangeType();
}
public static final class TraceMemoryRegionChangeType<U>
extends DefaultTraceChangeType<TraceMemoryRegion, U> {
public static final TraceMemoryRegionChangeType<Void> ADDED =
new TraceMemoryRegionChangeType<>();
public static final TraceMemoryRegionChangeType<Void> CHANGED =
new TraceMemoryRegionChangeType<>();
public static final TraceMemoryRegionChangeType<Lifespan> LIFESPAN_CHANGED =
new TraceMemoryRegionChangeType<>();
public static final TraceMemoryRegionChangeType<Void> DELETED =
new TraceMemoryRegionChangeType<>();
// NOTE: No MOVING, SPLITTING, or JOINING
}
public static final class TraceOverlaySpaceChangeType
extends DefaultTraceChangeType<Trace, AddressSpace> {
public static final TraceOverlaySpaceChangeType ADDED = new TraceOverlaySpaceChangeType();
public static final TraceOverlaySpaceChangeType DELETED = new TraceOverlaySpaceChangeType();
}
public static final class TraceMemoryStateChangeType<U>
extends DefaultTraceChangeType<TraceAddressSnapRange, U> {
public static final TraceMemoryStateChangeType<TraceMemoryState> CHANGED =
new TraceMemoryStateChangeType<>();
}
public static final class TraceModuleChangeType<U>
extends DefaultTraceChangeType<TraceModule, U> {
public static final TraceModuleChangeType<Void> ADDED = new TraceModuleChangeType<>();
public static final TraceModuleChangeType<Void> CHANGED = new TraceModuleChangeType<>();
public static final TraceModuleChangeType<Lifespan> LIFESPAN_CHANGED =
new TraceModuleChangeType<>();
// NOTE: module's sections will have been deleted, without events
public static final TraceModuleChangeType<Void> DELETED = new TraceModuleChangeType<>();
}
public static final class TraceReferenceChangeType<T, U> extends DefaultTraceChangeType<T, U> {
public static final TraceReferenceChangeType<TraceAddressSnapRange, TraceReference> ADDED =
new TraceReferenceChangeType<>();
public static final TraceReferenceChangeType<TraceReference, Lifespan> LIFESPAN_CHANGED =
new TraceReferenceChangeType<>();
public static final TraceReferenceChangeType<TraceReference, Boolean> PRIMARY_CHANGED =
new TraceReferenceChangeType<>();
public static final TraceReferenceChangeType<TraceAddressSnapRange, TraceReference> DELETED =
new TraceReferenceChangeType<>();
}
public static final class TraceSectionChangeType<U>
extends DefaultTraceChangeType<TraceSection, U> {
public static final TraceSectionChangeType<Void> ADDED = new TraceSectionChangeType<>();
public static final TraceSectionChangeType<Void> CHANGED = new TraceSectionChangeType<>();
public static final TraceSectionChangeType<Void> DELETED = new TraceSectionChangeType<>();
}
public static final class TraceStackChangeType<U>
extends DefaultTraceChangeType<TraceStack, U> {
public static final TraceStackChangeType<Void> ADDED = new TraceStackChangeType<>();
/**
* NOTE: The "new value" is the (min) snap where the change occurred. For StackFrame, it's
* Stack.getSnap(), for ObjectStackFrame, the min snap of the value entry. The "old value"
* is always 0.
*/
public static final TraceStackChangeType<Long> CHANGED = new TraceStackChangeType<>();
public static final TraceStackChangeType<Void> DELETED = new TraceStackChangeType<>();
}
public static final class TraceStaticMappingChangeType<U>
extends DefaultTraceChangeType<TraceStaticMapping, U> {
public static final TraceStaticMappingChangeType<Void> ADDED =
new TraceStaticMappingChangeType<>();
public static final TraceStaticMappingChangeType<Void> DELETED =
new TraceStaticMappingChangeType<>();
}
public static final class TraceSourceArchiveChangeType<U>
extends DefaultTraceChangeType<UniversalID, U> {
public static final TraceSourceArchiveChangeType<Void> ADDED =
new TraceSourceArchiveChangeType<>();
public static final TraceSourceArchiveChangeType<Void> CHANGED =
new TraceSourceArchiveChangeType<>();
// TODO: Unused???
public static final TraceSourceArchiveChangeType<Void> DELETED =
new TraceSourceArchiveChangeType<>();
}
public static final class TraceSymbolChangeType<U>
extends DefaultTraceChangeType<TraceSymbol, U> {
public static final TraceSymbolChangeType<Void> ADDED = new TraceSymbolChangeType<>();
public static final TraceSymbolChangeType<SourceType> SOURCE_CHANGED =
new TraceSymbolChangeType<>();
public static final TraceSymbolChangeType<TraceSymbol> SET_AS_PRIMARY =
new TraceSymbolChangeType<>();
public static final TraceSymbolChangeType<String> RENAMED = new TraceSymbolChangeType<>();
public static final TraceSymbolChangeType<TraceNamespaceSymbol> PARENT_CHANGED =
new TraceSymbolChangeType<>();
public static final TraceSymbolChangeType<TraceReference> ASSOCIATION_ADDED =
new TraceSymbolChangeType<>();
public static final TraceSymbolChangeType<TraceReference> ASSOCIATION_REMOVED =
new TraceSymbolChangeType<>();
public static final TraceSymbolChangeType<Address> ADDRESS_CHANGED =
new TraceSymbolChangeType<>();
public static final DefaultTraceChangeType<TraceSymbolWithLifespan, Lifespan> LIFESPAN_CHANGED =
new DefaultTraceChangeType<>();
public static final TraceSymbolChangeType<Void> DELETED = new TraceSymbolChangeType<>();
// Other changes not captured above
public static final TraceSymbolChangeType<Void> CHANGED = new TraceSymbolChangeType<>();
}
public static final class TraceThreadChangeType<U>
extends DefaultTraceChangeType<TraceThread, U> {
public static final TraceThreadChangeType<Void> ADDED = new TraceThreadChangeType<>();
public static final TraceThreadChangeType<Void> CHANGED = new TraceThreadChangeType<>();
public static final TraceThreadChangeType<Lifespan> LIFESPAN_CHANGED =
new TraceThreadChangeType<>();
public static final TraceThreadChangeType<Void> DELETED = new TraceThreadChangeType<>();
}
public static final class TraceSnapshotChangeType<U>
extends DefaultTraceChangeType<TraceSnapshot, U> {
public static final TraceSnapshotChangeType<Void> ADDED = new TraceSnapshotChangeType<>();
public static final TraceSnapshotChangeType<Void> CHANGED = new TraceSnapshotChangeType<>();
public static final TraceSnapshotChangeType<Void> DELETED = new TraceSnapshotChangeType<>();
}
public static final class TracePlatformChangeType<U>
extends DefaultTraceChangeType<TraceGuestPlatform, U> {
public static final TracePlatformChangeType<Void> ADDED = new TracePlatformChangeType<>();
public static final TracePlatformChangeType<Void> DELETED = new TracePlatformChangeType<>();
public static final TracePlatformChangeType<TraceGuestPlatformMappedRange> MAPPING_ADDED =
new TracePlatformChangeType<>();
public static final TracePlatformChangeType<TraceGuestPlatformMappedRange> MAPPING_DELETED =
new TracePlatformChangeType<>();
}
public interface TraceProgramViewListener {
void viewCreated(TraceProgramView view);
}

1
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/model/TraceDomainObjectListener.java
View file

@ -16,6 +16,7 @@
package ghidra.trace.model;
import ghidra.framework.model.*;
import ghidra.trace.util.TypedEventDispatcher;
public class TraceDomainObjectListener extends TypedEventDispatcher
implements DomainObjectListener {

114
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/util/DefaultTraceChangeType.java
View file

@ -1,114 +0,0 @@
/* ###
* 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.trace.util;
import java.lang.reflect.Field;
import java.lang.reflect.Modifier;
import java.util.*;
import ghidra.framework.model.DomainObjectChangeRecord;
/**
* A trace change type, assigned a number at runtime
*
* @param <T> the type of object changed
* @param <U> the type of the object's attribute that changed
*/
public class DefaultTraceChangeType<T, U> implements TraceChangeType<T, U> {
private static final Map<TraceEventType, String> TYPE_NAMES = new HashMap<>();
private static final Set<Field> FIELD_BACKLOG = new HashSet<>();
private static void procType(Field f, TraceChangeType<?, ?> type) {
String kind = f.getDeclaringClass().getSimpleName();
if (kind.startsWith("Trace")) {
kind = kind.substring("Trace".length());
}
if (kind.endsWith("ChangeType")) {
kind = kind.substring(0, kind.length() - "ChangeType".length());
}
TYPE_NAMES.put(type.getEventType(), kind + "." + f.getName());
}
private static <C extends TraceChangeType<?, ?>> void procField(Field f, Class<C> cls,
boolean isBacklog) {
int mods = f.getModifiers();
if (!Modifier.isStatic(mods) || !Modifier.isFinal(mods)) {
return;
}
if (!cls.isAssignableFrom(f.getType())) {
return;
}
C type;
try {
type = cls.cast(f.get(null));
}
catch (IllegalArgumentException | IllegalAccessException e) {
throw new AssertionError(e);
}
if (type != null) {
procType(f, type);
}
else if (isBacklog) {
throw new AssertionError();
}
else {
FIELD_BACKLOG.add(f);
}
}
@SuppressWarnings("unchecked")
private static void procBacklog() {
for (Iterator<Field> fit = FIELD_BACKLOG.iterator(); fit.hasNext();) {
Field f = fit.next();
procField(f, (Class<? extends TraceChangeType<?, ?>>) f.getType(), true);
fit.remove();
}
}
private static <C extends TraceChangeType<?, ?>> void scanTypeNames(Class<C> cls) {
for (Field f : cls.getFields()) {
procField(f, cls, false);
}
}
public static String getName(int type) {
procBacklog();
String name = TYPE_NAMES.get(type);
if (name != null) {
return name;
}
return "TYPE_0x" + Integer.toHexString(type);
}
private final TraceEventType eventType;
public DefaultTraceChangeType() {
this.eventType = new TraceEventType(getClass().getSimpleName());
scanTypeNames(getClass());
}
@Override
public TraceEventType getEventType() {
return eventType;
}
@SuppressWarnings("unchecked")
public TraceChangeRecord<T, U> cast(DomainObjectChangeRecord rec) {
return (TraceChangeRecord<T, U>) rec;
}
}

25
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/util/TraceChangeRecord.java
View file

@ -20,50 +20,41 @@ import ghidra.framework.model.DomainObjectChangeRecord;
public class TraceChangeRecord<T, U> extends DomainObjectChangeRecord {
private static final long serialVersionUID = 1;
private final TraceChangeType<T, U> type;
private final TraceAddressSpace space;
private final T affectedObject;
private final boolean oldKnown;
public TraceChangeRecord(TraceChangeType<T, U> type, TraceAddressSpace space, T affectedObject,
public TraceChangeRecord(TraceEvent<T, U> type, TraceAddressSpace space, T affectedObject,
U oldValue, U newValue) {
super(type.getEventType(), oldValue, newValue);
this.type = type;
super(type, oldValue, newValue);
this.space = space;
this.affectedObject = affectedObject;
this.oldKnown = true;
}
public TraceChangeRecord(TraceChangeType<T, U> type, TraceAddressSpace space, T affectedObject,
public TraceChangeRecord(TraceEvent<T, U> type, TraceAddressSpace space, T affectedObject,
U newValue) {
super(type.getEventType(), null, newValue);
this.type = type;
super(type, null, newValue);
this.space = space;
this.affectedObject = affectedObject;
this.oldKnown = false;
}
public TraceChangeRecord(TraceChangeType<T, U> type, TraceAddressSpace space,
public TraceChangeRecord(TraceEvent<T, U> type, TraceAddressSpace space,
T affectedObject) {
super(type.getEventType(), null, null);
this.type = type;
super(type, null, null);
this.space = space;
this.affectedObject = affectedObject;
this.oldKnown = false;
}
public TraceChangeRecord(TraceChangeType<T, U> type, TraceAddressSpace space) {
super(type.getEventType(), null, null);
this.type = type;
public TraceChangeRecord(TraceEvent<T, U> type, TraceAddressSpace space) {
super(type, null, null);
this.space = space;
this.affectedObject = null;
this.oldKnown = false;
}
public TraceChangeType<T, U> getType() {
return type;
}
public TraceAddressSpace getSpace() {
return space;
}

20
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/util/TraceChangeType.java
View file

@ -1,20 +0,0 @@
/* ###
* 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.trace.util;
public interface TraceChangeType<T, U> {
TraceEventType getEventType();
}

662
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/util/TraceEvent.java Normal file
View file

@ -0,0 +1,662 @@
/* ###
* 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.trace.util;
import ghidra.framework.model.*;
import ghidra.program.model.address.Address;
import ghidra.program.model.address.AddressSpace;
import ghidra.program.model.data.*;
import ghidra.program.model.listing.FlowOverride;
import ghidra.program.model.listing.ProgramFragment;
import ghidra.program.model.symbol.SourceType;
import ghidra.trace.model.*;
import ghidra.trace.model.bookmark.TraceBookmark;
import ghidra.trace.model.bookmark.TraceBookmarkType;
import ghidra.trace.model.breakpoint.TraceBreakpoint;
import ghidra.trace.model.guest.TraceGuestPlatform;
import ghidra.trace.model.guest.TraceGuestPlatformMappedRange;
import ghidra.trace.model.listing.*;
import ghidra.trace.model.memory.TraceMemoryRegion;
import ghidra.trace.model.memory.TraceMemoryState;
import ghidra.trace.model.modules.*;
import ghidra.trace.model.stack.TraceStack;
import ghidra.trace.model.symbol.*;
import ghidra.trace.model.target.TraceObject;
import ghidra.trace.model.target.TraceObjectValue;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.model.time.TraceSnapshot;
import ghidra.trace.util.TypedEventDispatcher.FullEventRecordHandler;
import ghidra.util.UniversalID;
/**
* A sub-type for event specific to traces.
*
* <p>
* For the various defined events, see {@link TraceEvents}.
*
* <p>
* This interface introduces two type parameters, which are provided by each trace event enum. They
* describe the type of the effected object, e.g., a thread, as well as the type of the changed
* value, e.g., its lifespan. These are can be enforced by using {@link TraceChangeRecord}. Its
* constructors will ensure that the affected object and values actually match the types for the
* given trace event. Conversely, by using {@link TraceDomainObjectListener} and registering
* handlers for each event type, it will ensure each handler method accepts arguments of the correct
* types. See, e.g., {@link TypedEventDispatcher#listenFor(TraceEvent, FullEventRecordHandler)}.
*
* @param <T> the type of the object changed
* @param <U> the type of the value
*/
public interface TraceEvent<T, U> extends EventType {
/**
* Cast a change record to one with object/affected value types for this event
*
* @param rec the untyped record
* @return the typed record
*/
@SuppressWarnings("unchecked")
default TraceChangeRecord<T, U> cast(DomainObjectChangeRecord rec) {
return (TraceChangeRecord<T, U>) rec;
}
enum TraceObjectEvent implements TraceEvent<TraceObject, Void> {
OBJECT_CREATED, OBJECT_LIFE_CHANGED, OBJECT_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceObjectValueEvent implements TraceEvent<TraceObjectValue, Void> {
VALUE_CREATED, VALUE_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceObjectValueLifespanEvent implements TraceEvent<TraceObjectValue, Lifespan> {
VALUE_LIFESPAN_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceBookmarkTypeEvent implements TraceEvent<TraceBookmarkType, Void> {
BOOKMARK_TYPE_ADDED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceBookmarkEvent implements TraceEvent<TraceBookmark, Void> {
BOOKMARK_ADDED, BOOKMARK_CHANGED, BOOKMARK_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceBookmarkLifespanEvent implements TraceEvent<TraceBookmark, Lifespan> {
BOOKMARK_LIFESPAN_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceBreakpointEvent implements TraceEvent<TraceBreakpoint, Void> {
BREAKPOINT_ADDED, BREAKPOINT_CHANGED, BREAKPOINT_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceBreakpointLifespanEvent implements TraceEvent<TraceBreakpoint, Lifespan> {
BREAKPOINT_LIFESPAN_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceTypeCategoryEvent implements TraceEvent<Long, Category> {
TYPE_CATEGORY_ADDED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceTypeCategoryPathEvent implements TraceEvent<Long, CategoryPath> {
TYPE_CATEGORY_MOVED, TYPE_CATEGORY_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceTypeCategoryStringEvent implements TraceEvent<Long, String> {
TYPE_CATEGORY_RENAMED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceCodeEvent implements TraceEvent<TraceAddressSnapRange, TraceCodeUnit> {
CODE_ADDED, CODE_REMOVED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceCodeLifespanEvent implements TraceEvent<TraceCodeUnit, Lifespan> {
CODE_LIFESPAN_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceCodeFragmentEvent implements TraceEvent<TraceAddressSnapRange, ProgramFragment> {
CODE_FRAGMENT_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceCodeDataTypeEvent implements TraceEvent<TraceAddressSnapRange, Long> {
CODE_DATA_TYPE_REPLACED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceCodeDataSettingsEvent implements TraceEvent<TraceAddressSnapRange, Void> {
CODE_DATA_SETTINGS_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceCommentEvent implements TraceEvent<TraceAddressSnapRange, String> {
PLATE_COMMENT_CHANGED,
PRE_COMMENT_CHANGED,
POST_COMMENT_CHANGED,
EOL_COMMENT_CHANGED,
REPEATABLE_COMMENT_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceCompositeDataEvent implements TraceEvent<TraceAddressSnapRange, TraceData> {
COMPOSITE_DATA_ADDED, COMPOSITE_DATA_REMOVED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceCompositeDataLifespanEvent implements TraceEvent<TraceData, Lifespan> {
COMPOSITE_DATA_LIFESPAN_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceDataTypeEvent implements TraceEvent<Long, DataType> {
DATA_TYPE_ADDED, DATA_TYPE_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceDataTypePathEvent implements TraceEvent<Long, DataTypePath> {
DATA_TYPE_REPLACED, DATA_TYPE_MOVED, DATA_TYPE_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceDataTypeStringEvent implements TraceEvent<Long, String> {
DATA_TYPE_RENAMED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceInstructionFlowEvent implements TraceEvent<TraceInstruction, FlowOverride> {
INSTRUCTION_FLOW_OVERRIDE_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceInstructionBoolEvent implements TraceEvent<TraceInstruction, Boolean> {
INSTRUCTION_FALL_THROUGH_OVERRIDE_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceInstructionIntEvent implements TraceEvent<TraceInstruction, Integer> {
INSTRUCTION_LENGTH_OVERRIDE_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceBytesEvent implements TraceEvent<TraceAddressSnapRange, byte[]> {
BYTES_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceMemoryRegionEvent implements TraceEvent<TraceMemoryRegion, Void> {
REGION_ADDED, REGION_CHANGED, REGION_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceMemoryRegionLifespanEvent implements TraceEvent<TraceMemoryRegion, Lifespan> {
REGION_LIFESPAN_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceOverlaySpaceEvent implements TraceEvent<Trace, AddressSpace> {
OVERLAY_ADDED, OVERLAY_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceMemoryStateEvent implements TraceEvent<TraceAddressSnapRange, TraceMemoryState> {
BYTES_STATE_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceModuleEvent implements TraceEvent<TraceModule, Void> {
MODULE_ADDED, MODULE_CHANGED, MODULE_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceModuleLifespanEvent implements TraceEvent<TraceModule, Lifespan> {
MODULE_LIFESPAN_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceSectionEvent implements TraceEvent<TraceSection, Void> {
SECTION_ADDED, SECTION_CHANGED, SECTION_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceReferenceEvent implements TraceEvent<TraceAddressSnapRange, TraceReference> {
REFERENCE_ADDED, REFERENCE_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceReferenceLifespanEvent implements TraceEvent<TraceReference, Lifespan> {
REFERENCE_LIFESPAN_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceReferenceBoolEvent implements TraceEvent<TraceReference, Boolean> {
REFERENCE_PRIMARY_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceStackEvent implements TraceEvent<TraceStack, Void> {
STACK_ADDED, STACK_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceStackLongEvent implements TraceEvent<TraceStack, Long> {
STACK_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceMappingEvent implements TraceEvent<TraceStaticMapping, Void> {
MAPPING_ADDED, MAPPING_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceTypeArchiveEvent implements TraceEvent<UniversalID, Void> {
SOURCE_TYPE_ARCHIVE_ADDED, SOURCE_TYPE_ARCHIVE_CHANGED, SOURCE_TYPE_ARCHIVE_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceSymbolEvent implements TraceEvent<TraceSymbol, Void> {
SYMBOL_ADDED, SYMBOL_CHANGED, SYMBOL_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceSymbolSourceEvent implements TraceEvent<TraceSymbol, SourceType> {
SYMBOL_SOURCE_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceSymbolSymEvent implements TraceEvent<TraceSymbol, TraceSymbol> {
SYMBOL_PRIMARY_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceSymbolStringEvent implements TraceEvent<TraceSymbol, String> {
SYMBOL_RENAMED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceSymbolNamespaceEvent implements TraceEvent<TraceSymbol, TraceNamespaceSymbol> {
SYMBOL_PARENT_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceSymbolRefEvent implements TraceEvent<TraceSymbol, TraceReference> {
SYMBOL_ASSOCIATION_ADDED, SYMBOL_ASSOCIATION_REMOVED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceSymbolAddressEvent implements TraceEvent<TraceSymbol, Address> {
SYMBOL_ADDRESS_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceSymbolLifespanEvent implements TraceEvent<TraceSymbolWithLifespan, Lifespan> {
SYMBOL_LIFESPAN_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceThreadEvent implements TraceEvent<TraceThread, Void> {
THREAD_ADDED, THREAD_CHANGED, THREAD_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceThreadLifespanEvent implements TraceEvent<TraceThread, Lifespan> {
THREAD_LIFESPAN_CHANGED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TraceSnapshotEvent implements TraceEvent<TraceSnapshot, Void> {
SNAPSHOT_ADDED, SNAPSHOT_CHANGED, SNAPSHOT_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TracePlatformEvent implements TraceEvent<TraceGuestPlatform, Void> {
PLATFORM_ADDED, PLATFORM_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
enum TracePlatformMappingEvent
implements TraceEvent<TraceGuestPlatform, TraceGuestPlatformMappedRange> {
PLATFORM_MAPPING_ADDED, PLATFORM_MAPPING_DELETED;
private final int id = DomainObjectEventIdGenerator.next();
@Override
public int getId() {
return id;
}
}
}

45
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/util/TraceEventType.java
View file

@ -1,45 +0,0 @@
/* ###
* 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.trace.util;
import ghidra.framework.model.DomainObjectEventIdGenerator;
import ghidra.framework.model.EventType;
/**
* EventTypes for trace events. This implementation exists because trace event types are not
* currently structured as enums. This current implementation will not give a very good toString as
* its actual event name is unknown, so it uses its event category class + its actual assigned
* numerical id.
*/
public class TraceEventType implements EventType {
private final int id = DomainObjectEventIdGenerator.next();
private String name;
TraceEventType(String name) {
this.name = name + "(" + id + ")";
}
@Override
public int getId() {
return id;
}
@Override
public String toString() {
return name;
}
}

331
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/util/TraceEvents.java Normal file
View file

@ -0,0 +1,331 @@
/* ###
* 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.trace.util;
import ghidra.docking.settings.Settings;
import ghidra.program.model.address.AddressSpace;
import ghidra.program.model.data.*;
import ghidra.program.model.listing.CodeUnit;
import ghidra.program.model.listing.ProgramFragment;
import ghidra.trace.model.Trace;
import ghidra.trace.model.bookmark.TraceBookmark;
import ghidra.trace.model.bookmark.TraceBookmarkType;
import ghidra.trace.model.breakpoint.TraceBreakpoint;
import ghidra.trace.model.guest.TraceGuestPlatform;
import ghidra.trace.model.guest.TraceGuestPlatformMappedRange;
import ghidra.trace.model.listing.*;
import ghidra.trace.model.memory.TraceMemoryRegion;
import ghidra.trace.model.modules.*;
import ghidra.trace.model.stack.TraceStack;
import ghidra.trace.model.symbol.TraceReference;
import ghidra.trace.model.symbol.TraceSymbol;
import ghidra.trace.model.target.TraceObject;
import ghidra.trace.model.target.TraceObjectValue;
import ghidra.trace.model.thread.TraceThread;
import ghidra.trace.model.time.TraceSnapshot;
import ghidra.trace.util.TraceEvent.*;
public interface TraceEvents {
/**
* A {@link TraceObject} was created, but not yet inserted.
*
* <p>
* Between the {@link #OBJECT_CREATED} event and the first {@link #OBJECT_LIFE_CHANGED} event,
* an object is considered "incomplete," because it is likely missing its attributes. Thus, a
* trace client must take care to ensure all attributes, especially fixed attributes, are added
* to the object before it is inserted at its canonical path. Listeners may use
* {@link TraceObject#getCanonicalParent(long)} to check if an object is complete for a given
* snapshot.
*/
TraceObjectEvent OBJECT_CREATED = TraceObjectEvent.OBJECT_CREATED;
/**
* An object's life changed.
*
* <p>
* One of its canonical parents was created, deleted, or had its lifespan change.
*/
TraceObjectEvent OBJECT_LIFE_CHANGED = TraceObjectEvent.OBJECT_LIFE_CHANGED;
/** A {@link TraceObject} was deleted */
TraceObjectEvent OBJECT_DELETED = TraceObjectEvent.OBJECT_DELETED;
/** A {@link TraceObjectValue} was created */
TraceObjectValueEvent VALUE_CREATED = TraceObjectValueEvent.VALUE_CREATED;
/** A {@link TraceObjectValue}'s lifespan changed */
TraceObjectValueLifespanEvent VALUE_LIFESPAN_CHANGED =
TraceObjectValueLifespanEvent.VALUE_LIFESPAN_CHANGED;
/** A {@link TraceObjectValue} was deleted */
TraceObjectValueEvent VALUE_DELETED = TraceObjectValueEvent.VALUE_DELETED;
/** A {@link TraceBookmarkType} was added */
TraceBookmarkTypeEvent BOOKMARK_TYPE_ADDED = TraceBookmarkTypeEvent.BOOKMARK_TYPE_ADDED;
/** A {@link TraceBookmark} was added */
TraceBookmarkEvent BOOKMARK_ADDED = TraceBookmarkEvent.BOOKMARK_ADDED;
/** A {@link TraceBookmark} was changed */
TraceBookmarkEvent BOOKMARK_CHANGED = TraceBookmarkEvent.BOOKMARK_CHANGED;
/** A {@link TraceBookmark}'s lifespan was changed */
TraceBookmarkLifespanEvent BOOKMARK_LIFESPAN_CHANGED =
TraceBookmarkLifespanEvent.BOOKMARK_LIFESPAN_CHANGED;
/** A {@link TraceBookmark} was deleted */
TraceBookmarkEvent BOOKMARK_DELETED = TraceBookmarkEvent.BOOKMARK_DELETED;
/** A {@link TraceBreakpoint} was added */
TraceBreakpointEvent BREAKPOINT_ADDED = TraceBreakpointEvent.BREAKPOINT_ADDED;
/** A {@link TraceBreakpoint} was changed */
TraceBreakpointEvent BREAKPOINT_CHANGED = TraceBreakpointEvent.BREAKPOINT_CHANGED;
/** A {@link TraceBreakpoint}'s lifespan was changed */
TraceBreakpointLifespanEvent BREAKPOINT_LIFESPAN_CHANGED =
TraceBreakpointLifespanEvent.BREAKPOINT_LIFESPAN_CHANGED;
/** A {@link TraceBreakpoint} was deleted */
TraceBreakpointEvent BREAKPOINT_DELETED = TraceBreakpointEvent.BREAKPOINT_DELETED;
/** A {@link Category} was added. The {@code long} is the category id. */
TraceTypeCategoryEvent TYPE_CATEGORY_ADDED = TraceTypeCategoryEvent.TYPE_CATEGORY_ADDED;
/** A {@link Category} was moved. The {@code long} is the category id. */
TraceTypeCategoryPathEvent TYPE_CATEGORY_MOVED = TraceTypeCategoryPathEvent.TYPE_CATEGORY_MOVED;
/** A {@link Category} was renamed. The {@code long} is the category id. */
TraceTypeCategoryStringEvent TYPE_CATEGORY_RENAMED =
TraceTypeCategoryStringEvent.TYPE_CATEGORY_RENAMED;
/** A {@link Category} was deleted. The {@code long} is the category id. */
TraceTypeCategoryPathEvent TYPE_CATEGORY_DELETED =
TraceTypeCategoryPathEvent.TYPE_CATEGORY_DELETED;
/**
* One or more {@link TraceCodeUnit}s were added.
*
* <p>
* This may be a single unit or a whole block. Only the first unit in the block is given in the
* record.
*/
TraceCodeEvent CODE_ADDED = TraceCodeEvent.CODE_ADDED;
/** A {@link TraceCodeUnit}'s lifspan changed. */
TraceCodeLifespanEvent CODE_LIFESPAN_CHANGED = TraceCodeLifespanEvent.CODE_LIFESPAN_CHANGED;
/**
* One or more {@link TraceCodeUnit}'s were removed.
*
* <p>
* This may be a single unit or a whole block. Only the first unit in the block is given, if it
* is given at all.
*/
TraceCodeEvent CODE_REMOVED = TraceCodeEvent.CODE_REMOVED;
/** A {@link ProgramFragment} was changed. */
TraceCodeFragmentEvent CODE_FRAGMENT_CHANGED = TraceCodeFragmentEvent.CODE_FRAGMENT_CHANGED;
/**
* One or more {@link TraceData}s' {@link DataType} was replaced.
*
* <p>
* The type's id is given in the record.
*/
TraceCodeDataTypeEvent CODE_DATA_TYPE_REPLACED = TraceCodeDataTypeEvent.CODE_DATA_TYPE_REPLACED;
/** One or more {@link TraceData}s' {@link Settings} was changed. */
TraceCodeDataSettingsEvent CODE_DATA_SETTINGS_CHANGED =
TraceCodeDataSettingsEvent.CODE_DATA_SETTINGS_CHANGED;
/** A plate comment was changed. */
TraceCommentEvent PLATE_COMMENT_CHANGED = TraceCommentEvent.PLATE_COMMENT_CHANGED;
/** A pre comment was changed. */
TraceCommentEvent PRE_COMMENT_CHANGED = TraceCommentEvent.PRE_COMMENT_CHANGED;
/** A post comment was changed. */
TraceCommentEvent POST_COMMENT_CHANGED = TraceCommentEvent.POST_COMMENT_CHANGED;
/** An end-of-line comment was changed. */
TraceCommentEvent EOL_COMMENT_CHANGED = TraceCommentEvent.EOL_COMMENT_CHANGED;
/** A repeatable comment was changed. */
TraceCommentEvent REPEATABLE_COMMENT_CHANGED = TraceCommentEvent.REPEATABLE_COMMENT_CHANGED;
/**
* Get the comment change event for the given comment type
*
* @param commentType the comment type
* @return the event type
*/
static TraceCommentEvent byCommentType(int commentType) {
return switch (commentType) {
case CodeUnit.PLATE_COMMENT -> PLATE_COMMENT_CHANGED;
case CodeUnit.PRE_COMMENT -> PRE_COMMENT_CHANGED;
case CodeUnit.POST_COMMENT -> POST_COMMENT_CHANGED;
case CodeUnit.EOL_COMMENT -> EOL_COMMENT_CHANGED;
case CodeUnit.REPEATABLE_COMMENT -> REPEATABLE_COMMENT_CHANGED;
default -> throw new AssertionError();
};
}
/** A {@link TraceData} of {@link Composite} type was added. */
TraceCompositeDataEvent COMPOSITE_DATA_ADDED = TraceCompositeDataEvent.COMPOSITE_DATA_ADDED;
/** The lifespan of a {@link TraceData} of {@link Composite} type was changed. */
TraceCompositeDataLifespanEvent COMPOSITE_DATA_LIFESPAN_CHANGED =
TraceCompositeDataLifespanEvent.COMPOSITE_DATA_LIFESPAN_CHANGED;
/** A {@link TraceData} of {@link Composite} type was removed. */
TraceCompositeDataEvent COMPOSITE_DATA_REMOVED = TraceCompositeDataEvent.COMPOSITE_DATA_REMOVED;
/** A {@link DataType} was added. */
TraceDataTypeEvent DATA_TYPE_ADDED = TraceDataTypeEvent.DATA_TYPE_ADDED;
/** A {@link DataType} was replaced. */
TraceDataTypePathEvent DATA_TYPE_REPLACED = TraceDataTypePathEvent.DATA_TYPE_REPLACED;
/** A {@link DataType} was changed. */
TraceDataTypeEvent DATA_TYPE_CHANGED = TraceDataTypeEvent.DATA_TYPE_CHANGED;
/** A {@link DataType} was moved. */
TraceDataTypePathEvent DATA_TYPE_MOVED = TraceDataTypePathEvent.DATA_TYPE_MOVED;
/** A {@link DataType} was renamed. */
TraceDataTypeStringEvent DATA_TYPE_RENAMED = TraceDataTypeStringEvent.DATA_TYPE_RENAMED;
/** A {@link DataType} was deleted. */
TraceDataTypePathEvent DATA_TYPE_DELETED = TraceDataTypePathEvent.DATA_TYPE_DELETED;
/** A {@link TraceInstruction}'s flow override was changed. */
TraceInstructionFlowEvent INSTRUCTION_FLOW_OVERRIDE_CHANGED =
TraceInstructionFlowEvent.INSTRUCTION_FLOW_OVERRIDE_CHANGED;
/** A {@link TraceInstruction}'s fall-through override was changed. */
TraceInstructionBoolEvent INSTRUCTION_FALL_THROUGH_OVERRIDE_CHANGED =
TraceInstructionBoolEvent.INSTRUCTION_FALL_THROUGH_OVERRIDE_CHANGED;
/** A {@link TraceInstruction}'s length override was changed. */
TraceInstructionIntEvent INSTRUCTION_LENGTH_OVERRIDE_CHANGED =
TraceInstructionIntEvent.INSTRUCTION_LENGTH_OVERRIDE_CHANGED;
/**
* The {@link Trace}'s memory or register values were changed.
*
* <p>
* Note the given byte arrays may be larger than the actual change.
*/
TraceBytesEvent BYTES_CHANGED = TraceBytesEvent.BYTES_CHANGED;
/** A {@link TraceMemoryRegion} was added. */
TraceMemoryRegionEvent REGION_ADDED = TraceMemoryRegionEvent.REGION_ADDED;
/** A {@link TraceMemoryRegion} was changed. */
TraceMemoryRegionEvent REGION_CHANGED = TraceMemoryRegionEvent.REGION_CHANGED;
/** A {@link TraceMemoryRegion}'s lifespan was changed. */
TraceMemoryRegionLifespanEvent REGION_LIFESPAN_CHANGED =
TraceMemoryRegionLifespanEvent.REGION_LIFESPAN_CHANGED;
/** A {@link TraceMemoryRegion} was deleted. */
TraceMemoryRegionEvent REGION_DELETED = TraceMemoryRegionEvent.REGION_DELETED;
/** An overlay {@link AddressSpace} was added. */
TraceOverlaySpaceEvent OVERLAY_ADDED = TraceOverlaySpaceEvent.OVERLAY_ADDED;
/** An overlay {@link AddressSpace} was deleted. */
TraceOverlaySpaceEvent OVERLAY_DELETED = TraceOverlaySpaceEvent.OVERLAY_DELETED;
/** The cache state of memory or register values was changed. */
TraceMemoryStateEvent BYTES_STATE_CHANGED = TraceMemoryStateEvent.BYTES_STATE_CHANGED;
/** A {@link TraceModule} was added. */
TraceModuleEvent MODULE_ADDED = TraceModuleEvent.MODULE_ADDED;
/** A {@link TraceModule} was changed. */
TraceModuleEvent MODULE_CHANGED = TraceModuleEvent.MODULE_CHANGED;
/** A {@link TraceModule}'s lifespan was changed. */
TraceModuleLifespanEvent MODULE_LIFESPAN_CHANGED =
TraceModuleLifespanEvent.MODULE_LIFESPAN_CHANGED;
/** A {@link TraceModule} was deleted. */
TraceModuleEvent MODULE_DELETED = TraceModuleEvent.MODULE_DELETED;
/** A {@link TraceSection} was added. */
TraceSectionEvent SECTION_ADDED = TraceSectionEvent.SECTION_ADDED;
/** A {@link TraceSection} was changed. */
TraceSectionEvent SECTION_CHANGED = TraceSectionEvent.SECTION_CHANGED;
/** A {@link TraceSection} was deleted. */
TraceSectionEvent SECTION_DELETED = TraceSectionEvent.SECTION_DELETED;
/** A {@link TraceReference} was added. */
TraceReferenceEvent REFERENCE_ADDED = TraceReferenceEvent.REFERENCE_ADDED;
/** A {@link TraceReference}'s lifespan was changed. */
TraceReferenceLifespanEvent REFERENCE_LIFESPAN_CHANGED =
TraceReferenceLifespanEvent.REFERENCE_LIFESPAN_CHANGED;
/** A {@link TraceReference} was promoted to or demoted from primary. */
TraceReferenceBoolEvent REFERENCE_PRIMARY_CHANGED =
TraceReferenceBoolEvent.REFERENCE_PRIMARY_CHANGED;
/** A {@link TraceReference} was deleted. */
TraceReferenceEvent REFERENCE_DELETED = TraceReferenceEvent.REFERENCE_DELETED;
/** A {@link TraceStack} was added. */
TraceStackEvent STACK_ADDED = TraceStackEvent.STACK_ADDED;
/**
* A {@link TraceStack} was changed.
*
* <p>
* The "new value" in the record is the min snap of the change. The "old value" is always 0.
*/
TraceStackLongEvent STACK_CHANGED = TraceStackLongEvent.STACK_CHANGED;
/** A {@link TraceStack} was deleted. */
TraceStackEvent STACK_DELETED = TraceStackEvent.STACK_DELETED;
/** A {@link TraceStaticMapping} was added. */
TraceMappingEvent MAPPING_ADDED = TraceMappingEvent.MAPPING_ADDED;
/** A {@link TraceStaticMapping} was deleted. */
TraceMappingEvent MAPPING_DELETED = TraceMappingEvent.MAPPING_DELETED;
/** A source data type archive was added. */
TraceTypeArchiveEvent SOURCE_TYPE_ARCHIVE_ADDED =
TraceTypeArchiveEvent.SOURCE_TYPE_ARCHIVE_ADDED;
/** A source data type archive was changed. */
TraceTypeArchiveEvent SOURCE_TYPE_ARCHIVE_CHANGED =
TraceTypeArchiveEvent.SOURCE_TYPE_ARCHIVE_CHANGED;
/** A source data type archive was deleted. */
TraceTypeArchiveEvent SOURCE_TYPE_ARCHIVE_DELETED =
TraceTypeArchiveEvent.SOURCE_TYPE_ARCHIVE_DELETED;
/** A {@link TraceSymbol} was added. */
TraceSymbolEvent SYMBOL_ADDED = TraceSymbolEvent.SYMBOL_ADDED;
/** A {@link TraceSymbol}'s source type changed. */
TraceSymbolSourceEvent SYMBOL_SOURCE_CHANGED = TraceSymbolSourceEvent.SYMBOL_SOURCE_CHANGED;
/** A {@link TraceSymbol} was promoted to or demoted from primary. */
TraceSymbolSymEvent SYMBOL_PRIMARY_CHANGED = TraceSymbolSymEvent.SYMBOL_PRIMARY_CHANGED;
/** A {@link TraceSymbol} was renamed. */
TraceSymbolStringEvent SYMBOL_RENAMED = TraceSymbolStringEvent.SYMBOL_RENAMED;
/** A {@link TraceSymbol}'s parent namespace changed. */
TraceSymbolNamespaceEvent SYMBOL_PARENT_CHANGED =
TraceSymbolNamespaceEvent.SYMBOL_PARENT_CHANGED;
/** A {@link TraceSymbol} was associated with a {@link TraceReference}. */
TraceSymbolRefEvent SYMBOL_ASSOCIATION_ADDED = TraceSymbolRefEvent.SYMBOL_ASSOCIATION_ADDED;
/** A {@link TraceSymbol} was dissociated from a {@link TraceReference}. */
TraceSymbolRefEvent SYMBOL_ASSOCIATION_REMOVED = TraceSymbolRefEvent.SYMBOL_ASSOCIATION_REMOVED;
/** A {@link TraceSymbol}'s address changed. */
TraceSymbolAddressEvent SYMBOL_ADDRESS_CHANGED = TraceSymbolAddressEvent.SYMBOL_ADDRESS_CHANGED;
/** A {@link TraceSymbol}'s lifespan changed. */
TraceSymbolLifespanEvent SYMBOL_LIFESPAN_CHANGED =
TraceSymbolLifespanEvent.SYMBOL_LIFESPAN_CHANGED;
/**
* A {@link TraceSymbol} was changed in a way not captured by the other {@code SYMBOL_} events.
*/
TraceSymbolEvent SYMBOL_CHANGED = TraceSymbolEvent.SYMBOL_CHANGED;
/** A {@link TraceSymbol} was deleted. */
TraceSymbolEvent SYMBOL_DELETED = TraceSymbolEvent.SYMBOL_DELETED;
/** A {@link TraceThread} was added. */
TraceThreadEvent THREAD_ADDED = TraceThreadEvent.THREAD_ADDED;
/** A {@link TraceThread} was changed. */
TraceThreadEvent THREAD_CHANGED = TraceThreadEvent.THREAD_CHANGED;
/** A {@link TraceThread}'s lifespan was changed. */
TraceThreadLifespanEvent THREAD_LIFESPAN_CHANGED =
TraceThreadLifespanEvent.THREAD_LIFESPAN_CHANGED;
/** A {@link TraceThread} was deleted. */
TraceThreadEvent THREAD_DELETED = TraceThreadEvent.THREAD_DELETED;
/** A {@link TraceSnapshot} was added. */
TraceSnapshotEvent SNAPSHOT_ADDED = TraceSnapshotEvent.SNAPSHOT_ADDED;
/** A {@link TraceSnapshot} was changed. */
TraceSnapshotEvent SNAPSHOT_CHANGED = TraceSnapshotEvent.SNAPSHOT_CHANGED;
/** A {@link TraceSnapshot} was deleted. */
TraceSnapshotEvent SNAPSHOT_DELETED = TraceSnapshotEvent.SNAPSHOT_DELETED;
/** A {@link TraceGuestPlatform} was added. */
TracePlatformEvent PLATFORM_ADDED = TracePlatformEvent.PLATFORM_ADDED;
/** A {@link TraceGuestPlatform} was deleted. */
TracePlatformEvent PLATFORM_DELETED = TracePlatformEvent.PLATFORM_DELETED;
/** A {@link TraceGuestPlatformMappedRange} was added. */
TracePlatformMappingEvent PLATFORM_MAPPING_ADDED =
TracePlatformMappingEvent.PLATFORM_MAPPING_ADDED;
/** A {@link TraceGuestPlatformMappedRange} was deleted. */
TracePlatformMappingEvent PLATFORM_MAPPING_DELETED =
TracePlatformMappingEvent.PLATFORM_MAPPING_DELETED;
}

25
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/model/TypedEventDispatcher.java → Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/util/TypedEventDispatcher.java
View file

@ -13,14 +13,13 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package ghidra.trace.model;
package ghidra.trace.util;
import java.util.HashMap;
import java.util.Map;
import java.util.function.Consumer;
import ghidra.framework.model.*;
import ghidra.trace.util.*;
public class TypedEventDispatcher {
@ -101,25 +100,25 @@ public class TypedEventDispatcher {
}
}
private Map<TraceChangeType<?, ?>, EventRecordHandler<?, ?>> typedMap = new HashMap<>();
private Map<TraceEvent<?, ?>, EventRecordHandler<?, ?>> typedMap = new HashMap<>();
private Map<EventType, Consumer<DomainObjectChangeRecord>> untypedMap = new HashMap<>();
protected Consumer<DomainObjectChangeRecord> restoredHandler = null;
protected <T, U> void listenFor(TraceChangeType<T, U> type, EventRecordHandler<T, U> handler) {
protected <T, U> void listenFor(TraceEvent<T, U> type, EventRecordHandler<T, U> handler) {
typedMap.put(type, handler);
}
protected <T, U> void listenFor(TraceChangeType<T, U> type,
protected <T, U> void listenFor(TraceEvent<T, U> type,
FullEventRecordHandler<? super T, ? super U> handler) {
typedMap.put(type, handler);
}
protected <T, U> void listenFor(TraceChangeType<T, U> type,
protected <T, U> void listenFor(TraceEvent<T, U> type,
AffectedObjectHandler<? super T> handler) {
typedMap.put(type, handler);
}
protected <T, U> void listenFor(TraceChangeType<T, U> type,
protected <T, U> void listenFor(TraceEvent<T, U> type,
AffectedObjectOnlyHandler<? super T> handler) {
typedMap.put(type, handler);
}
@ -132,26 +131,26 @@ public class TypedEventDispatcher {
* @param type the event type
* @param handler the handler
*/
protected <T, U> void listenFor(TraceChangeType<T, U> type,
protected <T, U> void listenFor(TraceEvent<T, U> type,
AffectedAndValuesOnlyHandler<? super T, ? super U> handler) {
typedMap.put(type, handler);
}
protected <T, U> void listenFor(TraceChangeType<T, U> type,
protected <T, U> void listenFor(TraceEvent<T, U> type,
ValuesOnlyHandler<? super U> handler) {
typedMap.put(type, handler);
}
protected <T, U> void listenFor(TraceChangeType<T, U> type,
protected <T, U> void listenFor(TraceEvent<T, U> type,
SpaceValuesHandler<? super U> handler) {
typedMap.put(type, handler);
}
protected void listenFor(TraceChangeType<?, ?> type, IgnoreValuesHandler handler) {
protected void listenFor(TraceEvent<?, ?> type, IgnoreValuesHandler handler) {
typedMap.put(type, handler);
}
protected void listenFor(TraceChangeType<?, ?> type, IgnoreAllHandler handler) {
protected void listenFor(TraceEvent<?, ?> type, IgnoreAllHandler handler) {
typedMap.put(type, handler);
}
@ -186,7 +185,7 @@ public class TypedEventDispatcher {
@SuppressWarnings("unchecked")
public void handleTraceChangeRecord(TraceChangeRecord<?, ?> rec) {
@SuppressWarnings("rawtypes")
EventRecordHandler handler = typedMap.get(rec.getType());
EventRecordHandler handler = typedMap.get(rec.getEventType());
if (handler != null) {
handler.handle(rec);
}

20
Ghidra/Framework/Project/src/main/java/ghidra/framework/model/DomainObjectChangeRecord.java
View file

@ -16,15 +16,16 @@
package ghidra.framework.model;
import java.io.Serializable;
import java.util.Objects;
/**
* Information about a change that was made to a domain object. The
* record is delivered as part of the change notification. The event types
* correspond to Enums defined in {@link DomainObjectEvent} and
* other Enums or objects that implement the {@link EventType} interface.
* Information about a change that was made to a domain object. The record is delivered as part of
* the change notification. The event types correspond to Enums defined in {@link DomainObjectEvent}
* and other Enums or objects that implement the {@link EventType} interface.
*
* Each event record contains the event type and optionally an old value and a new value.
* The old value and new value meaning are determined by the event type.
* <p>
* Each event record contains the event type and optionally an old value and a new value. The old
* value and new value meaning are determined by the event type.
*/
public class DomainObjectChangeRecord implements Serializable {
@ -34,6 +35,7 @@ public class DomainObjectChangeRecord implements Serializable {
/**
* Construct a new DomainObjectChangeRecord.
*
* @param eventType the type of event
*/
public DomainObjectChangeRecord(EventType eventType) {
@ -42,18 +44,20 @@ public class DomainObjectChangeRecord implements Serializable {
/**
* Construct a new DomainObjectChangeRecord.
*
* @param eventType the type of
* @param oldValue old value
* @param newValue new value
*/
public DomainObjectChangeRecord(EventType eventType, Object oldValue, Object newValue) {
this.eventType = eventType;
this.eventType = Objects.requireNonNull(eventType);
this.oldValue = oldValue;
this.newValue = newValue;
}
/**
* Returns the event type for this change.
*
* @return the event type for this change
*/
public EventType getEventType() {
@ -62,6 +66,7 @@ public class DomainObjectChangeRecord implements Serializable {
/**
* Return the old value for this event or null if not applicable.
*
* @return the old value or null if not applicable
*/
public Object getOldValue() {
@ -70,6 +75,7 @@ public class DomainObjectChangeRecord implements Serializable {
/**
* Return the new value for this event or null if not applicable.
*
* @return the old value or null if not applicable for this event.
*/
public Object getNewValue() {