/** Instrument the specified method to replace mapped calls. */
public void instrument_method(Method m, MethodGen mg) {
// Loop through each instruction, making substitutions
InstructionList il = mg.getInstructionList();
for (InstructionHandle ih = il.getStart(); ih != null; ) {
if (debug_instrument_inst.enabled()) {
debug_instrument_inst.log("instrumenting instruction %s%n", ih);
// ih.getInstruction().toString(pool.getConstantPool()));
}
InstructionList new_il = null;
// Remember the next instruction to process
InstructionHandle next_ih = ih.getNext();
// Get the translation for this instruction (if any)
new_il = xform_inst(mg, ih.getInstruction());
if (debug_instrument_inst.enabled()) debug_instrument_inst.log(" new inst: %s%n", new_il);
// If this instruction was modified, replace it with the new
// instruction list. If this instruction was the target of any
// jumps or line numbers , replace them with the first
// instruction in the new list
replace_instructions(il, ih, new_il);
ih = next_ih;
}
}
/**
* Replace instruction ih in list il with the instructions in new_il. If new_il is null, do
* nothing
*/
protected static void replace_instructions(
InstructionList il, InstructionHandle ih, InstructionList new_il) {
if ((new_il == null) || new_il.isEmpty()) return;
// If there is only one new instruction, just replace it in the handle
if (new_il.getLength() == 1) {
ih.setInstruction(new_il.getEnd().getInstruction());
return;
}
// Get the start and end instruction of the new instructions
InstructionHandle new_end = new_il.getEnd();
InstructionHandle new_start = il.insert(ih, new_il);
// Move all of the branches from the old instruction to the new start
il.redirectBranches(ih, new_start);
// Move other targets to the new instuctions.
if (ih.hasTargeters()) {
for (InstructionTargeter it : ih.getTargeters()) {
if (it instanceof LineNumberGen) {
it.updateTarget(ih, new_start);
} else if (it instanceof LocalVariableGen) {
it.updateTarget(ih, new_end);
} else if (it instanceof CodeExceptionGen) {
CodeExceptionGen exc = (CodeExceptionGen) it;
if (exc.getStartPC() == ih) exc.updateTarget(ih, new_start);
else if (exc.getEndPC() == ih) exc.updateTarget(ih, new_end);
else if (exc.getHandlerPC() == ih) exc.setHandlerPC(new_start);
else System.out.printf("Malformed CodeException: %s%n", exc);
} else {
System.out.printf("unexpected target %s%n", it);
}
}
}
// Remove the old handle. There should be no targeters left to it.
try {
il.delete(ih);
} catch (Exception e) {
throw new Error("Can't delete instruction", e);
}
}
/**
* Transforms invoke instructions that match the specified list for this class to call the
* specified static call instead.
*/
private InstructionList xform_inst(MethodGen mg, Instruction inst) {
switch (inst.getOpcode()) {
case Constants.INVOKESTATIC:
{
InstructionList il = new InstructionList();
INVOKESTATIC is = (INVOKESTATIC) inst;
String cname = is.getClassName(pgen);
String mname = is.getMethodName(pgen);
Type[] args = is.getArgumentTypes(pgen);
MethodDef orig = new MethodDef(cname + "." + mname, args);
MethodInfo call = method_map.get(orig);
if (call != null) {
call.cnt++;
String classname = call.method_class;
String methodname = mname;
debug_map.log(
"%s.%s: Replacing method %s.%s (%s) with %s.%s%n",
mg.getClassName(),
mg.getName(),
cname,
mname,
UtilMDE.join(args, ", "),
classname,
methodname);
il.append(
ifact.createInvoke(
classname, methodname, is.getReturnType(pgen), args, Constants.INVOKESTATIC));
}
return (il);
}
case Constants.INVOKEVIRTUAL:
{
InstructionList il = new InstructionList();
INVOKEVIRTUAL iv = (INVOKEVIRTUAL) inst;
String cname = iv.getClassName(pgen);
String mname = iv.getMethodName(pgen);
Type[] args = iv.getArgumentTypes(pgen);
Type instance_type = iv.getReferenceType(pgen);
Type[] new_args = BCELUtil.insert_type(instance_type, args);
MethodDef orig = new MethodDef(cname + "." + mname, args);
if (debug_class) System.out.printf("looking for %s in map %s%n", orig, method_map);
MethodInfo call = method_map.get(orig);
if (call != null) {
call.cnt++;
String classname = call.method_class;
String methodname = mname;
debug_map.log(
"Replacing method %s.%s (%s) with %s.%s%n",
cname, mname, ArraysMDE.toString(args), classname, methodname);
il.append(
ifact.createInvoke(
classname,
methodname,
iv.getReturnType(pgen),
new_args,
Constants.INVOKESTATIC));
}
return (il);
}
default:
return (null);
}
}