yetangitu/ghidra
1
0
Fork 0
mirror of https://github.com/NationalSecurityAgency/ghidra.git synced 2025-10-04 18:29:37 +02:00
Code Issues Releases Wiki Activity

Merge remote-tracking branch

Browse source 
'origin/GP-4403_ghidra1_ImmutableDomainObject--SQUASHED'

Conflicts:
	Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/program/database/ProgramContentHandler.java
This commit is contained in:
Ryan Kurtz 2024-03-21 09:11:28 -04:00
commit 5a970158d5
161 changed files with 1240 additions and 1126 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -26,6 +26,7 @@ import db.DBHandle;
import db.Transaction;
import generic.depends.DependentService;
import generic.depends.err.ServiceConstructionException;
import ghidra.framework.data.OpenMode;
import ghidra.framework.model.DomainObjectChangeRecord;
import ghidra.framework.options.Options;
import ghidra.lifecycle.Internal;
@ -64,7 +65,8 @@ import ghidra.trace.util.*;
import ghidra.trace.util.CopyOnWrite.WeakHashCowSet;
import ghidra.trace.util.CopyOnWrite.WeakValueHashCowMap;
import ghidra.util.*;
import ghidra.util.database.*;
import ghidra.util.database.DBCachedDomainObjectAdapter;
import ghidra.util.database.DBCachedObjectStoreFactory;
import ghidra.util.datastruct.ListenerSet;
import ghidra.util.exception.*;
import ghidra.util.task.TaskMonitor;
@ -154,7 +156,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
public DBTrace(String name, CompilerSpec baseCompilerSpec, Object consumer)
throws IOException, LanguageNotFoundException {
super(new DBHandle(), DBOpenMode.CREATE, TaskMonitor.DUMMY, name, DB_TIME_INTERVAL,
super(new DBHandle(), OpenMode.CREATE, TaskMonitor.DUMMY, name, DB_TIME_INTERVAL,
DB_BUFFER_SIZE, consumer);
this.storeFactory = new DBCachedObjectStoreFactory(this);
@ -167,7 +169,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
space -> getAddressSet(space));
try (Transaction tx = this.openTransaction("Create")) {
initOptions(DBOpenMode.CREATE);
initOptions(OpenMode.CREATE);
init();
}
catch (VersionException | CancelledException e) {
@ -189,7 +191,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
return new AddressSet(space.getMinAddress(), space.getMaxAddress());
}
public DBTrace(DBHandle dbh, DBOpenMode openMode, TaskMonitor monitor, Object consumer)
public DBTrace(DBHandle dbh, OpenMode openMode, TaskMonitor monitor, Object consumer)
throws CancelledException, VersionException, IOException, LanguageNotFoundException {
super(dbh, openMode, monitor, "Untitled", DB_TIME_INTERVAL, DB_BUFFER_SIZE, consumer);
this.storeFactory = new DBCachedObjectStoreFactory(this);
@ -209,9 +211,9 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
programView = createProgramView(0);
}
protected void initOptions(DBOpenMode openMode) throws IOException, CancelledException {
protected void initOptions(OpenMode openMode) throws IOException, CancelledException {
Options traceInfo = getOptions(TRACE_INFO);
if (openMode == DBOpenMode.CREATE) {
if (openMode == OpenMode.CREATE) {
traceInfo.setString(NAME, name);
traceInfo.setDate(DATE_CREATED, new Date());
traceInfo.setString(BASE_LANGUAGE, baseLanguage.getLanguageID().getIdAsString());
@ -659,9 +661,8 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
if (recordChanges) {
traceChangeSet.sourceArchiveChanged(sourceArchiveID.getValue());
}
setChanged(
new TraceChangeRecord<>(TraceEvents.SOURCE_TYPE_ARCHIVE_CHANGED, null,
sourceArchiveID));
setChanged(new TraceChangeRecord<>(TraceEvents.SOURCE_TYPE_ARCHIVE_CHANGED, null,
sourceArchiveID));
}
public void sourceArchiveAdded(UniversalID sourceArchiveID) {
@ -684,8 +685,7 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
if (recordChanges) {
traceChangeSet.dataTypeAdded(addedID);
}
setChanged(
new TraceChangeRecord<>(TraceEvents.DATA_TYPE_ADDED, null, addedID, addedType));
setChanged(new TraceChangeRecord<>(TraceEvents.DATA_TYPE_ADDED, null, addedID, addedType));
}
public void dataTypeReplaced(long replacedID, DataTypePath replacedPath, DataTypePath newPath) {
@ -700,16 +700,16 @@ public class DBTrace extends DBCachedDomainObjectAdapter implements Trace, Trace
if (recordChanges) {
traceChangeSet.dataTypeChanged(movedID);
}
setChanged(new TraceChangeRecord<>(TraceEvents.DATA_TYPE_MOVED, null, movedID, oldPath,
newPath));
setChanged(
new TraceChangeRecord<>(TraceEvents.DATA_TYPE_MOVED, null, movedID, oldPath, newPath));
}
public void dataTypeNameChanged(long renamedID, String oldName, String newName) {
if (recordChanges) {
traceChangeSet.dataTypeChanged(renamedID);
}
setChanged(new TraceChangeRecord<>(TraceEvents.DATA_TYPE_RENAMED, null, renamedID,
oldName, newName));
setChanged(new TraceChangeRecord<>(TraceEvents.DATA_TYPE_RENAMED, null, renamedID, oldName,
newName));
}
public void dataTypeDeleted(long deletedID, DataTypePath deletedPath) {

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

@ -22,15 +22,13 @@ import javax.swing.Icon;
import db.DBHandle;
import db.buffers.BufferFile;
import db.buffers.ManagedBufferFile;
import ghidra.framework.data.DBWithUserDataContentHandler;
import ghidra.framework.data.DomainObjectMergeManager;
import ghidra.framework.data.*;
import ghidra.framework.model.ChangeSet;
import ghidra.framework.model.DomainObject;
import ghidra.framework.store.*;
import ghidra.trace.model.Trace;
import ghidra.util.InvalidNameException;
import ghidra.util.Msg;
import ghidra.util.database.DBOpenMode;
import ghidra.util.exception.CancelledException;
import ghidra.util.exception.VersionException;
import ghidra.util.task.TaskMonitor;
@ -71,7 +69,7 @@ public class DBTraceContentHandler extends DBWithUserDataContentHandler<DBTrace>
try {
bf = dbItem.open(version, minChangeVersion);
dbh = new DBHandle(bf);
DBOpenMode openMode = DBOpenMode.READ_ONLY;
OpenMode openMode = OpenMode.IMMUTABLE;
trace = new DBTrace(dbh, openMode, monitor, consumer);
getTraceChangeSet(trace, bf);
success = true;
@ -119,7 +117,7 @@ public class DBTraceContentHandler extends DBWithUserDataContentHandler<DBTrace>
try {
bf = dbItem.open(version);
dbh = new DBHandle(bf);
DBOpenMode openMode = okToUpgrade ? DBOpenMode.UPGRADE : DBOpenMode.UPDATE;
OpenMode openMode = okToUpgrade ? OpenMode.UPGRADE : OpenMode.UPDATE;
trace = new DBTrace(dbh, openMode, monitor, consumer);
getTraceChangeSet(trace, bf);
trace.setTraceUserData(new DBTraceUserData(trace));
@ -169,7 +167,7 @@ public class DBTraceContentHandler extends DBWithUserDataContentHandler<DBTrace>
try {
bf = dbItem.openForUpdate(checkoutId);
dbh = new DBHandle(bf, recover, monitor);
DBOpenMode openMode = okToUpgrade ? DBOpenMode.UPGRADE : DBOpenMode.UPDATE;
OpenMode openMode = okToUpgrade ? OpenMode.UPGRADE : OpenMode.UPDATE;
trace = new DBTrace(dbh, openMode, monitor, consumer);
if (checkoutId == FolderItem.DEFAULT_CHECKOUT_ID) {
getTraceChangeSet(trace, bf);
@ -275,7 +273,7 @@ public class DBTraceContentHandler extends DBWithUserDataContentHandler<DBTrace>
try {
bf = dbItem.open(toVer, fromVer);
dbh = new DBHandle(bf);
DBOpenMode openMode = DBOpenMode.READ_ONLY;
OpenMode openMode = OpenMode.IMMUTABLE;
trace = new DBTrace(dbh, openMode, null, this);
return getTraceChangeSet(trace, bf);
}

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

@ -23,6 +23,7 @@ import java.util.*;
import java.util.concurrent.locks.ReadWriteLock;
import db.*;
import ghidra.framework.data.OpenMode;
import ghidra.program.database.ProgramAddressFactory;
import ghidra.program.database.ProgramOverlayAddressSpace;
import ghidra.program.model.address.Address;
@ -149,7 +150,7 @@ public class DBTraceOverlaySpaceAdapter implements DBTraceManager {
protected final DBCachedObjectStore<DBTraceOverlaySpaceEntry> overlayStore;
protected final DBCachedObjectIndex<String, DBTraceOverlaySpaceEntry> overlaysByName;
public DBTraceOverlaySpaceAdapter(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceOverlaySpaceAdapter(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, DBTrace trace) throws VersionException, IOException {
this.dbh = dbh;
this.lock = lock;

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

@ -24,6 +24,7 @@ import java.util.concurrent.locks.ReadWriteLock;
import javax.swing.Icon;
import db.DBHandle;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.Language;
import ghidra.trace.database.DBTrace;
@ -39,7 +40,6 @@ import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.Msg;
import ghidra.util.database.DBOpenMode;
import ghidra.util.exception.VersionException;
import ghidra.util.task.TaskMonitor;
@ -167,7 +167,7 @@ public class DBTraceBookmarkManager extends AbstractDBTraceSpaceBasedManager<DBT
protected final Collection<DBTraceBookmarkType> typesView =
Collections.unmodifiableCollection(typesByName.values());
public DBTraceBookmarkManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceBookmarkManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager) throws VersionException, IOException {
super(NAME, dbh, openMode, lock, monitor, baseLanguage, trace, threadManager);
@ -182,8 +182,8 @@ public class DBTraceBookmarkManager extends AbstractDBTraceSpaceBasedManager<DBT
}
@Override
protected DBTraceBookmarkSpace createRegisterSpace(AddressSpace space,
TraceThread thread, DBTraceSpaceEntry ent) throws VersionException, IOException {
protected DBTraceBookmarkSpace createRegisterSpace(AddressSpace space, TraceThread thread,
DBTraceSpaceEntry ent) throws VersionException, IOException {
return new DBTraceBookmarkSpace(this, space, thread, ent.getFrameLevel());
}
@ -292,8 +292,8 @@ public class DBTraceBookmarkManager extends AbstractDBTraceSpaceBasedManager<DBT
}
@Override
public DBTraceBookmark addBookmark(Lifespan lifespan, Address address,
TraceBookmarkType type, String category, String comment) {
public DBTraceBookmark addBookmark(Lifespan lifespan, Address address, TraceBookmarkType type,
String category, String comment) {
return delegateWrite(address.getAddressSpace(),
m -> m.addBookmark(lifespan, address, type, category, comment));
}

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

@ -23,6 +23,7 @@ import java.util.concurrent.locks.ReadWriteLock;
import db.DBHandle;
import ghidra.dbg.target.TargetBreakpointLocation;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.Language;
import ghidra.trace.database.DBTrace;
@ -33,7 +34,6 @@ import ghidra.trace.model.Lifespan;
import ghidra.trace.model.breakpoint.*;
import ghidra.trace.model.thread.TraceThread;
import ghidra.util.LockHold;
import ghidra.util.database.DBOpenMode;
import ghidra.util.exception.DuplicateNameException;
import ghidra.util.exception.VersionException;
import ghidra.util.task.TaskMonitor;
@ -43,7 +43,7 @@ public class DBTraceBreakpointManager
implements TraceBreakpointManager, DBTraceDelegatingManager<DBTraceBreakpointSpace> {
protected static final String NAME = "Breakpoint";
public DBTraceBreakpointManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceBreakpointManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager) throws VersionException, IOException {
super(NAME, dbh, openMode, lock, monitor, baseLanguage, trace, threadManager);
@ -129,8 +129,7 @@ public class DBTraceBreakpointManager
.getObjectByPath(snap, path, TraceObjectBreakpointLocation.class);
}
try (LockHold hold = LockHold.lock(lock.readLock())) {
return getBreakpointsByPath(path)
.stream()
return getBreakpointsByPath(path).stream()
.filter(b -> b.getLifespan().contains(snap))
.findAny()
.orElse(null);

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

@ -24,6 +24,7 @@ import java.util.concurrent.locks.ReadWriteLock;
import db.DBHandle;
import db.DBRecord;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.*;
import ghidra.program.model.listing.ProgramContext;
@ -40,15 +41,15 @@ import ghidra.trace.model.TraceAddressSnapRange;
import ghidra.trace.model.context.TraceRegisterContextManager;
import ghidra.trace.model.guest.TracePlatform;
import ghidra.trace.model.thread.TraceThread;
import ghidra.util.database.*;
import ghidra.util.database.DBCachedObjectStore;
import ghidra.util.database.DBObjectColumn;
import ghidra.util.database.annot.*;
import ghidra.util.exception.VersionException;
import ghidra.util.task.TaskMonitor;
public class DBTraceRegisterContextManager
extends AbstractDBTraceSpaceBasedManager<DBTraceRegisterContextSpace>
implements TraceRegisterContextManager,
DBTraceDelegatingManager<DBTraceRegisterContextSpace> {
extends AbstractDBTraceSpaceBasedManager<DBTraceRegisterContextSpace> implements
TraceRegisterContextManager, DBTraceDelegatingManager<DBTraceRegisterContextSpace> {
public static final String NAME = "RegisterContext";
@DBAnnotatedObjectInfo(version = 0)
@ -87,7 +88,7 @@ public class DBTraceRegisterContextManager
protected final Map<Language, ProgramContext> defaultContexts = new HashMap<>();
public DBTraceRegisterContextManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceRegisterContextManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager, DBTracePlatformManager languageManager)
throws VersionException, IOException {

15
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/data/DBTraceDataSettingsAdapter.java
View file

@ -20,6 +20,7 @@ import java.util.concurrent.locks.ReadWriteLock;
import db.DBHandle;
import db.DBRecord;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.AddressSpace;
import ghidra.program.model.lang.Language;
import ghidra.trace.database.DBTrace;
@ -176,7 +177,7 @@ public class DBTraceDataSettingsAdapter
}
}
public DBTraceDataSettingsAdapter(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceDataSettingsAdapter(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager) throws IOException, VersionException {
super(NAME, dbh, openMode, lock, monitor, baseLanguage, trace, threadManager,
@ -184,17 +185,16 @@ public class DBTraceDataSettingsAdapter
}
@Override
protected DBTraceDataSettingsSpace createSpace(
AddressSpace space, DBTraceSpaceEntry ent) throws VersionException, IOException {
protected DBTraceDataSettingsSpace createSpace(AddressSpace space, DBTraceSpaceEntry ent)
throws VersionException, IOException {
return new DBTraceDataSettingsSpace(
tableName(space, ent.getThreadKey(), ent.getFrameLevel()), trace.getStoreFactory(),
lock, space, null, 0, dataType, dataFactory);
}
@Override
protected DBTraceDataSettingsSpace createRegisterSpace(
AddressSpace space, TraceThread thread, DBTraceSpaceEntry ent)
throws VersionException, IOException {
protected DBTraceDataSettingsSpace createRegisterSpace(AddressSpace space, TraceThread thread,
DBTraceSpaceEntry ent) throws VersionException, IOException {
return new DBTraceDataSettingsSpace(
tableName(space, ent.getThreadKey(), ent.getFrameLevel()), trace.getStoreFactory(),
lock, space, thread, ent.getFrameLevel(), dataType, dataFactory);
@ -206,8 +206,7 @@ public class DBTraceDataSettingsAdapter
}
@Override
public DBTraceDataSettingsSpace getRegisterSpace(TraceThread thread,
boolean createIfAbsent) {
public DBTraceDataSettingsSpace getRegisterSpace(TraceThread thread, boolean createIfAbsent) {
return (DBTraceDataSettingsSpace) super.getRegisterSpace(thread, createIfAbsent);
}

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

@ -22,6 +22,7 @@ import java.util.concurrent.locks.ReadWriteLock;
import db.DBHandle;
import db.Transaction;
import ghidra.framework.data.OpenMode;
import ghidra.framework.model.DomainFile;
import ghidra.program.database.data.ProgramBasedDataTypeManagerDB;
import ghidra.program.model.address.Address;
@ -33,7 +34,6 @@ import ghidra.trace.database.DBTraceManager;
import ghidra.trace.model.data.TraceBasedDataTypeManager;
import ghidra.util.InvalidNameException;
import ghidra.util.UniversalID;
import ghidra.util.database.DBOpenMode;
import ghidra.util.exception.CancelledException;
import ghidra.util.exception.VersionException;
import ghidra.util.task.TaskMonitor;
@ -46,11 +46,10 @@ public class DBTraceDataTypeManager extends ProgramBasedDataTypeManagerDB
private static final String INSTANCE_TABLE_PREFIX = null; // placeholder only
public DBTraceDataTypeManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceDataTypeManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, DBTrace trace)
throws CancelledException, VersionException, IOException {
super(dbh, null, openMode.toInteger(), INSTANCE_TABLE_PREFIX, trace, trace.getLock(),
monitor);
super(dbh, null, openMode, INSTANCE_TABLE_PREFIX, trace, trace.getLock(), monitor);
this.lock = lock; // TODO: nothing uses this local lock - not sure what its purpose is
this.trace = trace;
@ -72,7 +71,7 @@ public class DBTraceDataTypeManager extends ProgramBasedDataTypeManagerDB
}
}, null, false, monitor);
if (openMode == DBOpenMode.CREATE) {
if (openMode == OpenMode.CREATE) {
saveDataOrganization();
}
}

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

@ -20,6 +20,7 @@ import java.util.*;
import java.util.concurrent.locks.ReadWriteLock;
import db.DBHandle;
import ghidra.framework.data.OpenMode;
import ghidra.lifecycle.Internal;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.*;
@ -32,7 +33,8 @@ 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.database.DBCachedObjectStore;
import ghidra.util.database.DBCachedObjectStoreFactory;
import ghidra.util.exception.CancelledException;
import ghidra.util.exception.VersionException;
import ghidra.util.task.TaskMonitor;
@ -141,7 +143,7 @@ public class DBTracePlatformManager implements DBTraceManager, TracePlatformMana
}
};
public DBTracePlatformManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTracePlatformManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, CompilerSpec baseCompilerSpec, DBTrace trace)
throws VersionException, IOException {
this.dbh = dbh;

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

@ -15,7 +15,7 @@
*/
package ghidra.trace.database.listing;
import static ghidra.lifecycle.Unfinished.TODO;
import static ghidra.lifecycle.Unfinished.*;
import java.io.IOException;
import java.math.BigInteger;
@ -25,6 +25,7 @@ import java.util.concurrent.locks.ReadWriteLock;
import db.DBHandle;
import db.DBRecord;
import ghidra.framework.data.OpenMode;
import ghidra.lifecycle.Internal;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.*;
@ -323,7 +324,7 @@ public class DBTraceCodeManager extends AbstractDBTraceSpaceBasedManager<DBTrace
protected final Map<AddressSnap, UndefinedDBTraceData> undefinedCache =
new WeakValueHashMap<>();
public DBTraceCodeManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceCodeManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager, DBTracePlatformManager platformManager,
DBTraceDataTypeManager dataTypeManager, DBTraceOverlaySpaceAdapter overlayAdapter,

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

@ -22,6 +22,7 @@ import org.apache.commons.lang3.StringUtils;
import db.DBHandle;
import db.DBRecord;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.Language;
import ghidra.program.model.listing.CodeUnit;
@ -39,7 +40,8 @@ import ghidra.trace.model.*;
import ghidra.trace.util.TraceChangeRecord;
import ghidra.trace.util.TraceEvents;
import ghidra.util.LockHold;
import ghidra.util.database.*;
import ghidra.util.database.DBCachedObjectStore;
import ghidra.util.database.DBObjectColumn;
import ghidra.util.database.annot.*;
import ghidra.util.exception.VersionException;
import ghidra.util.task.TaskMonitor;
@ -106,7 +108,7 @@ public class DBTraceCommentAdapter
/**
* Construct the adapter
*/
public DBTraceCommentAdapter(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceCommentAdapter(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager) throws IOException, VersionException {
super("Comments", dbh, openMode, lock, monitor, baseLanguage, trace, threadManager,
@ -140,8 +142,8 @@ public class DBTraceCommentAdapter
}
String oldValue = null;
try (LockHold hold = LockHold.lock(lock.writeLock())) {
for (DBTraceCommentEntry entry : reduce(TraceAddressSnapRangeQuery.intersecting(
new AddressRangeImpl(address, address), lifespan)).values()) {
for (DBTraceCommentEntry entry : reduce(TraceAddressSnapRangeQuery
.intersecting(new AddressRangeImpl(address, address), lifespan)).values()) {
if (entry.type == commentType) {
if (entry.getLifespan().contains(lifespan.lmin())) {
oldValue = entry.comment;
@ -157,8 +159,7 @@ public class DBTraceCommentAdapter
trace.setChanged(new TraceChangeRecord<TraceAddressSnapRange, String>(
TraceEvents.byCommentType(commentType),
DBTraceSpaceKey.create(address.getAddressSpace(), null, 0),
new ImmutableTraceAddressSnapRange(address, lifespan),
oldValue, comment));
new ImmutableTraceAddressSnapRange(address, lifespan), oldValue, comment));
}
/**
@ -191,8 +192,8 @@ public class DBTraceCommentAdapter
*/
public String getComment(long snap, Address address, int commentType) {
try (LockHold hold = LockHold.lock(lock.readLock())) {
for (DBTraceCommentEntry entry : reduce(
TraceAddressSnapRangeQuery.at(address, snap)).values()) {
for (DBTraceCommentEntry entry : reduce(TraceAddressSnapRangeQuery.at(address, snap))
.values()) {
if (entry.type != commentType) {
continue;
}

33
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/map/AbstractDBTracePropertyMap.java
View file

@ -23,10 +23,12 @@ import java.util.Map.Entry;
import java.util.concurrent.locks.ReadWriteLock;
import db.*;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.Language;
import ghidra.trace.database.DBTrace;
import ghidra.trace.database.DBTraceUtils;
import ghidra.trace.database.map.AbstractDBTracePropertyMap.DBTraceSaveablePropertyMapEntry;
import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.AbstractDBTraceAddressSnapRangePropertyMapData;
import ghidra.trace.database.map.DBTraceAddressSnapRangePropertyMapTree.TraceAddressSnapRangeQuery;
import ghidra.trace.database.thread.DBTraceThreadManager;
@ -45,7 +47,7 @@ import ghidra.util.task.TaskMonitor;
public abstract class AbstractDBTracePropertyMap<T, DR extends AbstractDBTraceAddressSnapRangePropertyMapData<T>>
extends DBTraceAddressSnapRangePropertyMap<T, DR> implements TracePropertyMap<T> {
public AbstractDBTracePropertyMap(String name, DBHandle dbh, DBOpenMode openMode,
public AbstractDBTracePropertyMap(String name, DBHandle dbh, OpenMode openMode,
ReadWriteLock lock, TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager, Class<DR> dataType,
DBTraceAddressSnapRangePropertyMapDataFactory<T, DR> dataFactory)
@ -120,17 +122,16 @@ public abstract class AbstractDBTracePropertyMap<T, DR extends AbstractDBTraceAd
}
@Override
protected DBTracePropertyMapSpace createSpace(AddressSpace space,
DBTraceSpaceEntry ent) throws VersionException, IOException {
protected DBTracePropertyMapSpace createSpace(AddressSpace space, DBTraceSpaceEntry ent)
throws VersionException, IOException {
return new DBTracePropertyMapSpace(
tableName(space, ent.getThreadKey(), ent.getFrameLevel()), trace.getStoreFactory(),
lock, space, null, 0, dataType, dataFactory);
}
@Override
protected DBTracePropertyMapSpace createRegisterSpace(
AddressSpace space, TraceThread thread, DBTraceSpaceEntry ent)
throws VersionException, IOException {
protected DBTracePropertyMapSpace createRegisterSpace(AddressSpace space, TraceThread thread,
DBTraceSpaceEntry ent) throws VersionException, IOException {
return new DBTracePropertyMapSpace(
tableName(space, ent.getThreadKey(), ent.getFrameLevel()), trace.getStoreFactory(),
lock, space, thread, ent.getFrameLevel(), dataType, dataFactory);
@ -143,10 +144,9 @@ public abstract class AbstractDBTracePropertyMap<T, DR extends AbstractDBTraceAd
}
@Override
public TracePropertyMapSpace<T> getPropertyMapRegisterSpace(TraceThread thread,
int frameLevel, boolean createIfAbsent) {
return (DBTracePropertyMapSpace) getForRegisterSpace(thread, frameLevel,
createIfAbsent);
public TracePropertyMapSpace<T> getPropertyMapRegisterSpace(TraceThread thread, int frameLevel,
boolean createIfAbsent) {
return (DBTracePropertyMapSpace) getForRegisterSpace(thread, frameLevel, createIfAbsent);
}
@Override
@ -154,8 +154,7 @@ public abstract class AbstractDBTracePropertyMap<T, DR extends AbstractDBTraceAd
throw new NotYetImplementedException();
}
public class DBTracePropertyMapSpace
extends DBTraceAddressSnapRangePropertyMapSpace<T, DR>
public class DBTracePropertyMapSpace extends DBTraceAddressSnapRangePropertyMapSpace<T, DR>
implements TracePropertyMapSpace<T> {
public DBTracePropertyMapSpace(String tableName, DBCachedObjectStoreFactory storeFactory,
@ -242,7 +241,7 @@ public abstract class AbstractDBTracePropertyMap<T, DR extends AbstractDBTraceAd
public static class DBTraceIntPropertyMap
extends AbstractDBTracePropertyMap<Integer, DBTraceIntPropertyMapEntry> {
public DBTraceIntPropertyMap(String name, DBHandle dbh, DBOpenMode openMode,
public DBTraceIntPropertyMap(String name, DBHandle dbh, OpenMode openMode,
ReadWriteLock lock, TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager) throws IOException, VersionException {
super(name, dbh, openMode, lock, monitor, baseLanguage, trace, threadManager,
@ -287,7 +286,7 @@ public abstract class AbstractDBTracePropertyMap<T, DR extends AbstractDBTraceAd
public static class DBTraceLongPropertyMap
extends AbstractDBTracePropertyMap<Long, DBTraceLongPropertyMapEntry> {
public DBTraceLongPropertyMap(String name, DBHandle dbh, DBOpenMode openMode,
public DBTraceLongPropertyMap(String name, DBHandle dbh, OpenMode openMode,
ReadWriteLock lock, TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager) throws IOException, VersionException {
super(name, dbh, openMode, lock, monitor, baseLanguage, trace, threadManager,
@ -340,7 +339,7 @@ public abstract class AbstractDBTracePropertyMap<T, DR extends AbstractDBTraceAd
return (Class) DBTraceSaveablePropertyMapEntry.class;
}
public DBTraceSaveablePropertyMap(String name, DBHandle dbh, DBOpenMode openMode,
public DBTraceSaveablePropertyMap(String name, DBHandle dbh, OpenMode openMode,
ReadWriteLock lock, TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager, Class<T> valueClass)
throws IOException, VersionException {
@ -456,7 +455,7 @@ public abstract class AbstractDBTracePropertyMap<T, DR extends AbstractDBTraceAd
public static class DBTraceStringPropertyMap
extends AbstractDBTracePropertyMap<String, DBTraceStringPropertyMapEntry> {
public DBTraceStringPropertyMap(String name, DBHandle dbh, DBOpenMode openMode,
public DBTraceStringPropertyMap(String name, DBHandle dbh, OpenMode openMode,
ReadWriteLock lock, TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager) throws IOException, VersionException {
super(name, dbh, openMode, lock, monitor, baseLanguage, trace, threadManager,
@ -501,7 +500,7 @@ public abstract class AbstractDBTracePropertyMap<T, DR extends AbstractDBTraceAd
public static class DBTraceVoidPropertyMap
extends AbstractDBTracePropertyMap<Void, DBTraceVoidPropertyMapEntry> {
public DBTraceVoidPropertyMap(String name, DBHandle dbh, DBOpenMode openMode,
public DBTraceVoidPropertyMap(String name, DBHandle dbh, OpenMode openMode,
ReadWriteLock lock, TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager) throws IOException, VersionException {
super(name, dbh, openMode, lock, monitor, baseLanguage, trace, threadManager,

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

@ -24,6 +24,7 @@ import java.util.function.Predicate;
import db.DBHandle;
import db.DBRecord;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.AddressSetView;
import ghidra.program.model.address.AddressSpace;
import ghidra.program.model.lang.Language;
@ -40,7 +41,6 @@ import ghidra.trace.model.stack.TraceStackFrame;
import ghidra.trace.model.thread.TraceThread;
import ghidra.util.UnionAddressSetView;
import ghidra.util.database.DBCachedObjectStore;
import ghidra.util.database.DBOpenMode;
import ghidra.util.database.spatial.SpatialMap;
import ghidra.util.exception.VersionException;
import ghidra.util.task.TaskMonitor;
@ -58,7 +58,7 @@ public class DBTraceAddressSnapRangePropertyMap<T, DR extends AbstractDBTraceAdd
protected final Class<DR> dataType;
protected final DBTraceAddressSnapRangePropertyMapDataFactory<T, DR> dataFactory;
public DBTraceAddressSnapRangePropertyMap(String name, DBHandle dbh, DBOpenMode openMode,
public DBTraceAddressSnapRangePropertyMap(String name, DBHandle dbh, OpenMode openMode,
ReadWriteLock lock, TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager, Class<DR> dataType,
DBTraceAddressSnapRangePropertyMapDataFactory<T, DR> dataFactory)
@ -84,23 +84,22 @@ public class DBTraceAddressSnapRangePropertyMap<T, DR extends AbstractDBTraceAdd
}
@Override
protected DBTraceAddressSnapRangePropertyMapSpace<T, DR> createRegisterSpace(
AddressSpace space, TraceThread thread, DBTraceSpaceEntry ent)
throws VersionException, IOException {
protected DBTraceAddressSnapRangePropertyMapSpace<T, DR> createRegisterSpace(AddressSpace space,
TraceThread thread, DBTraceSpaceEntry ent) throws VersionException, IOException {
return new DBTraceAddressSnapRangePropertyMapSpace<>(
tableName(space, ent.getThreadKey(), ent.getFrameLevel()), trace.getStoreFactory(),
lock, space, thread, ent.getFrameLevel(), dataType, dataFactory);
}
@Override
public DBTraceAddressSnapRangePropertyMapSpace<T, DR> getRegisterSpace(
TraceThread thread, boolean createIfAbsent) {
public DBTraceAddressSnapRangePropertyMapSpace<T, DR> getRegisterSpace(TraceThread thread,
boolean createIfAbsent) {
return getForRegisterSpace(thread, 0, createIfAbsent);
}
@Override
public DBTraceAddressSnapRangePropertyMapSpace<T, DR> getRegisterSpace(
TraceStackFrame frame, boolean createIfAbsent) {
public DBTraceAddressSnapRangePropertyMapSpace<T, DR> getRegisterSpace(TraceStackFrame frame,
boolean createIfAbsent) {
return getForRegisterSpace(frame, createIfAbsent);
}

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

@ -26,6 +26,7 @@ import java.util.function.Predicate;
import db.DBHandle;
import ghidra.dbg.target.TargetMemoryRegion;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.Language;
import ghidra.program.model.mem.MemBuffer;
@ -41,7 +42,6 @@ import ghidra.trace.model.stack.TraceStackFrame;
import ghidra.trace.model.thread.TraceThread;
import ghidra.util.MathUtilities;
import ghidra.util.UnionAddressSetView;
import ghidra.util.database.DBOpenMode;
import ghidra.util.exception.*;
import ghidra.util.task.TaskMonitor;
@ -53,7 +53,7 @@ public class DBTraceMemoryManager extends AbstractDBTraceSpaceBasedManager<DBTra
protected final DBTraceOverlaySpaceAdapter overlayAdapter;
public DBTraceMemoryManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceMemoryManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager, DBTraceOverlaySpaceAdapter overlayAdapter)
throws IOException, VersionException {
@ -91,8 +91,8 @@ public class DBTraceMemoryManager extends AbstractDBTraceSpaceBasedManager<DBTra
}
@Override
protected DBTraceMemorySpace createRegisterSpace(AddressSpace space,
TraceThread thread, DBTraceSpaceEntry ent) throws VersionException, IOException {
protected DBTraceMemorySpace createRegisterSpace(AddressSpace space, TraceThread thread,
DBTraceSpaceEntry ent) throws VersionException, IOException {
return new DBTraceMemorySpace(this, dbh, space, ent, thread);
}
@ -117,8 +117,7 @@ public class DBTraceMemoryManager extends AbstractDBTraceSpaceBasedManager<DBTra
}
@Override
public DBTraceMemorySpace getMemoryRegisterSpace(TraceThread thread,
boolean createIfAbsent) {
public DBTraceMemorySpace getMemoryRegisterSpace(TraceThread thread, boolean createIfAbsent) {
return getForRegisterSpace(thread, 0, createIfAbsent);
}
@ -135,8 +134,8 @@ public class DBTraceMemoryManager extends AbstractDBTraceSpaceBasedManager<DBTra
}
@Override
public TraceMemoryRegion addRegion(String path, Lifespan lifespan,
AddressRange range, Collection<TraceMemoryFlag> flags)
public TraceMemoryRegion addRegion(String path, Lifespan lifespan, AddressRange range,
Collection<TraceMemoryFlag> flags)
throws TraceOverlappedRegionException, DuplicateNameException {
if (trace.getObjectManager().hasSchema()) {
return trace.getObjectManager().addMemoryRegion(path, lifespan, range, flags);
@ -223,9 +222,8 @@ public class DBTraceMemoryManager extends AbstractDBTraceSpaceBasedManager<DBTra
.getObjectsAddressSet(snap, TargetMemoryRegion.RANGE_ATTRIBUTE_NAME,
TraceObjectMemoryRegion.class, r -> true);
}
return new UnionAddressSetView(getActiveMemorySpaces().stream()
.map(m -> m.getRegionsAddressSet(snap))
.toList());
return new UnionAddressSetView(
getActiveMemorySpaces().stream().map(m -> m.getRegionsAddressSet(snap)).toList());
}
@Override
@ -397,9 +395,9 @@ public class DBTraceMemoryManager extends AbstractDBTraceSpaceBasedManager<DBTra
}
Collection<DBTraceMemoryRegion> result = new ArrayList<>();
for (DBTraceMemorySpace space : memSpaces.values()) {
result.addAll(space.regionMapSpace
.reduce(TraceAddressSnapRangeQuery.added(from, to, space.space))
.values());
result.addAll(
space.regionMapSpace.reduce(TraceAddressSnapRangeQuery.added(from, to, space.space))
.values());
}
return result;
}
@ -429,9 +427,9 @@ public class DBTraceMemoryManager extends AbstractDBTraceSpaceBasedManager<DBTra
for (DBTraceMemorySpace space : memSpaces.values()) {
AddressRange rng =
new AddressRangeImpl(space.space.getMinAddress(), space.space.getMaxAddress());
result.addAll(space.stateMapSpace
.reduce(TraceAddressSnapRangeQuery.enclosed(rng, between))
.entries());
result.addAll(
space.stateMapSpace.reduce(TraceAddressSnapRangeQuery.enclosed(rng, between))
.entries());
}
return result;
}

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

@ -23,6 +23,7 @@ import java.util.concurrent.locks.ReadWriteLock;
import db.DBHandle;
import ghidra.dbg.target.TargetModule;
import ghidra.dbg.target.TargetSection;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.Language;
import ghidra.trace.database.DBTrace;
@ -34,7 +35,6 @@ 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;
import ghidra.util.exception.VersionException;
import ghidra.util.task.TaskMonitor;
@ -43,7 +43,7 @@ public class DBTraceModuleManager extends AbstractDBTraceSpaceBasedManager<DBTra
implements TraceModuleManager, DBTraceDelegatingManager<DBTraceModuleSpace> {
public static final String NAME = "Module";
public DBTraceModuleManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceModuleManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, Language baseLanguage, DBTrace trace)
throws VersionException, IOException {
super(NAME, dbh, openMode, lock, monitor, baseLanguage, trace, null);
@ -70,8 +70,8 @@ public class DBTraceModuleManager extends AbstractDBTraceSpaceBasedManager<DBTra
if (!pc.getLifespan().intersects(moduleLifespan)) {
continue;
}
throw new DuplicateNameException("Module with path '" +
modulePath + "' already exists within an overlapping snap");
throw new DuplicateNameException(
"Module with path '" + modulePath + "' already exists within an overlapping snap");
}
}
@ -132,8 +132,7 @@ public class DBTraceModuleManager extends AbstractDBTraceSpaceBasedManager<DBTra
.getObjectByPath(snap, modulePath, TraceObjectModule.class);
}
try (LockHold hold = LockHold.lock(lock.readLock())) {
return doGetModulesByPath(modulePath)
.stream()
return doGetModulesByPath(modulePath).stream()
.filter(m -> m.getLifespan().contains(snap))
.findAny()
.orElse(null);
@ -163,8 +162,8 @@ public class DBTraceModuleManager extends AbstractDBTraceSpaceBasedManager<DBTra
.getObjectsContaining(snap, address, TargetModule.RANGE_ATTRIBUTE_NAME,
TraceObjectModule.class);
}
return delegateRead(address.getAddressSpace(),
m -> m.getModulesAt(snap, address), Set.of());
return delegateRead(address.getAddressSpace(), m -> m.getModulesAt(snap, address),
Set.of());
}
@Override
@ -175,8 +174,8 @@ public class DBTraceModuleManager extends AbstractDBTraceSpaceBasedManager<DBTra
.getObjectsIntersecting(lifespan, range, TargetModule.RANGE_ATTRIBUTE_NAME,
TraceObjectModule.class);
}
return delegateRead(range.getAddressSpace(),
m -> m.getModulesIntersecting(lifespan, range), Set.of());
return delegateRead(range.getAddressSpace(), m -> m.getModulesIntersecting(lifespan, range),
Set.of());
}
@Override
@ -191,8 +190,8 @@ public class DBTraceModuleManager extends AbstractDBTraceSpaceBasedManager<DBTra
.getObjectsContaining(snap, address, TargetSection.RANGE_ATTRIBUTE_NAME,
TraceObjectSection.class);
}
return delegateRead(address.getAddressSpace(),
m -> m.getSectionsAt(snap, address), Set.of());
return delegateRead(address.getAddressSpace(), m -> m.getSectionsAt(snap, address),
Set.of());
}
@Override
@ -274,8 +273,7 @@ public class DBTraceModuleManager extends AbstractDBTraceSpaceBasedManager<DBTra
.getObjectByPath(snap, sectionPath, TraceObjectSection.class);
}
try (LockHold hold = LockHold.lock(lock.readLock())) {
return doGetSectionsByPath(sectionPath)
.stream()
return doGetSectionsByPath(sectionPath).stream()
.filter(s -> s.getModule().getLifespan().contains(snap))
.findAny()
.orElse(null);

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

@ -21,6 +21,7 @@ import java.util.*;
import java.util.concurrent.locks.ReadWriteLock;
import db.DBHandle;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.Address;
import ghidra.program.model.address.AddressRange;
import ghidra.trace.database.DBTrace;
@ -49,7 +50,7 @@ public class DBTraceStaticMappingManager implements TraceStaticMappingManager, D
protected final DBCachedObjectIndex<Address, DBTraceStaticMapping> mappingsByAddress;
protected final Collection<DBTraceStaticMapping> view;
public DBTraceStaticMappingManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceStaticMappingManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, DBTrace trace, DBTraceOverlaySpaceAdapter overlayAdapter)
throws VersionException, IOException {
this.dbh = dbh;
@ -118,8 +119,9 @@ public class DBTraceStaticMappingManager implements TraceStaticMappingManager, D
@Override
public DBTraceStaticMapping findContaining(Address address, long snap) {
for (DBTraceStaticMapping mapping : mappingsByAddress.head(address,
true).descending().values()) {
for (DBTraceStaticMapping mapping : mappingsByAddress.head(address, true)
.descending()
.values()) {
if (!mapping.getLifespan().contains(snap)) {
continue;
}
@ -134,8 +136,9 @@ public class DBTraceStaticMappingManager implements TraceStaticMappingManager, D
@Override
public DBTraceStaticMapping findAnyConflicting(AddressRange range, Lifespan lifespan,
URL toProgramURL, String toAddress) {
for (DBTraceStaticMapping mapping : mappingsByAddress.head(range.getMaxAddress(),
true).descending().values()) {
for (DBTraceStaticMapping mapping : mappingsByAddress.head(range.getMaxAddress(), true)
.descending()
.values()) {
if (!mapping.conflictsWith(range, lifespan, toProgramURL, toAddress)) {
continue;
}
@ -154,8 +157,9 @@ public class DBTraceStaticMappingManager implements TraceStaticMappingManager, D
public Collection<? extends DBTraceStaticMapping> findAllOverlapping(AddressRange range,
Lifespan lifespan) {
Set<DBTraceStaticMapping> result = new HashSet<>();
for (DBTraceStaticMapping mapping : mappingsByAddress.head(range.getMaxAddress(),
true).descending().values()) {
for (DBTraceStaticMapping mapping : mappingsByAddress.head(range.getMaxAddress(), true)
.descending()
.values()) {
if (!mapping.getLifespan().intersects(lifespan)) {
continue;
}

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

@ -19,6 +19,7 @@ import java.io.IOException;
import java.util.*;
import java.util.stream.Stream;
import ghidra.framework.data.OpenMode;
import ghidra.program.database.ProgramDB;
import ghidra.program.database.function.OverlappingFunctionException;
import ghidra.program.model.address.Address;
@ -173,7 +174,7 @@ public class DBTraceProgramViewFunctionManager implements FunctionManager {
}
@Override
public void programReady(int openMode, int currentRevision, TaskMonitor monitor)
public void programReady(OpenMode openMode, int currentRevision, TaskMonitor monitor)
throws IOException, CancelledException {
throw new UnsupportedOperationException();
}

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

@ -22,6 +22,7 @@ import java.util.concurrent.locks.ReadWriteLock;
import db.DBHandle;
import db.DBRecord;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.lang.Language;
import ghidra.program.model.listing.ProgramUserData;
import ghidra.trace.database.DBTrace;
@ -95,7 +96,7 @@ public class DBTraceAddressPropertyManager implements TraceAddressPropertyManage
protected final TraceAddressPropertyManager apiView =
new DBTraceAddressPropertyManagerApiView(this);
public DBTraceAddressPropertyManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceAddressPropertyManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager) throws VersionException, IOException {
this.dbh = dbh;
@ -117,7 +118,7 @@ public class DBTraceAddressPropertyManager implements TraceAddressPropertyManage
if (ent.map == null) {
try {
propertyMapsByName.put(ent.name,
ent.map = doCreateMap(ent.name, DBOpenMode.UPDATE, ent.getValueClass()));
ent.map = doCreateMap(ent.name, OpenMode.UPDATE, ent.getValueClass()));
}
catch (Exception e) {
Msg.error(this, "Cannot load address property " + ent.name, e);
@ -130,7 +131,7 @@ public class DBTraceAddressPropertyManager implements TraceAddressPropertyManage
}
@SuppressWarnings("unchecked")
protected <T> AbstractDBTracePropertyMap<T, ?> doCreateMap(String name, DBOpenMode openMode,
protected <T> AbstractDBTracePropertyMap<T, ?> doCreateMap(String name, OpenMode openMode,
Class<T> valueClass) {
String tableName = "AddressProperty: " + name;
try {
@ -175,7 +176,7 @@ public class DBTraceAddressPropertyManager implements TraceAddressPropertyManage
}
DBTraceAddressPropertyEntry ent = propertyStore.create();
ent.set(name, valueClass);
AbstractDBTracePropertyMap<T, ?> map = doCreateMap(name, DBOpenMode.CREATE, valueClass);
AbstractDBTracePropertyMap<T, ?> map = doCreateMap(name, OpenMode.CREATE, valueClass);
ent.map = map;
propertyMapsByName.put(name, map);
return map;

3
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/trace/database/space/AbstractDBTraceSpaceBasedManager.java
View file

@ -24,6 +24,7 @@ import db.DBHandle;
import db.DBRecord;
import generic.CatenatedCollection;
import ghidra.dbg.target.TargetRegisterContainer;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.Language;
import ghidra.trace.database.*;
@ -125,7 +126,7 @@ public abstract class AbstractDBTraceSpaceBasedManager<M extends DBTraceSpaceBas
protected final Collection<M> allSpacesView =
new CatenatedCollection<>(memSpacesView, regSpacesView);
public AbstractDBTraceSpaceBasedManager(String name, DBHandle dbh, DBOpenMode openMode,
public AbstractDBTraceSpaceBasedManager(String name, DBHandle dbh, OpenMode openMode,
ReadWriteLock lock, TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager) throws IOException, VersionException {
this.name = name;

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

@ -23,6 +23,7 @@ import db.DBHandle;
import generic.NestedIterator;
import ghidra.dbg.target.*;
import ghidra.dbg.util.*;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.Address;
import ghidra.program.model.address.AddressSetView;
import ghidra.trace.database.DBTrace;
@ -57,10 +58,9 @@ public class DBTraceStackManager implements TraceStackManager, DBTraceManager {
protected final DBCachedObjectStore<DBTraceStackFrame> frameStore;
protected final DBCachedObjectIndex<Address, DBTraceStackFrame> framesByPC;
public DBTraceStackManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceStackManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, DBTrace trace, DBTraceThreadManager threadManager,
DBTraceOverlaySpaceAdapter overlayAdapter)
throws VersionException, IOException {
DBTraceOverlaySpaceAdapter overlayAdapter) throws VersionException, IOException {
this.dbh = dbh;
this.lock = lock;
this.trace = trace;
@ -69,8 +69,8 @@ public class DBTraceStackManager implements TraceStackManager, DBTraceManager {
DBCachedObjectStoreFactory factory = trace.getStoreFactory();
stackStore = factory.getOrCreateCachedStore(DBTraceStack.TABLE_NAME,
DBTraceStack.class, (s, r) -> new DBTraceStack(this, s, r), true);
stackStore = factory.getOrCreateCachedStore(DBTraceStack.TABLE_NAME, DBTraceStack.class,
(s, r) -> new DBTraceStack(this, s, r), true);
stacksByThreadSnap = stackStore.getIndex(ThreadSnap.class, DBTraceStack.THREAD_SNAP_COLUMN);
frameStore = factory.getOrCreateCachedStore(DBTraceStackFrame.TABLE_NAME,
@ -113,9 +113,8 @@ public class DBTraceStackManager implements TraceStackManager, DBTraceManager {
PathPredicates predicates = single(obj, TargetStack.class);
if (createIfAbsent) {
try (LockHold hold = trace.lockWrite()) {
TraceObjectStack stack =
trace.getObjectManager()
.getSuccessor(obj, predicates, snap, TraceObjectStack.class);
TraceObjectStack stack = trace.getObjectManager()
.getSuccessor(obj, predicates, snap, TraceObjectStack.class);
if (stack != null) {
return stack;
}
@ -187,15 +186,16 @@ public class DBTraceStackManager implements TraceStackManager, DBTraceManager {
// TODO: Should probably include a lifespan parameter?
public Iterable<TraceStackFrame> getFramesIn(AddressSetView set) {
if (trace.getObjectManager().hasSchema()) {
return () -> NestedIterator.start(set.iterator(), rng -> trace.getObjectManager()
.getObjectsIntersecting(Lifespan.ALL, rng, TargetStackFrame.PC_ATTRIBUTE_NAME,
TraceObjectStackFrame.class)
.iterator());
return () -> NestedIterator.start(set.iterator(),
rng -> trace.getObjectManager()
.getObjectsIntersecting(Lifespan.ALL, rng,
TargetStackFrame.PC_ATTRIBUTE_NAME, TraceObjectStackFrame.class)
.iterator());
}
return () -> NestedIterator.start(set.iterator(), rng -> framesByPC
.sub(rng.getMinAddress(), true, rng.getMaxAddress(), true)
.values()
.iterator());
return () -> NestedIterator.start(set.iterator(),
rng -> framesByPC.sub(rng.getMinAddress(), true, rng.getMaxAddress(), true)
.values()
.iterator());
}
protected void deleteStack(DBTraceStack stack) {

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

@ -22,6 +22,7 @@ import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import db.DBHandle;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.Language;
import ghidra.trace.database.DBTrace;
@ -47,10 +48,9 @@ public class DBTraceEquateManager extends AbstractDBTraceSpaceBasedManager<DBTra
protected final DBCachedObjectIndex<String, DBTraceEquate> equatesByName;
protected final DBCachedObjectIndex<Long, DBTraceEquate> equatesByValue;
public DBTraceEquateManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor,
Language baseLanguage, DBTrace trace, DBTraceThreadManager threadManager)
throws VersionException, IOException {
public DBTraceEquateManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager) throws VersionException, IOException {
super(NAME, dbh, openMode, lock, monitor, baseLanguage, trace, threadManager);
DBCachedObjectStoreFactory factory = trace.getStoreFactory();
@ -93,8 +93,7 @@ public class DBTraceEquateManager extends AbstractDBTraceSpaceBasedManager<DBTra
}
@Override
public DBTraceEquateSpace getEquateRegisterSpace(TraceThread thread,
boolean createIfAbsent) {
public DBTraceEquateSpace getEquateRegisterSpace(TraceThread thread, boolean createIfAbsent) {
return getForRegisterSpace(thread, 0, createIfAbsent);
}
@ -111,8 +110,8 @@ public class DBTraceEquateManager extends AbstractDBTraceSpaceBasedManager<DBTra
}
@Override
protected DBTraceEquateSpace createRegisterSpace(AddressSpace space,
TraceThread thread, DBTraceSpaceEntry ent) throws VersionException, IOException {
protected DBTraceEquateSpace createRegisterSpace(AddressSpace space, TraceThread thread,
DBTraceSpaceEntry ent) throws VersionException, IOException {
return new DBTraceEquateSpace(this, dbh, space, ent, thread);
}
@ -193,8 +192,7 @@ public class DBTraceEquateManager extends AbstractDBTraceSpaceBasedManager<DBTra
public Collection<? extends DBTraceEquate> getReferenced(long snap, Address address,
int operandIndex) {
return delegateRead(address.getAddressSpace(),
m -> m.getReferenced(snap, address, operandIndex),
Collections.emptyList());
m -> m.getReferenced(snap, address, operandIndex), Collections.emptyList());
}
@Override

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

@ -22,6 +22,7 @@ import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReadWriteLock;
import db.DBHandle;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.Language;
import ghidra.program.model.lang.Register;
@ -38,7 +39,6 @@ import ghidra.trace.model.symbol.TraceReference;
import ghidra.trace.model.symbol.TraceReferenceManager;
import ghidra.trace.model.thread.TraceThread;
import ghidra.util.UnionAddressSetView;
import ghidra.util.database.DBOpenMode;
import ghidra.util.exception.VersionException;
import ghidra.util.task.TaskMonitor;
@ -48,7 +48,7 @@ public class DBTraceReferenceManager extends AbstractDBTraceSpaceBasedManager<DB
protected final DBTraceOverlaySpaceAdapter overlayAdapter;
public DBTraceReferenceManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceReferenceManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager, DBTraceOverlaySpaceAdapter overlayAdapter)
throws VersionException, IOException {
@ -65,8 +65,8 @@ public class DBTraceReferenceManager extends AbstractDBTraceSpaceBasedManager<DB
}
@Override
protected DBTraceReferenceSpace createRegisterSpace(AddressSpace space,
TraceThread thread, DBTraceSpaceEntry ent) throws VersionException, IOException {
protected DBTraceReferenceSpace createRegisterSpace(AddressSpace space, TraceThread thread,
DBTraceSpaceEntry ent) throws VersionException, IOException {
return new DBTraceReferenceSpace(this, dbh, space, ent, thread);
}

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

@ -21,6 +21,7 @@ import java.util.*;
import java.util.concurrent.locks.ReadWriteLock;
import db.*;
import ghidra.framework.data.OpenMode;
import ghidra.lifecycle.Internal;
import ghidra.program.model.address.*;
import ghidra.program.model.data.DataType;
@ -138,10 +139,7 @@ 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;
@ -238,7 +236,7 @@ public class DBTraceSymbolManager implements TraceSymbolManager, DBTraceManager
protected final Map<Byte, AbstractDBTraceSymbolSingleTypeView<?>> symbolViews = new HashMap<>();
public DBTraceSymbolManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceSymbolManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, Language baseLanguage, DBTrace trace,
DBTraceThreadManager threadManager, DBTraceDataTypeManager dataTypeManager,
DBTraceOverlaySpaceAdapter overlayAdapter) throws VersionException, IOException {

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

@ -31,6 +31,7 @@ import ghidra.dbg.target.TargetObject;
import ghidra.dbg.target.schema.*;
import ghidra.dbg.target.schema.TargetObjectSchema.SchemaName;
import ghidra.dbg.util.*;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.Language;
import ghidra.trace.database.DBTrace;
@ -68,8 +69,8 @@ import ghidra.util.task.TaskMonitor;
public class DBTraceObjectManager implements TraceObjectManager, DBTraceManager {
private static final int OBJECTS_CONTAINING_CACHE_SIZE = 100;
public static class DBTraceObjectSchemaDBFieldCodec extends
AbstractDBFieldCodec<SchemaContext, DBTraceObjectSchemaEntry, StringField> {
public static class DBTraceObjectSchemaDBFieldCodec
extends AbstractDBFieldCodec<SchemaContext, DBTraceObjectSchemaEntry, StringField> {
public DBTraceObjectSchemaDBFieldCodec(Class<DBTraceObjectSchemaEntry> objectType,
Field field, int column) {
super(SchemaContext.class, objectType, StringField.class, field, column);
@ -118,9 +119,7 @@ public class DBTraceObjectManager implements TraceObjectManager, DBTraceManager
@DBAnnotatedColumn(SCHEMA_COLUMN_NAME)
static DBObjectColumn SCHEMA_COLUMN;
@DBAnnotatedField(
column = CONTEXT_COLUMN_NAME,
codec = DBTraceObjectSchemaDBFieldCodec.class)
@DBAnnotatedField(column = CONTEXT_COLUMN_NAME, codec = DBTraceObjectSchemaDBFieldCodec.class)
private SchemaContext context;
@DBAnnotatedField(column = SCHEMA_COLUMN_NAME)
private String schemaName;
@ -175,7 +174,7 @@ public class DBTraceObjectManager implements TraceObjectManager, DBTraceManager
protected final Map<Class<? extends TraceObjectInterface>, Set<TargetObjectSchema>> //
schemasByInterface = new HashMap<>();
public DBTraceObjectManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceObjectManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, Language baseLanguage, DBTrace trace)
throws IOException, VersionException {
this.lock = lock;
@ -185,16 +184,15 @@ public class DBTraceObjectManager implements TraceObjectManager, DBTraceManager
schemaStore = factory.getOrCreateCachedStore(DBTraceObjectSchemaEntry.TABLE_NAME,
DBTraceObjectSchemaEntry.class, DBTraceObjectSchemaEntry::new, true);
loadRootSchema();
objectStore = factory.getOrCreateCachedStore(DBTraceObject.TABLE_NAME,
DBTraceObject.class, (s, r) -> new DBTraceObject(this, s, r), true);
objectStore = factory.getOrCreateCachedStore(DBTraceObject.TABLE_NAME, DBTraceObject.class,
(s, r) -> new DBTraceObject(this, s, r), true);
valueTree = new DBTraceObjectValueRStarTree(this, factory,
DBTraceObjectValueData.TABLE_NAME, ValueSpace.INSTANCE, DBTraceObjectValueData.class,
DBTraceObjectValueNode.class, false, 50);
valueMap = valueTree.asSpatialMap();
objectsByPath =
objectStore.getIndex(TraceObjectKeyPath.class, DBTraceObject.PATH_COLUMN);
objectsByPath = objectStore.getIndex(TraceObjectKeyPath.class, DBTraceObject.PATH_COLUMN);
valueWbCache = new DBTraceObjectValueWriteBehindCache(this);
@ -297,12 +295,12 @@ public class DBTraceObjectManager implements TraceObjectManager, DBTraceManager
return entry;
}
protected DBTraceObjectValue doCreateValue(Lifespan lifespan,
DBTraceObject parent, String key, Object value) {
protected DBTraceObjectValue doCreateValue(Lifespan lifespan, DBTraceObject parent, String key,
Object value) {
// Root is never in write-behind cache
DBTraceObjectValue entry = parent == null
? doCreateValueData(lifespan, parent, key, value).getWrapper()
: valueWbCache.doCreateValue(lifespan, parent, key, value).getWrapper();
DBTraceObjectValue entry =
parent == null ? doCreateValueData(lifespan, parent, key, value).getWrapper()
: valueWbCache.doCreateValue(lifespan, parent, key, value).getWrapper();
if (parent != null) {
parent.notifyValueCreated(entry);
}
@ -420,18 +418,17 @@ public class DBTraceObjectManager implements TraceObjectManager, DBTraceManager
@Override
public Stream<DBTraceObjectValue> getAllValues() {
return Stream.concat(
valueMap.values().stream().map(v -> v.getWrapper()),
StreamUtils.lock(lock.readLock(),
valueWbCache.streamAllValues().map(v -> v.getWrapper())));
return Stream.concat(valueMap.values().stream().map(v -> v.getWrapper()), StreamUtils
.lock(lock.readLock(), valueWbCache.streamAllValues().map(v -> v.getWrapper())));
}
protected Stream<DBTraceObjectValueData> streamValuesIntersectingData(Lifespan span,
AddressRange range, String entryKey) {
return valueMap.reduce(TraceObjectValueQuery.intersecting(
entryKey != null ? entryKey : EntryKeyDimension.INSTANCE.absoluteMin(),
entryKey != null ? entryKey : EntryKeyDimension.INSTANCE.absoluteMax(),
span, range)).values().stream();
entryKey != null ? entryKey : EntryKeyDimension.INSTANCE.absoluteMax(), span, range))
.values()
.stream();
}
protected Stream<DBTraceObjectValueBehind> streamValuesIntersectingBehind(Lifespan span,
@ -442,9 +439,10 @@ public class DBTraceObjectManager implements TraceObjectManager, DBTraceManager
@Override
public Collection<? extends TraceObjectValue> getValuesIntersecting(Lifespan span,
AddressRange range, String entryKey) {
return Stream.concat(
streamValuesIntersectingData(span, range, entryKey).map(v -> v.getWrapper()),
streamValuesIntersectingBehind(span, range, entryKey).map(v -> v.getWrapper()))
return Stream
.concat(
streamValuesIntersectingData(span, range, entryKey).map(v -> v.getWrapper()),
streamValuesIntersectingBehind(span, range, entryKey).map(v -> v.getWrapper()))
.toList();
}
@ -460,9 +458,9 @@ public class DBTraceObjectManager implements TraceObjectManager, DBTraceManager
public Collection<? extends TraceObjectValue> getValuesAt(long snap, Address address,
String entryKey) {
return Stream.concat(
streamValuesAtData(snap, address, entryKey).map(v -> v.getWrapper()),
streamValuesAtBehind(snap, address, entryKey).map(v -> v.getWrapper()))
return Stream
.concat(streamValuesAtData(snap, address, entryKey).map(v -> v.getWrapper()),
streamValuesAtBehind(snap, address, entryKey).map(v -> v.getWrapper()))
.toList();
}
@ -474,16 +472,14 @@ public class DBTraceObjectManager implements TraceObjectManager, DBTraceManager
}
Class<? extends TargetObject> targetIf = TraceObjectInterfaceUtils.toTargetIf(ifClass);
PathMatcher matcher = rootSchema.searchFor(targetIf, true);
return getValuePaths(span, matcher)
.filter(p -> {
TraceObject object = p.getDestination(getRootObject());
if (object == null) {
Msg.error(this, "NULL VALUE! " + p.getLastEntry());
return false;
}
return true;
})
.map(p -> p.getDestination(getRootObject()).queryInterface(ifClass));
return getValuePaths(span, matcher).filter(p -> {
TraceObject object = p.getDestination(getRootObject());
if (object == null) {
Msg.error(this, "NULL VALUE! " + p.getLastEntry());
return false;
}
return true;
}).map(p -> p.getDestination(getRootObject()).queryInterface(ifClass));
}
@Override
@ -632,8 +628,8 @@ public class DBTraceObjectManager implements TraceObjectManager, DBTraceManager
return Set.copyOf(result);
}
public <I extends TraceObjectInterface> Collection<I> getObjectsIntersecting(
Lifespan lifespan, AddressRange range, String key, Class<I> iface) {
public <I extends TraceObjectInterface> Collection<I> getObjectsIntersecting(Lifespan lifespan,
AddressRange range, String key, Class<I> iface) {
try (LockHold hold = trace.lockRead()) {
Set<TargetObjectSchema> schemas;
synchronized (schemasByInterface) {
@ -802,8 +798,8 @@ public class DBTraceObjectManager implements TraceObjectManager, DBTraceManager
if (!exists.getLife().intersects(lifespan)) {
return;
}
throw new DuplicateNameException("A thread having path '" + path +
"' already exists within an overlapping snap");
throw new DuplicateNameException(
"A thread having path '" + path + "' already exists within an overlapping snap");
}
public TraceObjectThread addThread(String path, String display, Lifespan lifespan)

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

@ -21,6 +21,7 @@ import java.util.concurrent.locks.ReadWriteLock;
import java.util.stream.Collectors;
import db.DBHandle;
import ghidra.framework.data.OpenMode;
import ghidra.trace.database.DBTrace;
import ghidra.trace.database.DBTraceManager;
import ghidra.trace.database.target.DBTraceObject;
@ -44,7 +45,7 @@ public class DBTraceThreadManager implements TraceThreadManager, DBTraceManager
protected final DBCachedObjectStore<DBTraceThread> threadStore;
protected final DBCachedObjectIndex<String, DBTraceThread> threadsByPath;
public DBTraceThreadManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceThreadManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, DBTrace trace, DBTraceObjectManager objectManager)
throws IOException, VersionException {
this.lock = lock;
@ -104,8 +105,7 @@ public class DBTraceThreadManager implements TraceThreadManager, DBTraceManager
}
@Override
public TraceThread addThread(String path, Lifespan lifespan)
throws DuplicateNameException {
public TraceThread addThread(String path, Lifespan lifespan) throws DuplicateNameException {
return addThread(path, path, lifespan);
}
@ -168,8 +168,7 @@ public class DBTraceThreadManager implements TraceThreadManager, DBTraceManager
public Collection<? extends TraceThread> getLiveThreads(long snap) {
if (objectManager.hasSchema()) {
try (LockHold hold = LockHold.lock(lock.readLock())) {
return objectManager
.queryAllInterface(Lifespan.at(snap), TraceObjectThread.class)
return objectManager.queryAllInterface(Lifespan.at(snap), TraceObjectThread.class)
// Exclude the destruction
.filter(thread -> thread.getCreationSnap() <= snap &&
snap < thread.getDestructionSnap())

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

@ -22,6 +22,7 @@ import java.util.Map.Entry;
import java.util.concurrent.locks.ReadWriteLock;
import db.DBHandle;
import ghidra.framework.data.OpenMode;
import ghidra.trace.database.DBTrace;
import ghidra.trace.database.DBTraceManager;
import ghidra.trace.database.thread.DBTraceThreadManager;
@ -44,7 +45,7 @@ public class DBTraceTimeManager implements TraceTimeManager, DBTraceManager {
protected final DBCachedObjectStore<DBTraceSnapshot> snapshotStore;
protected final DBCachedObjectIndex<String, DBTraceSnapshot> snapshotsBySchedule;
public DBTraceTimeManager(DBHandle dbh, DBOpenMode openMode, ReadWriteLock lock,
public DBTraceTimeManager(DBHandle dbh, OpenMode openMode, ReadWriteLock lock,
TaskMonitor monitor, DBTrace trace, DBTraceThreadManager threadManager)
throws VersionException, IOException {
this.trace = trace;

28
Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/trace/database/ToyDBTraceBuilder.java
View file

@ -34,6 +34,7 @@ import generic.theme.GThemeDefaults.Colors.Messages;
import ghidra.app.plugin.processors.sleigh.SleighLanguage;
import ghidra.dbg.target.TargetExecutionStateful.TargetExecutionState;
import ghidra.dbg.util.PathPredicates;
import ghidra.framework.data.OpenMode;
import ghidra.pcode.exec.*;
import ghidra.pcode.exec.trace.TraceSleighUtils;
import ghidra.program.disassemble.Disassembler;
@ -61,7 +62,6 @@ import ghidra.trace.model.target.TraceObject.ConflictResolution;
import ghidra.trace.model.thread.TraceObjectThread;
import ghidra.trace.model.thread.TraceThread;
import ghidra.util.Msg;
import ghidra.util.database.DBOpenMode;
import ghidra.util.exception.*;
import ghidra.util.task.ConsoleTaskMonitor;
@ -95,7 +95,7 @@ public class ToyDBTraceBuilder implements AutoCloseable {
public ToyDBTraceBuilder(File file)
throws CancelledException, VersionException, LanguageNotFoundException, IOException {
DBHandle handle = new DBHandle(file);
this.trace = new DBTrace(handle, DBOpenMode.UPDATE, new ConsoleTaskMonitor(), this);
this.trace = new DBTrace(handle, OpenMode.UPDATE, new ConsoleTaskMonitor(), this);
this.language = trace.getBaseLanguage();
this.host = trace.getPlatformManager().getHostPlatform();
}
@ -553,8 +553,8 @@ public class ToyDBTraceBuilder implements AutoCloseable {
* @return the instruction unit
* @throws CodeUnitInsertionException if the instruction cannot be created
*/
public DBTraceInstruction addInstruction(long snap, Address start,
TracePlatform platform) throws CodeUnitInsertionException {
public DBTraceInstruction addInstruction(long snap, Address start, TracePlatform platform)
throws CodeUnitInsertionException {
DBTraceCodeManager code = trace.getCodeManager();
Language platformLanguage = platform.getLanguage();
Disassembler dis =
@ -637,8 +637,8 @@ public class ToyDBTraceBuilder implements AutoCloseable {
public DBTraceReference addMemoryReference(long creationSnap, Address from, Address to,
int operandIndex) {
return trace.getReferenceManager()
.addMemoryReference(Lifespan.nowOn(creationSnap), from, to,
RefType.DATA, SourceType.DEFAULT, operandIndex);
.addMemoryReference(Lifespan.nowOn(creationSnap), from, to, RefType.DATA,
SourceType.DEFAULT, operandIndex);
}
/**
@ -655,8 +655,8 @@ public class ToyDBTraceBuilder implements AutoCloseable {
public DBTraceReference addOffsetReference(long creationSnap, Address from, Address to,
boolean toAddrIsBase, long offset) {
return trace.getReferenceManager()
.addOffsetReference(Lifespan.nowOn(creationSnap), from, to, toAddrIsBase,
offset, RefType.DATA, SourceType.DEFAULT, -1);
.addOffsetReference(Lifespan.nowOn(creationSnap), from, to, toAddrIsBase, offset,
RefType.DATA, SourceType.DEFAULT, -1);
}
/**
@ -677,8 +677,8 @@ public class ToyDBTraceBuilder implements AutoCloseable {
public DBTraceReference addShiftedReference(long creationSnap, Address from, Address to,
int shift) {
return trace.getReferenceManager()
.addShiftedReference(Lifespan.nowOn(creationSnap), from,
to, shift, RefType.DATA, SourceType.DEFAULT, -1);
.addShiftedReference(Lifespan.nowOn(creationSnap), from, to, shift, RefType.DATA,
SourceType.DEFAULT, -1);
}
/**
@ -696,8 +696,8 @@ public class ToyDBTraceBuilder implements AutoCloseable {
*/
public DBTraceReference addRegisterReference(long creationSnap, Address from, String to) {
return trace.getReferenceManager()
.addRegisterReference(Lifespan.nowOn(creationSnap), from,
language.getRegister(to), RefType.DATA, SourceType.DEFAULT, -1);
.addRegisterReference(Lifespan.nowOn(creationSnap), from, language.getRegister(to),
RefType.DATA, SourceType.DEFAULT, -1);
}
/**
@ -715,8 +715,8 @@ public class ToyDBTraceBuilder implements AutoCloseable {
*/
public DBTraceReference addStackReference(long creationSnap, Address from, int to) {
return trace.getReferenceManager()
.addStackReference(Lifespan.nowOn(creationSnap), from, to,
RefType.DATA, SourceType.DEFAULT, -1);
.addStackReference(Lifespan.nowOn(creationSnap), from, to, RefType.DATA,
SourceType.DEFAULT, -1);
}
/**

3
Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapAddressSetViewTest.java
View file

@ -24,6 +24,7 @@ import java.util.function.Predicate;
import org.junit.*;
import db.*;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.Language;
import ghidra.program.model.lang.LanguageID;
@ -43,7 +44,7 @@ public class DBTraceAddressSnapRangePropertyMapAddressSetViewTest
extends AbstractGhidraHeadlessIntegrationTest {
protected static class MyObject extends DBCachedDomainObjectAdapter {
protected MyObject(Object consumer) throws IOException {
super(new DBHandle(), DBOpenMode.CREATE, new ConsoleTaskMonitor(), "Testing", 500, 1000,
super(new DBHandle(), OpenMode.CREATE, new ConsoleTaskMonitor(), "Testing", 500, 1000,
consumer);
}

12
Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapOcclusionIntoFutureIterableTest.java
View file

@ -25,6 +25,7 @@ import org.apache.commons.lang3.tuple.ImmutablePair;
import org.junit.*;
import db.*;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.Language;
import ghidra.program.model.lang.LanguageID;
@ -42,7 +43,7 @@ public class DBTraceAddressSnapRangePropertyMapOcclusionIntoFutureIterableTest
extends AbstractGhidraHeadlessIntegrationTest {
protected static class MyObject extends DBCachedDomainObjectAdapter {
protected MyObject(Object consumer) throws IOException {
super(new DBHandle(), DBOpenMode.CREATE, new ConsoleTaskMonitor(), "Testing", 500, 1000,
super(new DBHandle(), OpenMode.CREATE, new ConsoleTaskMonitor(), "Testing", 500, 1000,
consumer);
}
@ -152,8 +153,7 @@ public class DBTraceAddressSnapRangePropertyMapOcclusionIntoFutureIterableTest
@Before
public void setUp() throws IOException, VersionException {
toy = DefaultLanguageService.getLanguageService()
.getLanguage(
new LanguageID("Toy:BE:64:default"));
.getLanguage(new LanguageID("Toy:BE:64:default"));
obj = new MyObject(this);
factory = new DBCachedObjectStoreFactory(obj);
try (Transaction tx = obj.openTransaction("CreateTable")) {
@ -240,12 +240,10 @@ public class DBTraceAddressSnapRangePropertyMapOcclusionIntoFutureIterableTest
}
it = makeOcclusionIterable(tasr(0x0000, -0x0001, Long.MIN_VALUE, Long.MAX_VALUE));
assertEquals(list(
ent(0x0000, 0x0fff, 5, 10, "W"),
assertEquals(list(ent(0x0000, 0x0fff, 5, 10, "W"),
ent(0x1000, 0x1fff, Long.MIN_VALUE, Long.MIN_VALUE + 10, "S"),
ent(0x2000, 0x2fff, Long.MAX_VALUE - 10, Long.MAX_VALUE, "N"),
ent(-0x1000, -0x0001, 5, 10, "E")),
list(it));
ent(-0x1000, -0x0001, 5, 10, "E")), list(it));
}
@Test

6
Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapOcclusionIntoPastIterableTest.java
View file

@ -25,6 +25,7 @@ import org.apache.commons.lang3.tuple.ImmutablePair;
import org.junit.*;
import db.*;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.*;
import ghidra.program.model.lang.Language;
import ghidra.program.model.lang.LanguageID;
@ -42,7 +43,7 @@ public class DBTraceAddressSnapRangePropertyMapOcclusionIntoPastIterableTest
extends AbstractGhidraHeadlessIntegrationTest {
protected static class MyObject extends DBCachedDomainObjectAdapter {
protected MyObject(Object consumer) throws IOException {
super(new DBHandle(), DBOpenMode.CREATE, new ConsoleTaskMonitor(), "Testing", 500, 1000,
super(new DBHandle(), OpenMode.CREATE, new ConsoleTaskMonitor(), "Testing", 500, 1000,
consumer);
}
@ -152,8 +153,7 @@ public class DBTraceAddressSnapRangePropertyMapOcclusionIntoPastIterableTest
@Before
public void setUp() throws IOException, VersionException {
toy = DefaultLanguageService.getLanguageService()
.getLanguage(
new LanguageID("Toy:BE:64:default"));
.getLanguage(new LanguageID("Toy:BE:64:default"));
obj = new MyObject(this);
factory = new DBCachedObjectStoreFactory(obj);
try (Transaction tid = obj.openTransaction("CreateTable")) {

10
Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/trace/database/map/DBTraceAddressSnapRangePropertyMapSpaceTest.java
View file

@ -29,6 +29,7 @@ import org.apache.commons.lang3.tuple.ImmutablePair;
import org.junit.*;
import db.*;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.Address;
import ghidra.program.model.lang.Language;
import ghidra.program.model.lang.LanguageID;
@ -61,7 +62,7 @@ public class DBTraceAddressSnapRangePropertyMapSpaceTest
private DBTraceAddressSnapRangePropertyMapSpace<MyEntry, MyEntry> space2;
private DBTraceAddressSnapRangePropertyMapSpace<String, AltEntry> space3;
protected MyObject(DBHandle dbh, DBOpenMode openMode, Language toy, Object consumer)
protected MyObject(DBHandle dbh, OpenMode openMode, Language toy, Object consumer)
throws VersionException, IOException {
super(dbh, openMode, new ConsoleTaskMonitor(), "Testing", 500, 1000, consumer);
this.toy = toy;
@ -70,12 +71,12 @@ public class DBTraceAddressSnapRangePropertyMapSpaceTest
}
protected MyObject(Language toy, Object consumer) throws IOException, VersionException {
this(new DBHandle(), DBOpenMode.CREATE, toy, consumer);
this(new DBHandle(), OpenMode.CREATE, toy, consumer);
}
protected MyObject(File file, Language toy, Object consumer)
throws IOException, VersionException {
this(new DBHandle(file), DBOpenMode.UPDATE, toy, consumer);
this(new DBHandle(file), OpenMode.UPDATE, toy, consumer);
}
protected void loadSpaces() throws VersionException, IOException {
@ -211,8 +212,7 @@ public class DBTraceAddressSnapRangePropertyMapSpaceTest
@Before
public void setUp() throws IOException, VersionException {
toy = DefaultLanguageService.getLanguageService()
.getLanguage(
new LanguageID("Toy:BE:64:default"));
.getLanguage(new LanguageID("Toy:BE:64:default"));
obj = new MyObject(toy, this);
}

62
Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/trace/database/memory/AbstractDBTraceMemoryManagerMemoryTest.java
View file

@ -24,13 +24,13 @@ import java.util.*;
import org.junit.Test;
import db.Transaction;
import db.DBHandle;
import db.Transaction;
import ghidra.framework.data.OpenMode;
import ghidra.program.model.address.*;
import ghidra.trace.database.DBTrace;
import ghidra.trace.model.TraceAddressSnapRange;
import ghidra.trace.model.memory.TraceMemoryState;
import ghidra.util.database.DBOpenMode;
import ghidra.util.task.ConsoleTaskMonitor;
import ghidra.util.task.TaskMonitor;
@ -683,62 +683,52 @@ public abstract class AbstractDBTraceMemoryManagerMemoryTest
}
try {
memory.findBytes(3, b.range(0x4000, 0x4003), b.buf(1, 2, 3, 4), b.buf(-1, -1, -1),
true, TaskMonitor.DUMMY);
memory.findBytes(3, b.range(0x4000, 0x4003), b.buf(1, 2, 3, 4), b.buf(-1, -1, -1), true,
TaskMonitor.DUMMY);
}
catch (IllegalArgumentException e) {
// pass
}
// Degenerate
assertNull(
memory.findBytes(2, b.range(0x4000, 0x4003), b.buf(), b.buf(),
true, TaskMonitor.DUMMY));
assertNull(memory.findBytes(2, b.range(0x4000, 0x4003), b.buf(), b.buf(), true,
TaskMonitor.DUMMY));
// Too soon
assertNull(
memory.findBytes(2, b.range(0x4000, 0x4003), b.buf(1, 2, 3, 4), b.buf(-1, -1, -1, -1),
true, TaskMonitor.DUMMY));
assertNull(memory.findBytes(2, b.range(0x4000, 0x4003), b.buf(1, 2, 3, 4),
b.buf(-1, -1, -1, -1), true, TaskMonitor.DUMMY));
// Too small
assertNull(
memory.findBytes(3, b.range(0x4000, 0x4002), b.buf(1, 2, 3, 4), b.buf(-1, -1, -1, -1),
true, TaskMonitor.DUMMY));
assertNull(memory.findBytes(3, b.range(0x4000, 0x4002), b.buf(1, 2, 3, 4),
b.buf(-1, -1, -1, -1), true, TaskMonitor.DUMMY));
// Too high
assertNull(
memory.findBytes(3, b.range(0x4001, 0x4004), b.buf(1, 2, 3, 4), b.buf(-1, -1, -1, -1),
true, TaskMonitor.DUMMY));
assertNull(memory.findBytes(3, b.range(0x4001, 0x4004), b.buf(1, 2, 3, 4),
b.buf(-1, -1, -1, -1), true, TaskMonitor.DUMMY));
// Too high, into unknown
assertNull(
memory.findBytes(3, b.range(0x4001, 0x4005), b.buf(1, 2, 3, 4, 5),
b.buf(-1, -1, -1, -1, -1), true, TaskMonitor.DUMMY));
assertNull(memory.findBytes(3, b.range(0x4001, 0x4005), b.buf(1, 2, 3, 4, 5),
b.buf(-1, -1, -1, -1, -1), true, TaskMonitor.DUMMY));
// Too low
assertNull(
memory.findBytes(3, b.range(0x3fff, 0x4002), b.buf(1, 2, 3, 4), b.buf(-1, -1, -1, -1),
true, TaskMonitor.DUMMY));
assertNull(memory.findBytes(3, b.range(0x3fff, 0x4002), b.buf(1, 2, 3, 4),
b.buf(-1, -1, -1, -1), true, TaskMonitor.DUMMY));
// Perfect match
assertEquals(b.addr(0x4000),
memory.findBytes(3, b.range(0x4000, 0x4003), b.buf(1, 2, 3, 4), b.buf(-1, -1, -1, -1),
true, TaskMonitor.DUMMY));
assertEquals(b.addr(0x4000), memory.findBytes(3, b.range(0x4000, 0x4003), b.buf(1, 2, 3, 4),
b.buf(-1, -1, -1, -1), true, TaskMonitor.DUMMY));
// Make it work for the match
assertEquals(b.addr(0x4000), memory.findBytes(3, b.range(0x0, -1), b.buf(1, 2, 3, 4),
b.buf(-1, -1, -1, -1), true, TaskMonitor.DUMMY));
// Make it work for the match
assertEquals(b.addr(0x4000),
memory.findBytes(3, b.range(0x0, -1), b.buf(1, 2, 3, 4), b.buf(-1, -1, -1, -1),
true, TaskMonitor.DUMMY));
// Make it work for the match
assertEquals(b.addr(0x4000),
memory.findBytes(3, b.range(0x0, -1), b.buf(1), b.buf(-1),
true, TaskMonitor.DUMMY));
memory.findBytes(3, b.range(0x0, -1), b.buf(1), b.buf(-1), true, TaskMonitor.DUMMY));
// Sub match
assertEquals(b.addr(0x4001),
memory.findBytes(3, b.range(0x4000, 0x4003), b.buf(2, 3, 4), b.buf(-1, -1, -1),
true, TaskMonitor.DUMMY));
assertEquals(b.addr(0x4001), memory.findBytes(3, b.range(0x4000, 0x4003), b.buf(2, 3, 4),
b.buf(-1, -1, -1), true, TaskMonitor.DUMMY));
}
@Test
@ -811,7 +801,7 @@ public abstract class AbstractDBTraceMemoryManagerMemoryTest
DBHandle opened = new DBHandle(tmp.toFile());
DBTrace restored = null;
try {
restored = new DBTrace(opened, DBOpenMode.UPDATE, new ConsoleTaskMonitor(), this);
restored = new DBTrace(opened, OpenMode.UPDATE, new ConsoleTaskMonitor(), this);
DBTraceMemorySpace rSpace =
restored.getMemoryManager().getMemorySpace(b.language.getDefaultDataSpace(), true);