/**
* Transforms the init method to create the newly added join point member field.
*
* @param cp the ConstantPoolGen
* @param cg the ClassGen
* @param init the constructor for the class
* @param method the current method
* @param factory the objectfactory
* @param methodSequence the methods sequence number
* @return the modified constructor
*/
private MethodGen createJoinPointField(
final ConstantPoolGen cp,
final ClassGen cg,
final Method init,
final Method method,
final InstructionFactory factory,
final int methodSequence) {
final MethodGen mg = new MethodGen(init, cg.getClassName(), cp);
final InstructionList il = mg.getInstructionList();
final InstructionHandle[] ihs = il.getInstructionHandles();
// grab the handle to the the return instruction of the constructor
InstructionHandle ih = ihs[0];
for (int i = 0; i < ihs.length; i++) {
Instruction instruction = ihs[i].getInstruction();
if (instruction instanceof ReturnInstruction) {
ih = ihs[i]; // set the instruction handle to the return instruction
break;
}
}
final String joinPoint = getJoinPointName(method, methodSequence);
final InstructionHandle ihPost;
ihPost = il.insert(ih, factory.createLoad(Type.OBJECT, 0));
il.insert(ih, factory.createNew(TransformationUtil.THREAD_LOCAL_CLASS));
il.insert(ih, InstructionConstants.DUP);
il.insert(
ih,
factory.createInvoke(
TransformationUtil.THREAD_LOCAL_CLASS,
"<init>",
Type.VOID,
new Type[] {},
Constants.INVOKESPECIAL));
il.insert(
ih,
factory.createFieldAccess(
cg.getClassName(),
joinPoint,
new ObjectType(TransformationUtil.THREAD_LOCAL_CLASS),
Constants.PUTFIELD));
il.redirectBranches(ih, ihPost);
mg.setMaxStack();
mg.setMaxLocals();
return mg;
}
/**
* 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);
}
}
