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.javaindex 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 targetsArrayList<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 instructionprocessor.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 thruAddress 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 instructionreturn false;}- catch (UnknownContextException e) {- // something wrong with context- return false;- }// get rid of anything on target list that is in body of instructionIterator<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