diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/ArrayMethods.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/ArrayMethods.java index 2cdf49cffb..228587990e 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/ArrayMethods.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/ArrayMethods.java @@ -18,7 +18,8 @@ package ghidra.app.util.pcodeInject; import ghidra.javaclass.format.DescriptorDecoder; import ghidra.javaclass.format.JavaClassConstants; import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava; -import ghidra.program.model.data.*; +import ghidra.program.model.data.DataType; +import ghidra.program.model.data.DataTypeManager; /** * @@ -43,6 +44,7 @@ public class ArrayMethods { private ArrayMethods(){ throw new AssertionError(); } + /** * Emits pcode for the multianewarray op, which is used to create new multi-dimensional arrays * It is modeled with two black-box pcode ops: multianewarrayOp and multianewarrayProcessAdditionalDimensionsOp. @@ -53,23 +55,22 @@ public class ArrayMethods { * are array dimensions. Additional array dimensions are consumed from the stack with calls to * multianewarrayProcessAdditionalDimensionsOp, which takes a reference returned by multianewarrayOp as its first argument * and a dimension as its second argument. + * @param pCode is the pcode accumulator * @param constantPoolIndex * @param constantPool * @param dimensions - * @return */ - public static String getPcodeForMultiANewArray(int constantPoolIndex, AbstractConstantPoolInfoJava[] constantPool, + public static void getPcodeForMultiANewArray(PcodeOpEmitter pCode, int constantPoolIndex, + AbstractConstantPoolInfoJava[] constantPool, int dimensions) { - StringBuilder pCode = new StringBuilder(); - - //pop all of the dimensions off the stack for (int i = dimensions; i >= 1; --i){ String iAsString = Integer.toString(i); - PcodeTextEmitter.emitPopCat1Value(pCode, DIMENSION + iAsString); + pCode.emitPopCat1Value(DIMENSION + iAsString); } - PcodeTextEmitter.emitAssignVarnodeFromPcodeOpCall(pCode, CLASS_NAME, 4, ConstantPoolJava.CPOOL_OP, "0", Integer.toString(constantPoolIndex),ConstantPoolJava.CPOOL_MULTIANEWARRAY); + pCode.emitAssignVarnodeFromPcodeOpCall(CLASS_NAME, 4, ConstantPoolJava.CPOOL_OP, "0", + Integer.toString(constantPoolIndex), ConstantPoolJava.CPOOL_MULTIANEWARRAY); //emit the call to multianewarrayOp @@ -92,18 +93,18 @@ public class ArrayMethods { multianewarrayOpArgs[i] = DIMENSION + Integer.toString(i); } } - PcodeTextEmitter.emitAssignVarnodeFromPcodeOpCall(pCode, ARRAY_REF, 4, MULTIANEWARRAY, CLASS_NAME,"dim1","dim2"); + pCode.emitAssignVarnodeFromPcodeOpCall(ARRAY_REF, 4, MULTIANEWARRAY, CLASS_NAME, "dim1", + "dim2"); //consume any additional arguments for (int i = MAX_PCODE_OP_ARGS; i <= dimensions; ++i){ String[] args = {ARRAY_REF, DIMENSION + Integer.toString(i)}; - PcodeTextEmitter.emitVoidPcodeOpCall(pCode, PROCESS_ADDITIONAL_DIMENSIONS, args); + pCode.emitVoidPcodeOpCall(PROCESS_ADDITIONAL_DIMENSIONS, args); } - PcodeTextEmitter.emitPushCat1Value(pCode, ARRAY_REF); - return pCode.toString(); + pCode.emitPushCat1Value(ARRAY_REF); } /** * The array type codes can be found in the JVM documentation for the diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectGetField.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectGetField.java index dcce0dca23..ef9c0d2ad2 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectGetField.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectGetField.java @@ -19,20 +19,26 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage; import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava; import ghidra.program.model.lang.InjectContext; import ghidra.program.model.listing.Program; +import ghidra.program.model.pcode.PcodeOp; public class InjectGetField extends InjectPayloadJava { - public InjectGetField(String sourceName, SleighLanguage language) { - super(sourceName, language); + public InjectGetField(String sourceName, SleighLanguage language, long uniqBase) { + super(sourceName, language, uniqBase); } @Override - public String getPcodeText(Program program, String context) { - InjectContext injectContext = getInjectContext(program, context); + public String getName() { + return PcodeInjectLibraryJava.GETFIELD; + } + + @Override + public PcodeOp[] getPcode(Program program, InjectContext con) { AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); - int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset(); - String pcodeText = ReferenceMethods.getPcodeForGetField(constantPoolIndex, constantPool); - return pcodeText; + int constantPoolIndex = (int) con.inputlist.get(0).getOffset(); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase); + ReferenceMethods.getPcodeForGetField(pCode, constantPoolIndex, constantPool); + return pCode.getPcodeOps(); } } diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectGetStatic.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectGetStatic.java index 5c5a3f62ce..3047cd4471 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectGetStatic.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectGetStatic.java @@ -19,20 +19,25 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage; import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava; import ghidra.program.model.lang.InjectContext; import ghidra.program.model.listing.Program; +import ghidra.program.model.pcode.PcodeOp; public class InjectGetStatic extends InjectPayloadJava { - public InjectGetStatic(String sourceName, SleighLanguage language) { - super(sourceName, language); + public InjectGetStatic(String sourceName, SleighLanguage language, long uniqBase) { + super(sourceName, language, uniqBase); } @Override - public String getPcodeText(Program program, String context) { - InjectContext injectContext = getInjectContext(program, context); - AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); - int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset(); - String pcodeText = ReferenceMethods.getPcodeForGetStatic(constantPoolIndex, constantPool); - return pcodeText; + public String getName() { + return PcodeInjectLibraryJava.GETSTATIC; } + @Override + public PcodeOp[] getPcode(Program program, InjectContext con) { + AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); + int constantPoolIndex = (int) con.inputlist.get(0).getOffset(); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase); + ReferenceMethods.getPcodeForGetStatic(pCode, constantPoolIndex, constantPool); + return pCode.getPcodeOps(); + } } diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeDynamic.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeDynamic.java index 784d614f72..7120229539 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeDynamic.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeDynamic.java @@ -19,20 +19,25 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage; import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava; import ghidra.program.model.lang.InjectContext; import ghidra.program.model.listing.Program; +import ghidra.program.model.pcode.PcodeOp; public class InjectInvokeDynamic extends InjectPayloadJava { - public InjectInvokeDynamic(String sourceName, SleighLanguage language) { - super(sourceName, language); + public InjectInvokeDynamic(String sourceName, SleighLanguage language, long uniqBase) { + super(sourceName, language, uniqBase); } @Override - public String getPcodeText(Program program, String context) { - InjectContext injectContext = getInjectContext(program, context); - AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); - int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset(); - String pcodeText = InvokeMethods.getPcodeForInvokeDynamic(constantPoolIndex, constantPool); - return pcodeText; + public String getName() { + return PcodeInjectLibraryJava.INVOKE_DYNAMIC; } + @Override + public PcodeOp[] getPcode(Program program, InjectContext con) { + AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); + int constantPoolIndex = (int) con.inputlist.get(0).getOffset(); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase); + InvokeMethods.getPcodeForInvokeDynamic(pCode, constantPoolIndex, constantPool); + return pCode.getPcodeOps(); + } } diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeInterface.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeInterface.java index 630f047612..4f37fa80ca 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeInterface.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeInterface.java @@ -19,20 +19,26 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage; import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava; import ghidra.program.model.lang.InjectContext; import ghidra.program.model.listing.Program; +import ghidra.program.model.pcode.PcodeOp; public class InjectInvokeInterface extends InjectPayloadJava { - public InjectInvokeInterface(String sourceName, SleighLanguage language) { - super(sourceName, language); + public InjectInvokeInterface(String sourceName, SleighLanguage language, long uniqBase) { + super(sourceName, language, uniqBase); } @Override - public String getPcodeText(Program program, String context) { - InjectContext injectContext = getInjectContext(program, context); - AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); - int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset(); - String pcodeText = InvokeMethods.getPcodeForInvoke(constantPoolIndex, constantPool, JavaInvocationType.INVOKE_INTERFACE); - return pcodeText; + public String getName() { + return PcodeInjectLibraryJava.INVOKE_INTERFACE; } + @Override + public PcodeOp[] getPcode(Program program, InjectContext con) { + AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); + int constantPoolIndex = (int) con.inputlist.get(0).getOffset(); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase); + InvokeMethods.getPcodeForInvoke(pCode, constantPoolIndex, constantPool, + JavaInvocationType.INVOKE_INTERFACE); + return pCode.getPcodeOps(); + } } diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeSpecial.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeSpecial.java index 1dac485dc7..6ab5b4a49d 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeSpecial.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeSpecial.java @@ -19,20 +19,26 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage; import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava; import ghidra.program.model.lang.InjectContext; import ghidra.program.model.listing.Program; +import ghidra.program.model.pcode.PcodeOp; public class InjectInvokeSpecial extends InjectPayloadJava { - public InjectInvokeSpecial(String sourceName, SleighLanguage language) { - super(sourceName, language); + public InjectInvokeSpecial(String sourceName, SleighLanguage language, long uniqBase) { + super(sourceName, language, uniqBase); } @Override - public String getPcodeText(Program program, String context) { - InjectContext injectContext = getInjectContext(program, context); - AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); - int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset(); - String pcodeText = InvokeMethods.getPcodeForInvoke(constantPoolIndex, constantPool, JavaInvocationType.INVOKE_SPECIAL); - return pcodeText; + public String getName() { + return PcodeInjectLibraryJava.INVOKE_SPECIAL; } + @Override + public PcodeOp[] getPcode(Program program, InjectContext con) { + AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); + int constantPoolIndex = (int) con.inputlist.get(0).getOffset(); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase); + InvokeMethods.getPcodeForInvoke(pCode, constantPoolIndex, constantPool, + JavaInvocationType.INVOKE_SPECIAL); + return pCode.getPcodeOps(); + } } diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeStatic.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeStatic.java index 4b96198afd..1e94e94ade 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeStatic.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeStatic.java @@ -19,20 +19,26 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage; import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava; import ghidra.program.model.lang.InjectContext; import ghidra.program.model.listing.Program; +import ghidra.program.model.pcode.PcodeOp; public class InjectInvokeStatic extends InjectPayloadJava { - public InjectInvokeStatic(String sourceName, SleighLanguage language) { - super(sourceName, language); + public InjectInvokeStatic(String sourceName, SleighLanguage language, long uniqBase) { + super(sourceName, language, uniqBase); } @Override - public String getPcodeText(Program program, String context) { - InjectContext injectContext = getInjectContext(program, context); - AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); - int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset(); - String pcodeText = InvokeMethods.getPcodeForInvoke(constantPoolIndex, constantPool, JavaInvocationType.INVOKE_STATIC); - return pcodeText; + public String getName() { + return PcodeInjectLibraryJava.INVOKE_STATIC; } + @Override + public PcodeOp[] getPcode(Program program, InjectContext con) { + AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); + int constantPoolIndex = (int) con.inputlist.get(0).getOffset(); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase); + InvokeMethods.getPcodeForInvoke(pCode, constantPoolIndex, constantPool, + JavaInvocationType.INVOKE_STATIC); + return pCode.getPcodeOps(); + } } diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeVirtual.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeVirtual.java index 878a0dbd4d..c4d9058312 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeVirtual.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectInvokeVirtual.java @@ -19,20 +19,26 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage; import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava; import ghidra.program.model.lang.InjectContext; import ghidra.program.model.listing.Program; +import ghidra.program.model.pcode.PcodeOp; public class InjectInvokeVirtual extends InjectPayloadJava { - public InjectInvokeVirtual(String sourceName, SleighLanguage language) { - super(sourceName, language); + public InjectInvokeVirtual(String sourceName, SleighLanguage language, long uniqBase) { + super(sourceName, language, uniqBase); } @Override - public String getPcodeText(Program program, String context) { - InjectContext injectContext = getInjectContext(program, context); - AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); - int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset(); - String pcodeText = InvokeMethods.getPcodeForInvoke(constantPoolIndex, constantPool, JavaInvocationType.INVOKE_VIRTUAL); - return pcodeText; + public String getName() { + return PcodeInjectLibraryJava.INVOKE_VIRTUAL; } + @Override + public PcodeOp[] getPcode(Program program, InjectContext con) { + AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); + int constantPoolIndex = (int) con.inputlist.get(0).getOffset(); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase); + InvokeMethods.getPcodeForInvoke(pCode, constantPoolIndex, constantPool, + JavaInvocationType.INVOKE_VIRTUAL); + return pCode.getPcodeOps(); + } } diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectLdc.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectLdc.java index c844501f5d..1bae3ba83a 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectLdc.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectLdc.java @@ -19,20 +19,25 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage; import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava; import ghidra.program.model.lang.InjectContext; import ghidra.program.model.listing.Program; +import ghidra.program.model.pcode.PcodeOp; public class InjectLdc extends InjectPayloadJava { - public InjectLdc(String sourceName, SleighLanguage language) { - super(sourceName, language); + public InjectLdc(String sourceName, SleighLanguage language, long uniqBase) { + super(sourceName, language, uniqBase); } @Override - public String getPcodeText(Program program, String context) { - InjectContext injectContext = getInjectContext(program, context); - AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); - int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset(); - String pcodeText = LdcMethods.getPcodeForLdc(constantPoolIndex, constantPool); - return pcodeText; + public String getName() { + return PcodeInjectLibraryJava.LDC; } + @Override + public PcodeOp[] getPcode(Program program, InjectContext con) { + AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); + int constantPoolIndex = (int) con.inputlist.get(0).getOffset(); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase); + LdcMethods.getPcodeForLdc(pCode, constantPoolIndex, constantPool); + return pCode.getPcodeOps(); + } } diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectMultiANewArray.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectMultiANewArray.java index 33b3e5f3d3..506ffe41e3 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectMultiANewArray.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectMultiANewArray.java @@ -19,21 +19,26 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage; import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava; import ghidra.program.model.lang.InjectContext; import ghidra.program.model.listing.Program; +import ghidra.program.model.pcode.PcodeOp; public class InjectMultiANewArray extends InjectPayloadJava { - public InjectMultiANewArray(String sourceName, SleighLanguage language) { - super(sourceName, language); + public InjectMultiANewArray(String sourceName, SleighLanguage language, long uniqBase) { + super(sourceName, language, uniqBase); } @Override - public String getPcodeText(Program program, String context) { - InjectContext injectContext = getInjectContext(program, context); - AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); - int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset(); - int dimensions = (int) injectContext.inputlist.get(1).getOffset(); - String pcodeText = ArrayMethods.getPcodeForMultiANewArray(constantPoolIndex, constantPool, dimensions); - return pcodeText; + public String getName() { + return PcodeInjectLibraryJava.MULTIANEWARRAY; } + @Override + public PcodeOp[] getPcode(Program program, InjectContext con) { + AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); + int constantPoolIndex = (int) con.inputlist.get(0).getOffset(); + int dimensions = (int) con.inputlist.get(1).getOffset(); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase); + ArrayMethods.getPcodeForMultiANewArray(pCode, constantPoolIndex, constantPool, dimensions); + return pCode.getPcodeOps(); + } } diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPayloadJava.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPayloadJava.java index be2a01798c..d057962b08 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPayloadJava.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPayloadJava.java @@ -17,25 +17,12 @@ package ghidra.app.util.pcodeInject; import java.io.IOException; -import javax.xml.parsers.SAXParser; -import javax.xml.parsers.SAXParserFactory; - -import org.xml.sax.*; - -import ghidra.app.plugin.processors.sleigh.SleighException; +import ghidra.app.plugin.processors.sleigh.PcodeEmit; import ghidra.app.plugin.processors.sleigh.SleighLanguage; -import ghidra.app.plugin.processors.sleigh.template.ConstructTpl; -import ghidra.app.plugin.processors.sleigh.template.OpTpl; import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava; -import ghidra.pcodeCPort.slgh_compile.PcodeParser; -import ghidra.program.model.lang.*; +import ghidra.program.model.lang.InjectContext; +import ghidra.program.model.lang.InjectPayload; import ghidra.program.model.listing.Program; -import ghidra.program.model.pcode.PcodeXMLException; -import ghidra.sleigh.grammar.Location; -import ghidra.util.Msg; -import ghidra.util.xml.XmlUtilities; -import ghidra.xml.XmlPullParser; -import ghidra.xml.XmlPullParserFactory; /** * Subclasses of this class are used to generate pcode to inject for modeling @@ -43,51 +30,18 @@ import ghidra.xml.XmlPullParserFactory; * */ -public abstract class InjectPayloadJava extends InjectPayloadCallother { - private SleighLanguage language; - private SAXParser saxParser; +public abstract class InjectPayloadJava implements InjectPayload { + protected SleighLanguage language; + protected long uniqueBase; + private String sourceName; - /** - * Subclasses use this method to generate pcode text for a particular java - * bytecode op requiring pcode injection. - * - * @param program The program containing the op. - * @param context The context associated with the op. - * @return - */ - abstract String getPcodeText(Program program, String context); - - public InjectPayloadJava(String sourceName, SleighLanguage language) { - super(sourceName); + public InjectPayloadJava(String sourceName, SleighLanguage language, long uniqBase) { this.language = language; - try { - saxParser = getSAXParser(); - } - catch (PcodeXMLException e) { - // TODO Auto-generated catch block - e.printStackTrace(); - } + this.sourceName = sourceName; + this.uniqueBase = uniqBase; } - SleighLanguage getLanguage() { - return language; - } - - InjectContext getInjectContext(Program program, String context) { - InjectContext injectContext = new InjectContext(); - injectContext.language = language; - try { - injectContext.restoreXml(saxParser, context, program.getAddressFactory()); - saxParser.reset(); - } - catch (PcodeXMLException e1) { - Msg.info(this, e1.getMessage()); - e1.printStackTrace(); - } - return injectContext; - } - - AbstractConstantPoolInfoJava[] getConstantPool(Program program) { + protected static AbstractConstantPoolInfoJava[] getConstantPool(Program program) { ConstantPoolJava cPool = null; try { cPool = new ConstantPoolJava(program); @@ -99,87 +53,38 @@ public abstract class InjectPayloadJava extends InjectPayloadCallother { return cPool.getConstantPool(); } - //from DecompileCallback.java - private static SAXParser getSAXParser() throws PcodeXMLException { - try { - SAXParserFactory saxParserFactory = XmlUtilities.createSecureSAXParserFactory(false); - saxParserFactory.setFeature("http://xml.org/sax/features/namespaces", false); - saxParserFactory.setFeature("http://xml.org/sax/features/validation", false); - return saxParserFactory.newSAXParser(); - } - catch (Exception e) { - Msg.error(PcodeInjectLibraryJava.class, e.getMessage()); - throw new PcodeXMLException("Failed to instantiate XML parser", e); - } + @Override + public int getType() { + return InjectPayload.CALLOTHERFIXUP_TYPE; } - /** - * This method is used to generate and compile pcode for a given - * callotherfixup. - * - * @param parser Used to parse pcode. - * @param program The program containing the callotherfixup - * @param context The context of the callotherfixup. - * @return An array of OpTpl (for passing to - * PcodeInjectLibrary.adjustUniqueBase) - */ - public OpTpl[] getPcode(PcodeParser parser, Program program, String context) { - String sourceName = getSource(); - Location loc = new Location(sourceName, 1); + @Override + public String getSource() { + return sourceName; + } - InjectParameter[] input = getInput(); - for (InjectParameter element : input) { - parser.addOperand(loc, element.getName(), element.getIndex()); - } - InjectParameter[] output = getOutput(); - for (InjectParameter element : output) { - parser.addOperand(loc, element.getName(), element.getIndex()); - } + @Override + public int getParamShift() { + return 0; + } - String pcodeText = getPcodeText(program, context); - String constructTplXml = - PcodeParser.stringifyTemplate(parser.compilePcode(pcodeText, sourceName, 1)); - if (constructTplXml == null) { - throw new SleighException("pcode compile failed " + sourceName); - } - final SAXParseException[] exception = new SAXParseException[1]; - XmlPullParser xmlParser = null; - try { - xmlParser = - XmlPullParserFactory.create(constructTplXml, sourceName, new ErrorHandler() { - @Override - public void warning(SAXParseException e) throws SAXException { - Msg.warn(this, e.getMessage()); - } + @Override + public void inject(InjectContext context, PcodeEmit emit) { + // Not used + } - @Override - public void fatalError(SAXParseException e) throws SAXException { - exception[0] = e; - } + @Override + public boolean isFallThru() { + return true; + } - @Override - public void error(SAXParseException e) throws SAXException { - exception[0] = e; - } - }, false); - } - catch (SAXException e) { - e.printStackTrace(); - } + @Override + public InjectParameter[] getInput() { + return null; + } - ConstructTpl constructTpl = new ConstructTpl(); - try { - constructTpl.restoreXml(xmlParser, language.getAddressFactory()); - } - catch (UnknownInstructionException e) { - e.printStackTrace(); - } - if (exception[0] != null) { - throw new SleighException("pcode compiler returned invalid xml " + sourceName, - exception[0]); - } - OpTpl[] opTemplates = constructTpl.getOpVec(); - setTemplate(constructTpl); - return opTemplates; + @Override + public InjectParameter[] getOutput() { + return null; } } diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPayloadJavaParameters.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPayloadJavaParameters.java index b3c7725763..a34dfe95c6 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPayloadJavaParameters.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPayloadJavaParameters.java @@ -20,6 +20,7 @@ import java.util.ArrayList; import java.util.List; import ghidra.app.plugin.processors.sleigh.PcodeEmit; +import ghidra.app.plugin.processors.sleigh.SleighLanguage; import ghidra.javaclass.format.*; import ghidra.javaclass.format.constantpool.ConstantPoolUtf8Info; import ghidra.program.model.address.Address; @@ -35,10 +36,36 @@ public class InjectPayloadJavaParameters implements InjectPayload { private InjectParameter[] noParams; private boolean analysisStateRecoverable; + private AddressSpace constantSpace; + private int paramSpaceID; + private int lvaID; + private Varnode temp4; + private Varnode temp8; + private Varnode zero; + private Varnode four; + private Varnode eight; + private Varnode LVA; - public InjectPayloadJavaParameters() { + public InjectPayloadJavaParameters(SleighLanguage language, long uniqBase) { noParams = new InjectParameter[0]; analysisStateRecoverable = true; + constantSpace = language.getAddressFactory().getConstantSpace(); + AddressSpace uniqueSpace = language.getAddressFactory().getUniqueSpace(); + Address temp4Address = uniqueSpace.getAddress(uniqBase); + Address temp8Address = uniqueSpace.getAddress(uniqBase + 0x10); + AddressSpace paramSpace = language.getAddressFactory().getAddressSpace("parameterSpace"); + paramSpaceID = paramSpace.getSpaceID(); + AddressSpace lva = language.getAddressFactory().getAddressSpace("localVariableArray"); + lvaID = lva.getSpaceID(); + //create temp storage locations + temp4 = new Varnode(temp4Address, 4); + temp8 = new Varnode(temp8Address, 8); + //create varnodes for incrementing pointer by 4 or 8 bytes + zero = new Varnode(constantSpace.getAddress(0), 4); + four = new Varnode(constantSpace.getAddress(4), 4); + eight = new Varnode(constantSpace.getAddress(8), 4); + Address LVAregAddress = language.getRegister("LVA").getAddress(); + LVA = new Varnode(LVAregAddress, 4); } @Override @@ -110,34 +137,15 @@ public class InjectPayloadJavaParameters implements InjectPayload { return new PcodeOp[0]; } - AddressSpace paramSpace = program.getAddressFactory().getAddressSpace("parameterSpace"); - int paramSpaceID = paramSpace.getSpaceID(); - AddressSpace lva = program.getAddressFactory().getAddressSpace("localVariableArray"); - int lvaID = lva.getSpaceID(); - AddressSpace constant = program.getAddressFactory().getConstantSpace(); - PcodeOp[] resOps = new PcodeOp[1 + 3*numOps]; int seqNum = 0; - //create varnodes for incrementing pointer by 4 or 8 bytes - Varnode zero = new Varnode(constant.getAddress(0),4); - Varnode four = new Varnode(constant.getAddress(4),4); - Varnode eight = new Varnode(constant.getAddress(8),4); - Address LVAregAddress = program.getRegister("LVA").getAddress(); - Varnode LVA = new Varnode(LVAregAddress,4); - //initialize LVA to contain 0 PcodeOp copy = new PcodeOp(con.baseAddr,seqNum, PcodeOp.COPY); copy.setInput(zero, 0); copy.setOutput(LVA); resOps[seqNum++] = copy; - //create temp storage locations - Address temp4Address = analysisState.getNextUniqueAddress(); - Varnode temp4 = new Varnode(temp4Address,4); - Address temp8Address = analysisState.getNextUniqueAddress(); - Varnode temp8 = new Varnode(temp8Address,8); - Varnode tempLocation = null; Varnode increment = null; @@ -152,13 +160,13 @@ public class InjectPayloadJavaParameters implements InjectPayload { } //copy value from parameterSpace to temporary PcodeOp load = new PcodeOp(con.baseAddr, seqNum, PcodeOp.LOAD); - load.setInput(new Varnode(constant.getAddress(paramSpaceID),4), 0); + load.setInput(new Varnode(constantSpace.getAddress(paramSpaceID), 4), 0); load.setInput(LVA, 1); load.setOutput(tempLocation); resOps[seqNum++] = load; //copy temporary to LVA PcodeOp store = new PcodeOp(con.baseAddr, seqNum, PcodeOp.STORE); - store.setInput(new Varnode(constant.getAddress(lvaID),4), 0); + store.setInput(new Varnode(constantSpace.getAddress(lvaID), 4), 0); store.setInput(LVA,1); store.setInput(tempLocation, 2); resOps[seqNum++] = store; diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPutField.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPutField.java index 076c6fd9ee..7c44be1e7d 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPutField.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPutField.java @@ -19,20 +19,25 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage; import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava; import ghidra.program.model.lang.InjectContext; import ghidra.program.model.listing.Program; +import ghidra.program.model.pcode.PcodeOp; public class InjectPutField extends InjectPayloadJava { - public InjectPutField(String sourceName, SleighLanguage language) { - super(sourceName, language); + public InjectPutField(String sourceName, SleighLanguage language, long uniqBase) { + super(sourceName, language, uniqBase); } @Override - public String getPcodeText(Program program, String context) { - InjectContext injectContext = getInjectContext(program, context); - AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); - int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset(); - String pcodeText = ReferenceMethods.getPcodeForPutField(constantPoolIndex, constantPool); - return pcodeText; + public String getName() { + return PcodeInjectLibraryJava.PUTFIELD; } + @Override + public PcodeOp[] getPcode(Program program, InjectContext con) { + AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); + int constantPoolIndex = (int) con.inputlist.get(0).getOffset(); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase); + ReferenceMethods.getPcodeForPutField(pCode, constantPoolIndex, constantPool); + return pCode.getPcodeOps(); + } } diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPutStatic.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPutStatic.java index 67069452d5..45616a4158 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPutStatic.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/InjectPutStatic.java @@ -19,20 +19,25 @@ import ghidra.app.plugin.processors.sleigh.SleighLanguage; import ghidra.javaclass.format.constantpool.AbstractConstantPoolInfoJava; import ghidra.program.model.lang.InjectContext; import ghidra.program.model.listing.Program; +import ghidra.program.model.pcode.PcodeOp; public class InjectPutStatic extends InjectPayloadJava { - public InjectPutStatic(String sourceName, SleighLanguage language) { - super(sourceName, language); + public InjectPutStatic(String sourceName, SleighLanguage language, long uniqBase) { + super(sourceName, language, uniqBase); } @Override - public String getPcodeText(Program program, String context) { - InjectContext injectContext = getInjectContext(program, context); - AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); - int constantPoolIndex = (int) injectContext.inputlist.get(0).getOffset(); - String pcodeText = ReferenceMethods.getPcodeForPutStatic(constantPoolIndex, constantPool); - return pcodeText; + public String getName() { + return PcodeInjectLibraryJava.PUTSTATIC; } + @Override + public PcodeOp[] getPcode(Program program, InjectContext con) { + AbstractConstantPoolInfoJava[] constantPool = getConstantPool(program); + int constantPoolIndex = (int) con.inputlist.get(0).getOffset(); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, con.baseAddr, uniqueBase); + ReferenceMethods.getPcodeForPutStatic(pCode, constantPoolIndex, constantPool); + return pCode.getPcodeOps(); + } } diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/PcodeInjectLibraryJava.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/PcodeInjectLibraryJava.java index 90b7945452..7d50e96126 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/PcodeInjectLibraryJava.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/PcodeInjectLibraryJava.java @@ -16,14 +16,10 @@ package ghidra.app.util.pcodeInject; import java.io.IOException; -import java.util.HashSet; -import java.util.Set; - -import org.jdom.JDOMException; +import java.util.HashMap; +import java.util.Map; import ghidra.app.plugin.processors.sleigh.SleighLanguage; -import ghidra.app.plugin.processors.sleigh.template.OpTpl; -import ghidra.pcodeCPort.slgh_compile.PcodeParser; import ghidra.program.model.lang.*; import ghidra.program.model.listing.Program; @@ -114,92 +110,45 @@ public class PcodeInjectLibraryJava extends PcodeInjectLibrary { public static final String PUTFIELD = "putFieldCallOther"; public static final String PUTSTATIC = "putStaticCallOther"; + public static final String SOURCENAME = "javainternal"; //size of one stack element in the jvm (in bytes) public static final int REFERENCE_SIZE = 4; - private SleighLanguage language; - private Set implementedOps; - private PcodeParser parser; + private Map implementedOps; private InjectPayloadJavaParameters paramPayload; public PcodeInjectLibraryJava(SleighLanguage l) { super(l); - language = l; - implementedOps = new HashSet<>(); - implementedOps.add(GETFIELD); - implementedOps.add(GETSTATIC); - implementedOps.add(INVOKE_DYNAMIC); - implementedOps.add(INVOKE_INTERFACE); - implementedOps.add(INVOKE_SPECIAL); - implementedOps.add(INVOKE_STATIC); - implementedOps.add(INVOKE_VIRTUAL); - implementedOps.add(LDC); - implementedOps.add(LDC2_W); - implementedOps.add(LDC_W); - implementedOps.add(MULTIANEWARRAY); - implementedOps.add(PUTFIELD); - implementedOps.add(PUTSTATIC); + long offset = l.getUniqueBase(); + implementedOps = new HashMap<>(); + implementedOps.put(GETFIELD, new InjectGetField(SOURCENAME, l, offset)); + offset += 0x100; + implementedOps.put(GETSTATIC, new InjectGetStatic(SOURCENAME, l, offset)); + offset += 0x100; + implementedOps.put(INVOKE_DYNAMIC, new InjectInvokeDynamic(SOURCENAME, l, offset)); + offset += 0x100; + implementedOps.put(INVOKE_INTERFACE, new InjectInvokeInterface(SOURCENAME, l, offset)); + offset += 0x100; + implementedOps.put(INVOKE_SPECIAL, new InjectInvokeSpecial(SOURCENAME, l, offset)); + offset += 0x100; + implementedOps.put(INVOKE_STATIC, new InjectInvokeStatic(SOURCENAME, l, offset)); + offset += 0x100; + implementedOps.put(INVOKE_VIRTUAL, new InjectInvokeVirtual(SOURCENAME, l, offset)); + offset += 0x100; + InjectPayloadJava ldcInject = new InjectLdc(SOURCENAME, l, offset); + offset += 0x100; + implementedOps.put(LDC, ldcInject); + implementedOps.put(LDC2_W, ldcInject); + implementedOps.put(LDC_W, ldcInject); + implementedOps.put(MULTIANEWARRAY, new InjectMultiANewArray(SOURCENAME, l, offset)); + offset += 0x100; + implementedOps.put(PUTFIELD, new InjectPutField(SOURCENAME, l, offset)); + offset += 0x100; + implementedOps.put(PUTSTATIC, new InjectPutStatic(SOURCENAME, l, offset)); + offset += 0x100; - String translateSpec = language.buildTranslatorTag(language.getAddressFactory(), - getUniqueBase(), language.getSymbolTable()); - - paramPayload = null; - parser = null; - try { - parser = new PcodeParser(translateSpec); - } - catch (JDOMException e1) { - e1.printStackTrace(); - } - } - - @Override - protected InjectPayloadSleigh allocateInject(String sourceName, String name, int tp) { - InjectPayloadJava payload = null; - if (tp != InjectPayload.CALLOTHERFIXUP_TYPE) { - return super.allocateInject(sourceName, name, tp); - } - switch (name) { - case GETFIELD: - payload = new InjectGetField(sourceName, language); - break; - case GETSTATIC: - payload = new InjectGetStatic(sourceName, language); - break; - case INVOKE_DYNAMIC: - payload = new InjectInvokeDynamic(sourceName, language); - break; - case INVOKE_INTERFACE: - payload = new InjectInvokeInterface(sourceName, language); - break; - case INVOKE_SPECIAL: - payload = new InjectInvokeSpecial(sourceName, language); - break; - case INVOKE_STATIC: - payload = new InjectInvokeStatic(sourceName, language); - break; - case INVOKE_VIRTUAL: - payload = new InjectInvokeVirtual(sourceName, language); - break; - case LDC: - case LDC2_W: - case LDC_W: - payload = new InjectLdc(sourceName, language); - break; - case MULTIANEWARRAY: - payload = new InjectMultiANewArray(sourceName, language); - break; - case PUTFIELD: - payload = new InjectPutField(sourceName, language); - break; - case PUTSTATIC: - payload = new InjectPutStatic(sourceName, language); - break; - default: - return super.allocateInject(sourceName, name, InjectPayload.CALLOTHERFIXUP_TYPE); - } - return payload; + paramPayload = new InjectPayloadJavaParameters(l, offset); } @Override @@ -208,27 +157,14 @@ public class PcodeInjectLibraryJava extends PcodeInjectLibrary { */ public InjectPayload getPayload(int type, String name, Program program, String context) { if (type == InjectPayload.CALLMECHANISM_TYPE) { - if (paramPayload == null) { - paramPayload = new InjectPayloadJavaParameters(); - } return paramPayload; } - if (!implementedOps.contains(name)) { + InjectPayloadJava payload = implementedOps.get(name); + if (payload == null) { return super.getPayload(type, name, program, context); } - InjectPayloadJava payload = - (InjectPayloadJava) super.getPayload(InjectPayload.CALLOTHERFIXUP_TYPE, name, program, - context); - - synchronized (parser) { - OpTpl[] opTemplates = payload.getPcode(parser, program, context); - adjustUniqueBase(opTemplates); - //clear the added symbols so that the parser can be used again without - //duplicate symbol name conflicts. - parser.clearSymbols(); - } return payload; } diff --git a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/PcodeOpEmitter.java b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/PcodeOpEmitter.java index 3c2fd13dca..92abc2ec9d 100644 --- a/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/PcodeOpEmitter.java +++ b/Ghidra/Processors/JVM/src/main/java/ghidra/app/util/pcodeInject/PcodeOpEmitter.java @@ -100,18 +100,24 @@ public class PcodeOpEmitter { return PcodeOp.COPY; } - public PcodeOpEmitter(SleighLanguage language, Address opAddr) { + public PcodeOpEmitter(SleighLanguage language, Address opAddr, long uniqBase) { nameToReg = new HashMap(); opList = new ArrayList(); this.language = language; constSpace = language.getAddressFactory().getConstantSpace(); defSpace = language.getDefaultSpace(); uniqueSpace = language.getAddressFactory().getUniqueSpace(); - uniqueBase = language.getUniqueBase(); + uniqueBase = uniqBase; opAddress = opAddr; seqnum = 0; spVarnode = findRegister("SP"); - defSpaceId = getConstant(defSpace.getSpaceID(), 8); + defSpaceId = getConstant(defSpace.getSpaceID(), 4); + } + + public PcodeOp[] getPcodeOps() { + PcodeOp[] res = new PcodeOp[opList.size()]; + opList.toArray(res); + return res; } public void defineTemp(String name, int size) { @@ -171,7 +177,7 @@ public class PcodeOpEmitter { in = new Varnode[2]; in[0] = spVarnode; in[1] = getConstant(8, spVarnode.getSize()); - op = new PcodeOp(opAddress, seqnum++, PcodeOp.INT_SUB, in, spVarnode); + op = new PcodeOp(opAddress, seqnum++, PcodeOp.INT_ADD, in, spVarnode); opList.add(op); } @@ -189,7 +195,7 @@ public class PcodeOpEmitter { in = new Varnode[2]; in[0] = spVarnode; in[1] = getConstant(4, spVarnode.getSize()); - op = new PcodeOp(opAddress, seqnum++, PcodeOp.INT_SUB, in, spVarnode); + op = new PcodeOp(opAddress, seqnum++, PcodeOp.INT_ADD, in, spVarnode); opList.add(op); } @@ -295,8 +301,7 @@ public class PcodeOpEmitter { public void emitWriteToMemory(String space, int size, String offset, String value) { Varnode[] in = new Varnode[3]; AddressSpace spc = language.getAddressFactory().getAddressSpace(space); - // TODO: find correct space id - in[0] = getConstant(spc.getSpaceID(), 8); + in[0] = getConstant(spc.getSpaceID(), 4); if (offset.charAt(0) <= '9') { String[] piece = offset.split(":"); int sz = Integer.parseInt(piece[1]); diff --git a/Ghidra/Processors/JVM/src/test/java/ghidra/app/util/pcodeInject/InvokeMethodsTest.java b/Ghidra/Processors/JVM/src/test/java/ghidra/app/util/pcodeInject/InvokeMethodsTest.java index b5d6b96bd8..4de13ac6d4 100644 --- a/Ghidra/Processors/JVM/src/test/java/ghidra/app/util/pcodeInject/InvokeMethodsTest.java +++ b/Ghidra/Processors/JVM/src/test/java/ghidra/app/util/pcodeInject/InvokeMethodsTest.java @@ -35,12 +35,14 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest { private SleighLanguage language; private Address opAddress; + private long uniqueBase; @Before public void setUp() throws Exception { language = (SleighLanguage) getLanguageService().getLanguage(new LanguageID("JVM:BE:32:default")); opAddress = language.getAddressFactory().getDefaultAddressSpace().getAddress(0x10000); + uniqueBase = language.getUniqueBase(); } @Test @@ -58,11 +60,11 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest { byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); InvokeMethods.emitPcodeToResolveMethodReference(pCode, 1, constantPool, JavaInvocationType.INVOKE_DYNAMIC); - PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase); expected.emitAssignRegisterFromPcodeOpCall(InvokeMethods.CALL_TARGET, ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_INVOKEDYNAMIC); assertEquals("incorrect pcode for dynamic invocation", expected, pCode); @@ -84,12 +86,12 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest { byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); pCode.defineTemp(InvokeMethods.THIS, 4); InvokeMethods.emitPcodeToResolveMethodReference(pCode, 1, constantPool, JavaInvocationType.INVOKE_INTERFACE); - PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase); expected.defineTemp(InvokeMethods.THIS, 4); expected.emitAssignRegisterFromPcodeOpCall(InvokeMethods.CALL_TARGET, ConstantPoolJava.CPOOL_OP, InvokeMethods.THIS, "1", @@ -113,12 +115,12 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest { byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); pCode.defineTemp(InvokeMethods.THIS, 4); InvokeMethods.emitPcodeToResolveMethodReference(pCode, 1, constantPool, JavaInvocationType.INVOKE_SPECIAL); - PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase); expected.defineTemp(InvokeMethods.THIS, 4); expected.emitAssignRegisterFromPcodeOpCall(InvokeMethods.CALL_TARGET, ConstantPoolJava.CPOOL_OP, InvokeMethods.THIS, "1", @@ -142,11 +144,11 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest { byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); InvokeMethods.emitPcodeToResolveMethodReference(pCode, 1, constantPool, JavaInvocationType.INVOKE_STATIC); - PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase); expected.emitAssignRegisterFromPcodeOpCall(InvokeMethods.CALL_TARGET, ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_INVOKESTATIC); assertEquals("incorrect pcode for static method invocation", expected, pCode); @@ -168,12 +170,12 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest { byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); pCode.defineTemp(InvokeMethods.THIS, 4); InvokeMethods.emitPcodeToResolveMethodReference(pCode, 1, constantPool, JavaInvocationType.INVOKE_VIRTUAL); - PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase); expected.defineTemp(InvokeMethods.THIS, 4); expected.emitAssignRegisterFromPcodeOpCall(InvokeMethods.CALL_TARGET, ConstantPoolJava.CPOOL_OP, InvokeMethods.THIS, "1", @@ -183,9 +185,9 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest { @Test public void testEmitPcodeToReverseStackNoParamsNoThis() { - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); //InvokeMethods.emitPcodeToReverseStack(pCode, new ArrayList(), false); - PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase); assertEquals("incorrect pcode reversing stack: no params no this", expected, pCode); } @@ -205,10 +207,10 @@ public class InvokeMethodsTest extends AbstractGhidraHeadlessIntegrationTest { byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); InvokeMethods.getPcodeForInvoke(pCode, 1, constantPool, JavaInvocationType.INVOKE_DYNAMIC); - PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase); String descriptor = DescriptorDecoder.getDescriptorForInvoke(1, constantPool, JavaInvocationType.INVOKE_DYNAMIC); List categories = diff --git a/Ghidra/Processors/JVM/src/test/java/ghidra/app/util/pcodeInject/LdcMethodsTest.java b/Ghidra/Processors/JVM/src/test/java/ghidra/app/util/pcodeInject/LdcMethodsTest.java index 1cf193c2e7..48d88f1399 100644 --- a/Ghidra/Processors/JVM/src/test/java/ghidra/app/util/pcodeInject/LdcMethodsTest.java +++ b/Ghidra/Processors/JVM/src/test/java/ghidra/app/util/pcodeInject/LdcMethodsTest.java @@ -50,12 +50,14 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest { private static final int COUNT_LOW_BYTE = 9; private SleighLanguage language; private Address opAddress; + private long uniqueBase; @Before public void setUp() throws Exception { language = (SleighLanguage) getLanguageService().getLanguage(new LanguageID("JVM:BE:32:default")); opAddress = language.getAddressFactory().getDefaultAddressSpace().getAddress(0x10000); + uniqueBase = language.getUniqueBase(); } @Test @@ -67,9 +69,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest { TestClassFileCreator.appendInteger(classFile, 0x12345678); byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); LdcMethods.getPcodeForLdc(pCode, 1, constantPool); - PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase); expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4, ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_LDC); expectedPcode.emitPushCat1Value(LdcMethods.VALUE); @@ -80,9 +82,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest { TestClassFileCreator.appendInteger(classFile, 0x11111111); classFileBytes = TestClassFileCreator.getByteArray(classFile); constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - pCode = new PcodeOpEmitter(language, opAddress); + pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); LdcMethods.getPcodeForLdc(pCode, 2, constantPool); - expectedPcode = new PcodeOpEmitter(language, opAddress); + expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase); expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4, ConstantPoolJava.CPOOL_OP, "0", "2", ConstantPoolJava.CPOOL_LDC); expectedPcode.emitPushCat1Value(LdcMethods.VALUE); @@ -99,10 +101,10 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest { byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); LdcMethods.getPcodeForLdc(pCode, 1, constantPool); //+1 to skip over the tag - PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase); expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4, ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_LDC); expectedPcode.emitPushCat1Value(LdcMethods.VALUE); @@ -114,10 +116,10 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest { classFileBytes = TestClassFileCreator.getByteArray(classFile); constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - pCode = new PcodeOpEmitter(language, opAddress); + pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); LdcMethods.getPcodeForLdc(pCode, 2, constantPool); //+1 for tag of first float, +4 for data of first float, +1 for tag of 2nd float - expectedPcode = new PcodeOpEmitter(language, opAddress); + expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase); expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4, ConstantPoolJava.CPOOL_OP, "0", "2", ConstantPoolJava.CPOOL_LDC); expectedPcode.emitPushCat1Value(LdcMethods.VALUE); @@ -133,10 +135,10 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest { TestClassFileCreator.appendDouble(classFile, 2.0); byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); LdcMethods.getPcodeForLdc(pCode, 1, constantPool); //+1 to skip over the tag - PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase); expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 8, ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_LDC2_W); expectedPcode.emitPushCat2Value(LdcMethods.VALUE); @@ -148,9 +150,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest { TestClassFileCreator.appendDouble(classFile, 4.0); classFileBytes = TestClassFileCreator.getByteArray(classFile); constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - pCode = new PcodeOpEmitter(language, opAddress); + pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); LdcMethods.getPcodeForLdc(pCode, 3, constantPool); - expectedPcode = new PcodeOpEmitter(language, opAddress); + expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase); expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 8, ConstantPoolJava.CPOOL_OP, "0", "3", ConstantPoolJava.CPOOL_LDC2_W); expectedPcode.emitPushCat2Value(LdcMethods.VALUE); @@ -166,9 +168,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest { TestClassFileCreator.appendLong(classFile, 0x123456789l); byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); LdcMethods.getPcodeForLdc(pCode, 1, constantPool); - PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase); expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 8, ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_LDC2_W); expectedPcode.emitPushCat2Value(LdcMethods.VALUE); @@ -180,9 +182,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest { TestClassFileCreator.appendLong(classFile, 0x1111111111l); classFileBytes = TestClassFileCreator.getByteArray(classFile); constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - pCode = new PcodeOpEmitter(language, opAddress); + pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); LdcMethods.getPcodeForLdc(pCode, 3, constantPool); - expectedPcode = new PcodeOpEmitter(language, opAddress); + expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase); expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 8, ConstantPoolJava.CPOOL_OP, "0", "3", ConstantPoolJava.CPOOL_LDC2_W); expectedPcode.emitPushCat2Value(LdcMethods.VALUE); @@ -199,9 +201,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest { TestClassFileCreator.appendUtf8(classFile, "input1"); byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); LdcMethods.getPcodeForLdc(pCode, 1, constantPool); - PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase); expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4, ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_LDC); expectedPcode.emitPushCat1Value(LdcMethods.VALUE); @@ -214,9 +216,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest { TestClassFileCreator.appendUtf8(classFile, "input2"); classFileBytes = TestClassFileCreator.getByteArray(classFile); constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - pCode = new PcodeOpEmitter(language, opAddress); + pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); LdcMethods.getPcodeForLdc(pCode, 3, constantPool); - expectedPcode = new PcodeOpEmitter(language, opAddress); + expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase); expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4, ConstantPoolJava.CPOOL_OP, "0", "3", ConstantPoolJava.CPOOL_LDC); expectedPcode.emitPushCat1Value(LdcMethods.VALUE); @@ -233,10 +235,10 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest { TestClassFileCreator.appendUtf8(classFile, "Ljava/lang/Integer;"); byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); LdcMethods.getPcodeForLdc(pCode, 1, constantPool); - PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase); expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4, ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_LDC); expectedPcode.emitPushCat1Value(LdcMethods.VALUE); @@ -249,9 +251,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest { TestClassFileCreator.appendUtf8(classFile, "Ljava/lang/String;"); classFileBytes = TestClassFileCreator.getByteArray(classFile); constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - pCode = new PcodeOpEmitter(language, opAddress); + pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); LdcMethods.getPcodeForLdc(pCode, 3, constantPool); - expectedPcode = new PcodeOpEmitter(language, opAddress); + expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase); expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4, ConstantPoolJava.CPOOL_OP, "0", "3", ConstantPoolJava.CPOOL_LDC); expectedPcode.emitPushCat1Value(LdcMethods.VALUE); @@ -268,13 +270,13 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest { TestClassFileCreator.appendUtf8(classFile, "(I)Ljava/lang/Integer;"); byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); LdcMethods.getPcodeForLdc(pCode, 1, constantPool); //+1 to skip over the tag of the MethodType element //+2 to skip over data of MethodType element (2-byte ref to utf8 element) //+1 to skip over tag of utf8 element //+2 to skip over length of utf8 element - PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase); expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4, ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_LDC); expectedPcode.emitPushCat1Value(LdcMethods.VALUE); @@ -287,9 +289,9 @@ public class LdcMethodsTest extends AbstractGhidraHeadlessIntegrationTest { TestClassFileCreator.appendUtf8(classFile, "(I)Ljava/lang/Integer;"); classFileBytes = TestClassFileCreator.getByteArray(classFile); constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - pCode = new PcodeOpEmitter(language, opAddress); + pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); LdcMethods.getPcodeForLdc(pCode, 3, constantPool); - expectedPcode = new PcodeOpEmitter(language, opAddress); + expectedPcode = new PcodeOpEmitter(language, opAddress, uniqueBase); expectedPcode.emitAssignVarnodeFromPcodeOpCall(LdcMethods.VALUE, 4, ConstantPoolJava.CPOOL_OP, "0", "3", ConstantPoolJava.CPOOL_LDC); expectedPcode.emitPushCat1Value(LdcMethods.VALUE); diff --git a/Ghidra/Processors/JVM/src/test/java/ghidra/app/util/pcodeInject/ReferenceMethodsTest.java b/Ghidra/Processors/JVM/src/test/java/ghidra/app/util/pcodeInject/ReferenceMethodsTest.java index 3cf46c0fb9..b244cafe46 100644 --- a/Ghidra/Processors/JVM/src/test/java/ghidra/app/util/pcodeInject/ReferenceMethodsTest.java +++ b/Ghidra/Processors/JVM/src/test/java/ghidra/app/util/pcodeInject/ReferenceMethodsTest.java @@ -33,16 +33,14 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest private SleighLanguage language; private Address opAddress; - - public ReferenceMethodsTest() { - - } + private long uniqueBase; @Before public void setUp() throws Exception { language = (SleighLanguage) getLanguageService().getLanguage(new LanguageID("JVM:BE:32:default")); opAddress = language.getAddressFactory().getDefaultAddressSpace().getAddress(0x10000); + uniqueBase = language.getUniqueBase(); } @Test @@ -61,10 +59,10 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); ReferenceMethods.getPcodeForGetStatic(pCode, 1, constantPool); - PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase); expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.TEMP_1, 4, ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_GETSTATIC); expected.emitAssignVarnodeFromDereference(ReferenceMethods.VALUE, 4, @@ -89,10 +87,10 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); ReferenceMethods.getPcodeForGetStatic(pCode, 1, constantPool); - PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase); expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.TEMP_1, 8, ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_GETSTATIC); @@ -119,14 +117,14 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); ReferenceMethods.getPcodeForPutStatic(pCode, 1, constantPool); - PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase); expected.emitPopCat1Value(ReferenceMethods.NEW_VALUE); expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.STATIC_OFFSET, 4, ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_PUTSTATIC); - expected.emitWriteToMemory(PcodeTextEmitter.RAM, 4, + expected.emitWriteToMemory(PcodeOpEmitter.RAM, 4, ReferenceMethods.STATIC_OFFSET, ReferenceMethods.NEW_VALUE); assertEquals(pCode, expected); } @@ -147,14 +145,14 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); ReferenceMethods.getPcodeForPutStatic(pCode, 1, constantPool); - PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase); expected.emitPopCat2Value(ReferenceMethods.NEW_VALUE); expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.STATIC_OFFSET, 4, ConstantPoolJava.CPOOL_OP, "0", "1", ConstantPoolJava.CPOOL_PUTSTATIC); - expected.emitWriteToMemory(PcodeTextEmitter.RAM, 8, + expected.emitWriteToMemory(PcodeOpEmitter.RAM, 8, ReferenceMethods.STATIC_OFFSET, ReferenceMethods.NEW_VALUE); assertEquals(pCode, expected); } @@ -175,10 +173,10 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); ReferenceMethods.getPcodeForGetField(pCode, 1, constantPool); - PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase); expected.emitPopCat1Value(ReferenceMethods.OBJECT_REF); expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.TEMP_1, 4, ConstantPoolJava.CPOOL_OP, ReferenceMethods.OBJECT_REF, "1", @@ -205,10 +203,10 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); ReferenceMethods.getPcodeForGetField(pCode, 1, constantPool); - PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase); expected.emitPopCat1Value(ReferenceMethods.OBJECT_REF); expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.TEMP_1, 8, ConstantPoolJava.CPOOL_OP, ReferenceMethods.OBJECT_REF, "1", @@ -235,16 +233,16 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); ReferenceMethods.getPcodeForPutField(pCode, 1, constantPool); - PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase); expected.emitPopCat1Value(ReferenceMethods.NEW_VALUE); expected.emitPopCat1Value(ReferenceMethods.OBJECT_REF); expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.FIELD_OFFSET, 4, ConstantPoolJava.CPOOL_OP, ReferenceMethods.OBJECT_REF, "1", ConstantPoolJava.CPOOL_PUTFIELD); - expected.emitWriteToMemory(PcodeTextEmitter.RAM, 4, + expected.emitWriteToMemory(PcodeOpEmitter.RAM, 4, ReferenceMethods.FIELD_OFFSET, ReferenceMethods.NEW_VALUE); assertEquals(pCode, expected); @@ -266,16 +264,16 @@ public class ReferenceMethodsTest extends AbstractGhidraHeadlessIntegrationTest byte[] classFileBytes = TestClassFileCreator.getByteArray(classFile); AbstractConstantPoolInfoJava[] constantPool = TestClassFileCreator.getConstantPoolFromBytes(classFileBytes); - PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter pCode = new PcodeOpEmitter(language, opAddress, uniqueBase); ReferenceMethods.getPcodeForPutField(pCode, 1, constantPool); - PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress); + PcodeOpEmitter expected = new PcodeOpEmitter(language, opAddress, uniqueBase); expected.emitPopCat2Value(ReferenceMethods.NEW_VALUE); expected.emitPopCat1Value(ReferenceMethods.OBJECT_REF); expected.emitAssignVarnodeFromPcodeOpCall(ReferenceMethods.FIELD_OFFSET, 4, ConstantPoolJava.CPOOL_OP, ReferenceMethods.OBJECT_REF, "1", ConstantPoolJava.CPOOL_PUTFIELD); - expected.emitWriteToMemory(PcodeTextEmitter.RAM, 8, + expected.emitWriteToMemory(PcodeOpEmitter.RAM, 8, ReferenceMethods.FIELD_OFFSET, ReferenceMethods.NEW_VALUE); assertEquals(pCode, expected);