/* 94: */
/* 95: */ protected int match(
int c, int pos, CodeIterator iterator, int typedesc, ConstPool cp)
/* 96: */ throws BadBytecode
/* 97: */ {
/* 98:110 */ if (this.newIndex == 0)
/* 99: */ {
/* 100:111 */ int nt = cp.addNameAndTypeInfo(cp.addUtf8Info(this.newMethodname), typedesc);
/* 101: */
/* 102:113 */ int ci = cp.addClassInfo(this.newClassname);
/* 103:114 */ if (c == 185)
/* 104: */ {
/* 105:115 */ this.newIndex = cp.addInterfaceMethodrefInfo(ci, nt);
/* 106: */ }
/* 107: */ else
/* 108: */ {
/* 109:117 */ if ((this.newMethodIsPrivate) && (c == 182)) {
/* 110:118 */ iterator.writeByte(183, pos);
/* 111: */ }
/* 112:120 */ this.newIndex = cp.addMethodrefInfo(ci, nt);
/* 113: */ }
/* 114:123 */ this.constPool = cp;
/* 115: */ }
/* 116:126 */ iterator.write16bit(this.newIndex, pos + 1);
/* 117:127 */ return pos;
/* 118: */ }
public boolean transformClass(ClassFile file, ClassLoader loader, boolean modifiableClass) {
Set<Integer> methodCallLocations = new HashSet<Integer>();
Integer newCallLocation = null;
Integer methodReflectionLocation = null;
Integer fakeCallRequiredLocation = null;
// first we need to scan the constant pool looking for
// CONSTANT_method_info_ref structures
ConstPool pool = file.getConstPool();
for (int i = 1; i < pool.getSize(); ++i) {
// we have a method call
if (pool.getTag(i) == ConstPool.CONST_Methodref) {
String className = pool.getMethodrefClassName(i);
String methodName = pool.getMethodrefName(i);
if (className.equals(Method.class.getName())) {
if (methodName.equals("invoke")) {
// store the location in the const pool of the method ref
methodCallLocations.add(i);
// we have found a method call
// if we have not already stored a reference to our new
// method in the const pool
if (newCallLocation == null) {
methodReflectionLocation =
pool.addClassInfo("org.fakereplace.reflection.MethodReflection");
int nt = pool.addNameAndTypeInfo("fakeCallRequired", "(Ljava/lang/reflect/Method;)Z");
fakeCallRequiredLocation = pool.addMethodrefInfo(methodReflectionLocation, nt);
newCallLocation = pool.addNameAndTypeInfo(METHOD_NAME, REPLACED_METHOD_DESCRIPTOR);
}
}
}
}
}
// this means we found an instance of the call, now we have to iterate
// through the methods and replace instances of the call
if (newCallLocation != null) {
List<MethodInfo> methods = file.getMethods();
for (MethodInfo m : methods) {
try {
// ignore abstract methods
if (m.getCodeAttribute() == null) {
continue;
}
CodeIterator it = m.getCodeAttribute().iterator();
while (it.hasNext()) {
// loop through the bytecode
int index = it.next();
int op = it.byteAt(index);
// if the bytecode is a method invocation
if (op == CodeIterator.INVOKEVIRTUAL) {
int val = it.s16bitAt(index + 1);
// if the method call is one of the methods we are
// replacing
if (methodCallLocations.contains(val)) {
Bytecode b = new Bytecode(file.getConstPool());
// our stack looks like Method, instance,params
// we need Method, instance, params , Method
b.add(Opcode.DUP_X2);
b.add(Opcode.POP);
b.add(Opcode.DUP_X2);
b.add(Opcode.POP);
b.add(Opcode.DUP_X2);
b.addInvokestatic(
methodReflectionLocation, "fakeCallRequired", "(Ljava/lang/reflect/Method;)Z");
b.add(Opcode.IFEQ);
JumpMarker performRealCall = JumpUtils.addJumpInstruction(b);
// now perform the fake call
b.addInvokestatic(methodReflectionLocation, "invoke", REPLACED_METHOD_DESCRIPTOR);
b.add(Opcode.GOTO);
JumpMarker finish = JumpUtils.addJumpInstruction(b);
performRealCall.mark();
b.addInvokevirtual(Method.class.getName(), METHOD_NAME, METHOD_DESCRIPTOR);
finish.mark();
it.writeByte(CodeIterator.NOP, index);
it.writeByte(CodeIterator.NOP, index + 1);
it.writeByte(CodeIterator.NOP, index + 2);
it.insert(b.get());
}
}
}
m.getCodeAttribute().computeMaxStack();
} catch (Exception e) {
log.error("Bad byte code transforming " + file.getName());
e.printStackTrace();
}
}
return true;
} else {
return false;
}
}
/**
* Replace access to fields of entities (for example, entity.field) with a call to the enhanced
* getter / setter (in this example, entity.$$_hibernate_read_field()). It's assumed that the
* target entity is enhanced as well.
*
* @param managedCtClass Class to enhance
*/
public void enhanceFieldAccess(CtClass managedCtClass) {
final ConstPool constPool = managedCtClass.getClassFile().getConstPool();
for (Object oMethod : managedCtClass.getClassFile().getMethods()) {
final MethodInfo methodInfo = (MethodInfo) oMethod;
final String methodName = methodInfo.getName();
// skip methods added by enhancement and abstract methods (methods without any code)
if (methodName.startsWith("$$_hibernate_") || methodInfo.getCodeAttribute() == null) {
continue;
}
try {
final CodeIterator itr = methodInfo.getCodeAttribute().iterator();
while (itr.hasNext()) {
int index = itr.next();
int op = itr.byteAt(index);
if (op != Opcode.PUTFIELD && op != Opcode.GETFIELD) {
continue;
}
String fieldName = constPool.getFieldrefName(itr.u16bitAt(index + 1));
String fieldClassName =
constPool.getClassInfo(constPool.getFieldrefClass(itr.u16bitAt(index + 1)));
CtClass targetCtClass = this.classPool.getCtClass(fieldClassName);
if (!enhancementContext.isEntityClass(targetCtClass)
&& !enhancementContext.isCompositeClass(targetCtClass)) {
continue;
}
if (targetCtClass == managedCtClass
|| !enhancementContext.isPersistentField(targetCtClass.getField(fieldName))
|| "this$0".equals(fieldName)) {
continue;
}
log.debugf("Transforming access to field [%s] from method [%s]", fieldName, methodName);
if (op == Opcode.GETFIELD) {
int fieldReaderMethodIndex =
constPool.addMethodrefInfo(
constPool.addClassInfo(fieldClassName),
EnhancerConstants.PERSISTENT_FIELD_READER_PREFIX + fieldName,
"()" + constPool.getFieldrefType(itr.u16bitAt(index + 1)));
itr.writeByte(Opcode.INVOKEVIRTUAL, index);
itr.write16bit(fieldReaderMethodIndex, index + 1);
} else {
int fieldWriterMethodIndex =
constPool.addMethodrefInfo(
constPool.addClassInfo(fieldClassName),
EnhancerConstants.PERSISTENT_FIELD_WRITER_PREFIX + fieldName,
"(" + constPool.getFieldrefType(itr.u16bitAt(index + 1)) + ")V");
itr.writeByte(Opcode.INVOKEVIRTUAL, index);
itr.write16bit(fieldWriterMethodIndex, index + 1);
}
}
methodInfo.getCodeAttribute().setAttribute(MapMaker.make(classPool, methodInfo));
} catch (BadBytecode bb) {
final String msg =
String.format(
"Unable to perform field access transformation in method [%s]", methodName);
throw new EnhancementException(msg, bb);
} catch (NotFoundException nfe) {
final String msg =
String.format(
"Unable to perform field access transformation in method [%s]", methodName);
throw new EnhancementException(msg, nfe);
}
}
}
