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

GP-1161: Including uniques in thread-local state, and renaming things by those terms.

Browse source
This commit is contained in:
Dan 2021-08-24 08:20:42 -04:00
parent 0c56f638a3
commit 237b7c00d1
8 changed files with 53 additions and 49 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Ghidra/Debug/Debugger/src/main/java/ghidra/app/plugin/core/debug/service/emulation/DebuggerTracePcodeEmulator.java
View file

@ -70,13 +70,13 @@ public class DebuggerTracePcodeEmulator extends TracePcodeEmulator {
} }
@Override @Override
protected PcodeExecutorState<byte[]> createMemoryState() { protected PcodeExecutorState<byte[]> createSharedState() {
return new ReadsTargetMemoryPcodeExecutorState(tool, trace, snap, null, 0, return new ReadsTargetMemoryPcodeExecutorState(tool, trace, snap, null, 0,
recorder); recorder);
} }
@Override @Override
protected PcodeExecutorState<byte[]> createRegisterState(PcodeThread<byte[]> emuThread) { protected PcodeExecutorState<byte[]> createLocalState(PcodeThread<byte[]> emuThread) {
TraceThread traceThread = TraceThread traceThread =
trace.getThreadManager().getLiveThreadByPath(snap, emuThread.getName()); trace.getThreadManager().getLiveThreadByPath(snap, emuThread.getName());
return new ReadsTargetRegistersPcodeExecutorState(tool, trace, snap, traceThread, 0, return new ReadsTargetRegistersPcodeExecutorState(tool, trace, snap, traceThread, 0,

16
Ghidra/Debug/Framework-TraceModeling/src/main/java/ghidra/pcode/exec/trace/TracePcodeEmulator.java
View file

@ -55,12 +55,12 @@ public class TracePcodeEmulator extends AbstractPcodeEmulator {
} }
@Override @Override
protected PcodeExecutorState<byte[]> createMemoryState() { protected PcodeExecutorState<byte[]> createSharedState() {
return newState(null); return newState(null);
} }
@Override @Override
protected PcodeExecutorState<byte[]> createRegisterState(PcodeThread<byte[]> emuThread) { protected PcodeExecutorState<byte[]> createLocalState(PcodeThread<byte[]> emuThread) {
return newState(trace.getThreadManager().getLiveThreadByPath(snap, emuThread.getName())); return newState(trace.getThreadManager().getLiveThreadByPath(snap, emuThread.getName()));
} }
@ -79,13 +79,13 @@ public class TracePcodeEmulator extends AbstractPcodeEmulator {
* @param synthesizeStacks true to synthesize the innermost stack frame of each thread * @param synthesizeStacks true to synthesize the innermost stack frame of each thread
*/ */
public void writeDown(Trace trace, long destSnap, long threadsSnap, boolean synthesizeStacks) { public void writeDown(Trace trace, long destSnap, long threadsSnap, boolean synthesizeStacks) {
TraceCachedWriteBytesPcodeExecutorState ms = TraceCachedWriteBytesPcodeExecutorState ss =
(TraceCachedWriteBytesPcodeExecutorState) getMemoryState(); (TraceCachedWriteBytesPcodeExecutorState) getSharedState();
ms.writeCacheDown(trace, destSnap, null, 0); ss.writeCacheDown(trace, destSnap, null, 0);
TraceThreadManager threadManager = trace.getThreadManager(); TraceThreadManager threadManager = trace.getThreadManager();
for (PcodeThread<byte[]> emuThread : threads.values()) { for (PcodeThread<byte[]> emuThread : threads.values()) {
TraceCachedWriteBytesPcodeExecutorState rs = TraceCachedWriteBytesPcodeExecutorState ls =
(TraceCachedWriteBytesPcodeExecutorState) emuThread.getState().getRegisterState(); (TraceCachedWriteBytesPcodeExecutorState) emuThread.getState().getLocalState();
TraceThread traceThread = threadManager.getLiveThreadByPath( TraceThread traceThread = threadManager.getLiveThreadByPath(
threadsSnap, emuThread.getName()); threadsSnap, emuThread.getName());
if (traceThread == null) { if (traceThread == null) {
@ -93,7 +93,7 @@ public class TracePcodeEmulator extends AbstractPcodeEmulator {
"Given trace does not have thread with name/path '" + emuThread.getName() + "Given trace does not have thread with name/path '" + emuThread.getName() +
"' at snap " + destSnap); "' at snap " + destSnap);
} }
rs.writeCacheDown(trace, destSnap, traceThread, 0); ls.writeCacheDown(trace, destSnap, traceThread, 0);
if (synthesizeStacks) { if (synthesizeStacks) {
TraceStack stack = trace.getStackManager().getStack(traceThread, destSnap, true); TraceStack stack = trace.getStackManager().getStack(traceThread, destSnap, true);
stack.getFrame(0, true).setProgramCounter(emuThread.getCounter()); stack.getFrame(0, true).setProgramCounter(emuThread.getCounter());

4
Ghidra/Debug/Framework-TraceModeling/src/test/java/ghidra/trace/model/time/TraceScheduleTest.java
View file

@ -385,12 +385,12 @@ public class TraceScheduleTest extends AbstractGhidraHeadlessIntegrationTest {
} }
@Override @Override
protected PcodeExecutorState<Void> createMemoryState() { protected PcodeExecutorState<Void> createSharedState() {
return null; return null;
} }
@Override @Override
protected PcodeExecutorState<Void> createRegisterState(PcodeThread<Void> thread) { protected PcodeExecutorState<Void> createLocalState(PcodeThread<Void> thread) {
return null; return null;
} }
} }

14
Ghidra/Debug/ProposedUtils/src/main/java/ghidra/pcode/emu/AbstractPcodeMachine.java
View file

@ -34,7 +34,7 @@ public abstract class AbstractPcodeMachine<T> implements PcodeMachine<T> {
protected final SleighUseropLibrary<T> stubLibrary; protected final SleighUseropLibrary<T> stubLibrary;
/* for abstract thread access */ PcodeStateInitializer initializer; /* for abstract thread access */ PcodeStateInitializer initializer;
private PcodeExecutorState<T> memoryState; private PcodeExecutorState<T> sharedState;
protected final Map<String, PcodeThread<T>> threads = new LinkedHashMap<>(); protected final Map<String, PcodeThread<T>> threads = new LinkedHashMap<>();
protected final Map<Address, PcodeProgram> injects = new HashMap<>(); protected final Map<Address, PcodeProgram> injects = new HashMap<>();
@ -55,9 +55,9 @@ public abstract class AbstractPcodeMachine<T> implements PcodeMachine<T> {
this.initializer = getPluggableInitializer(language); this.initializer = getPluggableInitializer(language);
} }
protected abstract PcodeExecutorState<T> createMemoryState(); protected abstract PcodeExecutorState<T> createSharedState();
protected abstract PcodeExecutorState<T> createRegisterState(PcodeThread<T> thread); protected abstract PcodeExecutorState<T> createLocalState(PcodeThread<T> thread);
protected SleighUseropLibrary<T> createThreadStubLibrary() { protected SleighUseropLibrary<T> createThreadStubLibrary() {
return new DefaultPcodeThread.SleighEmulationLibrary<T>(null); return new DefaultPcodeThread.SleighEmulationLibrary<T>(null);
@ -113,12 +113,12 @@ public abstract class AbstractPcodeMachine<T> implements PcodeMachine<T> {
} }
@Override @Override
public PcodeExecutorState<T> getMemoryState() { public PcodeExecutorState<T> getSharedState() {
if (memoryState == null) { if (sharedState == null) {
memoryState = createMemoryState(); sharedState = createSharedState();
doPluggableInitialization(); doPluggableInitialization();
} }
return memoryState; return sharedState;
} }
protected PcodeProgram getInject(Address address) { protected PcodeProgram getInject(Address address) {

12
Ghidra/Debug/ProposedUtils/src/main/java/ghidra/pcode/emu/DefaultPcodeThread.java
View file

@ -114,10 +114,10 @@ public class DefaultPcodeThread<T> implements PcodeThread<T> {
this.machine = machine; this.machine = machine;
this.language = machine.language; this.language = machine.language;
this.arithmetic = machine.arithmetic; this.arithmetic = machine.arithmetic;
PcodeExecutorState<T> memoryState = machine.getMemoryState(); PcodeExecutorState<T> sharedState = machine.getSharedState();
PcodeExecutorState<T> registerState = machine.createRegisterState(this); PcodeExecutorState<T> localState = machine.createLocalState(this);
this.state = new ThreadPcodeExecutorState<>(memoryState, registerState); this.state = new ThreadPcodeExecutorState<>(sharedState, localState);
this.decoder = createInstructionDecoder(memoryState); this.decoder = createInstructionDecoder(sharedState);
this.library = createUseropLibrary(); this.library = createUseropLibrary();
this.executor = createExecutor(); this.executor = createExecutor();
@ -135,8 +135,8 @@ public class DefaultPcodeThread<T> implements PcodeThread<T> {
this.reInitialize(); this.reInitialize();
} }
protected SleighInstructionDecoder createInstructionDecoder(PcodeExecutorState<T> memoryState) { protected SleighInstructionDecoder createInstructionDecoder(PcodeExecutorState<T> sharedState) {
return new SleighInstructionDecoder(language, memoryState); return new SleighInstructionDecoder(language, sharedState);
} }
protected SleighUseropLibrary<T> createUseropLibrary() { protected SleighUseropLibrary<T> createUseropLibrary() {

4
Ghidra/Debug/ProposedUtils/src/main/java/ghidra/pcode/emu/PcodeMachine.java
View file

@ -54,7 +54,7 @@ public interface PcodeMachine<T> {
PcodeThread<T> getThread(String name, boolean createIfAbsent); PcodeThread<T> getThread(String name, boolean createIfAbsent);
/** /**
* Get the machine's memory state * Get the machine's shared (memory) state
* *
* <p> * <p>
* The returned state will may throw {@link IllegalArgumentException} if the client requests * The returned state will may throw {@link IllegalArgumentException} if the client requests
@ -62,7 +62,7 @@ public interface PcodeMachine<T> {
* *
* @return the memory state * @return the memory state
*/ */
PcodeExecutorState<T> getMemoryState(); PcodeExecutorState<T> getSharedState();
/** /**
* Compile the given SLEIGH code for execution by a thread of this machine * Compile the given SLEIGH code for execution by a thread of this machine

2
Ghidra/Debug/ProposedUtils/src/main/java/ghidra/pcode/emu/PcodeThread.java
View file

@ -248,7 +248,7 @@ public interface PcodeThread<T> {
* *
* <p> * <p>
* The memory part of this state is shared among all threads in the same machine. See * The memory part of this state is shared among all threads in the same machine. See
* {@link PcodeMachine#getMemoryState()}. * {@link PcodeMachine#getSharedState()}.
* *
*/ */
ThreadPcodeExecutorState<T> getState(); ThreadPcodeExecutorState<T> getState();

46
Ghidra/Debug/ProposedUtils/src/main/java/ghidra/pcode/emu/ThreadPcodeExecutorState.java
View file

@ -6,57 +6,61 @@ import ghidra.program.model.address.AddressSpace;
import ghidra.program.model.mem.MemBuffer; import ghidra.program.model.mem.MemBuffer;
public class ThreadPcodeExecutorState<T> implements PcodeExecutorState<T> { public class ThreadPcodeExecutorState<T> implements PcodeExecutorState<T> {
protected final PcodeExecutorState<T> memoryState; protected final PcodeExecutorState<T> sharedState;
protected final PcodeExecutorState<T> registerState; protected final PcodeExecutorState<T> localState;
public ThreadPcodeExecutorState(PcodeExecutorState<T> memoryState, public ThreadPcodeExecutorState(PcodeExecutorState<T> sharedState,
PcodeExecutorState<T> registerState) { PcodeExecutorState<T> localState) {
this.memoryState = memoryState; this.sharedState = sharedState;
this.registerState = registerState; this.localState = localState;
}
protected boolean isThreadLocalSpace(AddressSpace space) {
return space.isRegisterSpace() || space.isUniqueSpace();
} }
@Override @Override
public T longToOffset(AddressSpace space, long l) { public T longToOffset(AddressSpace space, long l) {
if (space.isRegisterSpace()) { if (isThreadLocalSpace(space)) {
return registerState.longToOffset(space, l); return localState.longToOffset(space, l);
} }
else { else {
return memoryState.longToOffset(space, l); return sharedState.longToOffset(space, l);
} }
} }
@Override @Override
public void setVar(AddressSpace space, T offset, int size, boolean truncateAddressableUnit, public void setVar(AddressSpace space, T offset, int size, boolean truncateAddressableUnit,
T val) { T val) {
if (space.isRegisterSpace()) { if (isThreadLocalSpace(space)) {
registerState.setVar(space, offset, size, truncateAddressableUnit, val); localState.setVar(space, offset, size, truncateAddressableUnit, val);
} }
else { else {
memoryState.setVar(space, offset, size, truncateAddressableUnit, val); sharedState.setVar(space, offset, size, truncateAddressableUnit, val);
} }
} }
@Override @Override
public T getVar(AddressSpace space, T offset, int size, boolean truncateAddressableUnit) { public T getVar(AddressSpace space, T offset, int size, boolean truncateAddressableUnit) {
if (space.isRegisterSpace()) { if (isThreadLocalSpace(space)) {
return registerState.getVar(space, offset, size, truncateAddressableUnit); return localState.getVar(space, offset, size, truncateAddressableUnit);
} }
else { else {
return memoryState.getVar(space, offset, size, truncateAddressableUnit); return sharedState.getVar(space, offset, size, truncateAddressableUnit);
} }
} }
@Override @Override
public MemBuffer getConcreteBuffer(Address address) { public MemBuffer getConcreteBuffer(Address address) {
assert !address.getAddressSpace().isRegisterSpace(); assert !isThreadLocalSpace(address.getAddressSpace());
return memoryState.getConcreteBuffer(address); return sharedState.getConcreteBuffer(address);
} }
public PcodeExecutorState<T> getMemoryState() { public PcodeExecutorState<T> getSharedState() {
return memoryState; return sharedState;
} }
public PcodeExecutorState<T> getRegisterState() { public PcodeExecutorState<T> getLocalState() {
return registerState; return localState;
} }
} }