public String getCodeWithArguments(
Un fixedArguments, Vector<Integer> sizesOfIndividualParameters) {
String ret = code;
try {
if (argumentFunction.size() != sizesOfIndividualParameters.size()) {
Miscellaneous.printlnErr(
"either bytecode defination file is wrong or opcode-parameter file is wrong.");
Miscellaneous.printlnErr(
"bytecode defination required "
+ argumentFunction.size()
+ " parameters, in "
+ "contrast the opcode-parameter file required "
+ sizesOfIndividualParameters.size()
+ " parameters");
Miscellaneous.exit();
}
LFRevUn.bigEndian = true;
for (int loop = argumentFunction.size() - 1; loop >= 0; loop--) {
String nextThingToReplace = "@@" + (loop + 1);
int argSize = sizesOfIndividualParameters.elementAt(loop);
Un afterCutting = Un.cutBytes(argSize, fixedArguments);
String toReplaceWith = "(0x" + afterCutting.toString() + ")";
if (loop != argumentFunction.size() - 1) {
toReplaceWith += ", ";
}
ret = ret.replace(nextThingToReplace, argumentType.elementAt(loop) + toReplaceWith);
}
LFRevUn.bigEndian = false;
} catch (Exception d) {
Miscellaneous.println("Error in bytecode defination file. " + this + ", " + fixedArguments);
d.printStackTrace();
Miscellaneous.exit();
}
return ret;
}
@Override
public void validateInput(String args[]) throws Exception {
if (args.length < 2) {
engine.inputMessage();
Miscellaneous.exit();
}
}
String getCodeWithArguments(Un fixedArg) throws IOException {
try {
return code.replace("@@1", argumentType.elementAt(0) + "(0x" + fixedArg.toString() + ")");
} catch (Exception d) {
LogHolder.getInstanceOf()
.addLog(" *******ERROR ********* in function getCodeWithArguments...", true);
Miscellaneous.println(" Enter a character to continue...");
System.in.read();
}
return "";
}
/**
* In case the method is still under-call then put the record of the method fields where get was
* used in a seperate map. When a method any next instruction is called again then the record is
* pop from the map and corresponding instructions are made dirty.
*
* <p>This method create that record of method fields.
*
* @param methodCallInfo
* @param instrDataSettingInstr
*/
private void handlePutRecalls(
MethodCallInfo methodCallInfo, GCInstruction instrDataSettingInstr, OperandStack stack) {
if (true) return;
try {
/**
* 1. Firstly get from input instructions the uniqueId for corresponding data reterival
* instructions. 2. Subsequently, add those instructions in the two different maps depending
* upon if the method is still under call or not.
*/
ControllerForFieldInstr contr = ControllerForFieldInstr.getInstanceOf();
HashSet<Integer> uniqueIdForDataRetrivalInstr = new HashSet<Integer>();
if (instrDataSettingInstr.getOpCode() != JavaInstructionsOpcodes.AASTORE) {
int cpIndex = instrDataSettingInstr.getOperandsData().intValueUnsigned();
uniqueIdForDataRetrivalInstr.add(cpIndex);
} else {
uniqueIdForDataRetrivalInstr = getAAStoreNewIds(stack);
}
/**
* following are the all getField or getStatic instruction for the given constant pool index.
*/
HashSet<FieldRecord> getFieldOrStateRecordSet =
contr.getRecords(
uniqueIdForDataRetrivalInstr,
instrDataSettingInstr.getOpCode() == JavaInstructionsOpcodes.AASTORE);
/**
* Now we iterate from all of those instructions and put them in two different maps
* depenending up if their method is still under call or not.
*/
Iterator<FieldRecord> fieldRectIt = getFieldOrStateRecordSet.iterator();
while (fieldRectIt.hasNext()) {
FieldRecord fieldRec = fieldRectIt.next();
HashSet<FunctionStateKey> allTheMethodCallsForTheField = fieldRec.getStateKeys();
Iterator<FunctionStateKey> methodCallIt = allTheMethodCallsForTheField.iterator();
while (methodCallIt.hasNext()) {
FunctionStateKey stateKey = methodCallIt.next();
GCDataFlowAnalyzer dataFlowAnalyzer = GCDataFlowAnalyzer.getInstanceOf();
HashSet<FunctionStateKey> allMethodInExecution = dataFlowAnalyzer.getMethodsInExecution();
String methodString = oracle.getMethodOrFieldString(stateKey.getMethod());
long instrId = fieldRec.getInstr().getInstructionId();
if (allMethodInExecution.contains(stateKey)) {
putInMap(fieldsToSetDirtyInUnderCallMethod, stateKey, fieldRec);
} else {
putInMap(fieldsToSetDirtyAfterMethodCalled, stateKey, fieldRec);
}
}
}
} catch (Exception d) {
d.printStackTrace();
Miscellaneous.exit();
}
}
@Override
public void init(String args[]) throws Exception {
String superArgs[] = null;
StatsHolder.getInstanceOf().addStatArgs(args);
engine.setDefaults();
try {
superArgs = engine.processArgs(args);
} catch (Exception d) {
engine.inputMessage();
// Miscellaneous.printlnErr("************ ERROR Wrong input: " + d.getMessage());
// d.printStackTrace();
Miscellaneous.exit();
}
// do not forget this. However, at the end as third parameter was set above properly
super.init(superArgs);
System.arraycopy(superArgs, 0, args, 0, args.length);
}
@Override
public void execute(String args[]) throws Exception {
try {
statHolder.addStat(
StatGroups.BYTECODE_OPTIMIZATION,
"Total size of all instructions ",
CodeAtt.getCodeTotalLengthInput());
super.execute(args);
if (!doOptimization) {
return;
}
InputOptionsController.getInstanceOf().execute();
endWithOptimization = true;
Oracle.getInstanceOf().updateAllCodeAttsLength();
} catch (Exception d) {
d.printStackTrace();
Miscellaneous.exit();
}
}