Skip to content

Ghidra is a software reverse engineering (SRE) framework

GP-6496 refactor PsuedoDisassembler to use real Disassembler

emteere412bf98ae1ca
diff --git a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/app/util/PseudoDisassembler.java b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/app/util/PseudoDisassembler.java
index 45b09b5962..5f69c6ce43 100644
--- a/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/app/util/PseudoDisassembler.java
+++ b/Ghidra/Framework/SoftwareModeling/src/main/java/ghidra/app/util/PseudoDisassembler.java
@@ -19,6 +19,7 @@ import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Iterator;
+import ghidra.program.disassemble.Disassembler;
import ghidra.program.model.address.*;
import ghidra.program.model.data.DataType;
import ghidra.program.model.data.PointerDataType;
@@ -28,6 +29,7 @@ import ghidra.program.model.mem.*;
import ghidra.program.model.pcode.PcodeOp;
import ghidra.program.model.symbol.*;
import ghidra.util.Msg;
+import ghidra.util.task.TaskMonitor;
/**
* PseudoDisassembler.java
@@ -71,7 +73,7 @@ public class PseudoDisassembler {
private boolean respectExecuteFlag = false;
- private int lastCheckValidDisassemblyCount; // number of last instructions disassembled
+ private int lastCheckValidDisassemblyCount; // number of last instructions disassembled in checkValidSubroutine
/**
* Create a pseudo disassembler for the given program.
@@ -98,8 +100,11 @@ public class PseudoDisassembler {
}
/**
- * Get the last number of disassembled instructions
- * or the number of initial contiguous instruction if requireContiguous is true
+ * Get the last number of disassembled instructions,
+ * or the number of initial contiguous instruction if requireContiguous is true,
+ * after calls to in checkValidSubroutine() or isValidSubroutine()
+ *
+ * @return number of disassembled instructions
*/
public int getLastCheckValidInstructionCount() {
return lastCheckValidDisassemblyCount;
@@ -128,17 +133,15 @@ public class PseudoDisassembler {
UnknownInstructionException, UnknownContextException {
PseudoDisassemblerContext procContext = new PseudoDisassemblerContext(programContext);
-
- procContext.flowStart(addr);
return disassemble(addr, procContext, false);
}
/**
* Disassemble a single instruction. The program is not affected.
- * @param addr
- * @param disassemblerContext
- * @param isInDelaySlot
- * @return
+ * @param addr location to disassemble
+ * @param disassemblerContext context for disassembly
+ * @param isInDelaySlot true if instruction to be disassembled is in a delaySlot
+ * @return disassembled instruction
* @throws InsufficientBytesException
* @throws UnknownInstructionException
* @throws UnknownContextException
@@ -148,41 +151,18 @@ public class PseudoDisassembler {
throws InsufficientBytesException, UnknownInstructionException,
UnknownContextException {
- MemBuffer memBuffer = new DumbMemBufferImpl(memory, addr);
-
- // check that address is defined in memory
- try {
- memBuffer.getByte(0);
- }
- catch (Exception e) {
- return null;
- }
-
- InstructionPrototype prototype = null;
+ addr = setTargetContextForDisassembly(disassemblerContext, addr);
+ RegisterValue entryContext = getTargetStartContext(addr, disassemblerContext);
try {
- prototype = language.parse(memBuffer, disassemblerContext, isInDelaySlot);
+ // Only disassemble one instruction, and always re-disassemble
+ // in case context has changed.
+ Instruction instr = pseudoDisassemble(addr, entryContext, 1, true);
+ return (PseudoInstruction) instr;
}
catch (UnknownInstructionException unknownExc) {
return null;
}
-
- if (prototype == null) {
- return null;
- }
-
- PseudoInstruction instr;
- try {
- instr = new PseudoInstruction(program, addr, prototype, memBuffer, disassemblerContext);
- }
- catch (Exception e) {
- // this is here, if a prototype matches for some number of bytes, but
- // the actual instruction is longer than the number of bytes needed for matching
- // the prototype. And all the bytes for the instruction are not available.
- return null;
- }
-
- return instr;
}
/**
@@ -224,34 +204,21 @@ public class PseudoDisassembler {
PseudoDisassemblerContext disassemblerContext) throws InsufficientBytesException,
UnknownInstructionException, UnknownContextException {
- MemBuffer memBuffer = new ByteMemBufferImpl(addr, bytes, language.isBigEndian());
-
- // check that address is defined in memory
- try {
- memBuffer.getByte(0);
- }
- catch (Exception e) {
- return null;
- }
-
- InstructionPrototype prototype = null;
- disassemblerContext.flowStart(addr);
- prototype = language.parse(memBuffer, disassemblerContext, false);
+ addr = setTargetContextForDisassembly(disassemblerContext, addr);
+ RegisterValue targetContext = getTargetStartContext(addr, disassemblerContext);
+
+ pseudoDisassembler = Disassembler.getDisassembler(program, false, false, false,
+ TaskMonitor.DUMMY, msg -> {
+ // ignore log errors
+ });
- if (prototype == null) {
+ MemBuffer memBuffer = new ByteMemBufferImpl(addr, bytes, language.isBigEndian());
+ InstructionBlock instrBlock = pseudoDisassembler.pseudoDisassembleBlock(memBuffer, targetContext, 1);
+ if (instrBlock == null) {
return null;
}
- PseudoInstruction instr;
- try {
- instr = new PseudoInstruction(program, addr, prototype, memBuffer, disassemblerContext);
- }
- catch (AddressOverflowException e) {
- throw new InsufficientBytesException(
- "failed to build pseudo instruction at " + addr + ": " + e.getMessage());
- }
-
- return instr;
+ return (PseudoInstruction) instrBlock.getInstructionAt(addr);
}
/**
@@ -265,9 +232,7 @@ public class PseudoDisassembler {
* @return {@link PseudoData} that acts like Data
*/
public PseudoData applyDataType(Address addr, DataType dt) {
-
- Memory memory = program.getMemory();
-
+
MemBuffer memBuffer = new DumbMemBufferImpl(memory, addr);
// check that address is defined in memory
@@ -424,9 +389,10 @@ public class PseudoDisassembler {
AddressSet body = new AddressSet();
AddressSet instrStarts = new AddressSet();
- entryPoint = setTargetContextForDisassembly(procContext, entryPoint);
-
Address target = entryPoint;
+
+ entryPoint = setTargetContextForDisassembly(procContext, entryPoint);
+ RegisterValue entryContext = getTargetStartContext(entryPoint, procContext);
ArrayList<Address> targetList = new ArrayList<>(); // list of valid targets
ArrayList<Address> untriedTargetList = new ArrayList<>(); // list of valid targets
@@ -458,17 +424,15 @@ public class PseudoDisassembler {
return body;
}
- procContext.flowStart(entryPoint);
-
try {
// look some number of fallthroughs to see if this
// is a valid run of instructions.
for (int i = 0; target != null && i < maxInstr; i++) {
- PseudoInstruction instr;
- instr = disassemble(target, procContext, false);
+ Instruction instr;
+ instr = pseudoDisassemble(target, entryContext, maxInstructions, false);
- boolean doContinue = processor.process(instr);
+ boolean doContinue = processor.process((PseudoInstruction)instr);
if (!doContinue) {
return body;
}
@@ -482,7 +446,7 @@ public class PseudoDisassembler {
instrStarts.addRange(instr.getMinAddress(), instr.getMinAddress());
// check whether processor wants to follow flow on this instruction
- if (!processor.followFlows(instr)) {
+ if (!processor.followFlows((PseudoInstruction) instr)) {
target = getNextTarget(body, untriedTargetList);
continue;
}
@@ -530,13 +494,8 @@ public class PseudoDisassembler {
target = newTarget;
}
}
- catch (InsufficientBytesException e) {
- processor.process(null);
- }
catch (UnknownInstructionException e) {
- processor.process(null);
- }
- catch (UnknownContextException e) {
+ // bad instruction
processor.process(null);
}
@@ -662,6 +621,7 @@ public class PseudoDisassembler {
AddressSetView execSet = memory.getExecuteSet();
entryPoint = setTargetContextForDisassembly(procContext, entryPoint);
+ RegisterValue entryContext = getTargetStartContext(entryPoint, procContext);
Address target = entryPoint;
@@ -683,24 +643,12 @@ public class PseudoDisassembler {
return false;
}
- RepeatInstructionByteTracker repeatInstructionByteTracker =
- new RepeatInstructionByteTracker(MAX_REPEAT_BYTES_LIMIT, null);
-
- procContext.flowStart(entryPoint);
try {
// look some number of fallthroughs to see if this
// is a valid run of instructions.
for (int i = 0; target != null && i < maxInstructions; i++) {
- if (target.compareTo(procContext.getAddress()) < 0) {
- procContext.copyToFutureFlowState(target);
- procContext.flowEnd(procContext.getAddress());
- procContext.flowStart(target);
- }
- else {
- procContext.flowToAddress(target);
- }
- PseudoInstruction instr = disassemble(target, procContext, false);
+ Instruction instr = pseudoDisassemble(target, entryContext, maxInstructions, false);
if (instr == null) {
// if the target is in the external section, which is uninitialized, ignore it!
@@ -712,7 +660,6 @@ public class PseudoDisassembler {
}
targetList.remove(target);
target = getNextTarget(body, untriedTargetList);
- repeatInstructionByteTracker.reset();
continue;
}
@@ -723,7 +670,7 @@ public class PseudoDisassembler {
}
// check if we are getting into bad instruction runs
- if (repeatInstructionByteTracker.exceedsRepeatBytePattern(instr)) {
+ if (lastPseudoInstructionBlock.getInstructionConflict() != null) {
return false;
}
@@ -743,8 +690,7 @@ public class PseudoDisassembler {
catch (AddressOverflowException e) {
return false;
}
- procContext.flowToAddress(addr);
- PseudoInstruction dsInstr = disassemble(addr, procContext, true);
+ Instruction dsInstr = pseudoDisassemble(addr, entryContext, maxInstructions, false);
if (dsInstr == null) {
return false;
}
@@ -762,9 +708,8 @@ public class PseudoDisassembler {
// if instruction has fall thru
Address fallThru = null;
if (instr.hasFallthrough()) {
- if (checkNonReturning(program, flowType, instr)) {
+ if (checkNonReturning(flowType, instr)) {
target = getNextTarget(body, untriedTargetList);
- repeatInstructionByteTracker.reset();
continue;
}
newTarget = instr.getFallThrough();
@@ -793,7 +738,6 @@ public class PseudoDisassembler {
if (newTarget == null) {
newTarget = getNextTarget(body, untriedTargetList);
- repeatInstructionByteTracker.reset();
}
}
@@ -817,7 +761,6 @@ public class PseudoDisassembler {
if (func != null) {
didCallValidSubroutine = true;
newTarget = getNextTarget(body, untriedTargetList);
- repeatInstructionByteTracker.reset();
continue;
}
targetList.add(address);
@@ -865,18 +808,10 @@ public class PseudoDisassembler {
target = newTarget;
}
}
- catch (InsufficientBytesException e) {
- // can't parse not enough bytes
- return false;
- }
catch (UnknownInstructionException e) {
// bad instruction
return false;
}
- catch (UnknownContextException e) {
- // something wrong with context
- return false;
- }
// get rid of anything on target list that is in body of instruction
Iterator<Address> iter = targetList.iterator();
@@ -905,8 +840,71 @@ public class PseudoDisassembler {
return false;
}
+
+
+ private InstructionBlock lastPseudoInstructionBlock;
+ private Disassembler pseudoDisassembler;
+
+ /**
+ * Disassemble a block of instructions
+ *
+ * @param addr location to disassemble
+ * @param entryContext context at the start of the block
+ * @param maxInstr maximum number of instructions to disassemble
+ * @param forceRedisassembly force re-disassembly (don't use cached block)
+ *
+ * @return the instruction (PseudoInstruction)
+ * @throws UnknownInstructionException if instruction at location not disassemblable
+ */
+
+ private Instruction pseudoDisassemble(Address addr, RegisterValue entryContext, int maxInstr, boolean forceRedisassembly) throws UnknownInstructionException {
+ Instruction instr;
+ if (!forceRedisassembly && lastPseudoInstructionBlock != null) {
+ instr = lastPseudoInstructionBlock.getInstructionAt(addr);
+ if (instr != null) {
+ return instr;
+ }
+ InstructionError error = lastPseudoInstructionBlock.getInstructionConflict();
+ if (error != null && addr.equals(error.getInstructionAddress())) {
+ throw new UnknownInstructionException(error.getConflictMessage());
+ }
+ lastPseudoInstructionBlock = null;
+ }
+
+ if (pseudoDisassembler == null) {
+ pseudoDisassembler = Disassembler.getDisassembler(program, false, false, false,
+ TaskMonitor.DUMMY, msg -> {
+ // ignore log errors
+ });
+ pseudoDisassembler.setRepeatPatternLimit(MAX_REPEAT_BYTES_LIMIT);
+ } else if (forceRedisassembly) {
+ pseudoDisassembler.resetDisassemblerContext();
+ }
+
+ lastPseudoInstructionBlock =
+ pseudoDisassembler.pseudoDisassembleBlock(addr, entryContext, maxInstr);
+ if (lastPseudoInstructionBlock != null) {
+ InstructionError error = lastPseudoInstructionBlock.getInstructionConflict(); // Look for zero-byte run first
+ if (error != null &&
+ error.getConflictMessage().startsWith("Maximum run of Zero-Byte")) {
+ throw new UnknownInstructionException(error.getConflictMessage()); // Don't return any of the zero-byte instructions
+ }
+ instr = lastPseudoInstructionBlock.getInstructionAt(addr);
+ if (instr != null) {
+ return instr;
+ }
+ if (error != null && addr.equals(error.getInstructionAddress())) {
+ throw new UnknownInstructionException(error.getConflictMessage());
+ }
+ if (program.getMemory().isExternalBlockAddress(addr)) {
+ throw new UnknownInstructionException(
+ "Unable to disassemble EXTERNAL block location: " + addr);
+ }
+ }
+ throw new UnknownInstructionException("Invalid instruction address (improperly aligned)");
+ }
- private boolean checkNonReturning(Program program, FlowType flowType, PseudoInstruction instr) {
+ private boolean checkNonReturning(FlowType flowType, Instruction instr) {
if (!flowType.isCall()) {
return false;
}
@@ -1059,6 +1057,25 @@ public class PseudoDisassembler {
}
return null;
}
+
+ /**
+ * Get the context register setup with the starting context for target
+ *
+ * @param target address to get context register value
+ * @param procContext disassembly context
+ * @return context register value set with current context for target
+ */
+ private RegisterValue getTargetStartContext(Address target,
+ PseudoDisassemblerContext procContext) {
+ procContext.flowStart(target);
+
+ RegisterValue entryContext = null;
+ Register baseContextRegister = procContext.getBaseContextRegister();
+ if (baseContextRegister != null) {
+ entryContext = procContext.getRegisterValue(baseContextRegister);
+ }
+ return entryContext;
+ }
/**
* @return true if program has uses the low bit of an address to change Instruction Set mode