List of usage examples for org.objectweb.asm.tree ClassNode ClassNode
public ClassNode(final int api)
From source file:org.blockartistry.mod.Jiffy.asm.Transformer.java
License:MIT License
private byte[] replaceRandom(final String name, final byte[] classBytes) { final String randomToReplace = "java/util/Random"; final String newRandom = "org/blockartistry/util/XorShiftRandom"; boolean madeUpdate = false; final ClassReader cr = new ClassReader(classBytes); final ClassNode cn = new ClassNode(ASM5); cr.accept(cn, 0);//from www . ja va 2s . c o m for (final MethodNode m : cn.methods) { final ListIterator<AbstractInsnNode> itr = m.instructions.iterator(); boolean foundNew = false; while (itr.hasNext()) { final AbstractInsnNode node = itr.next(); if (node.getOpcode() == NEW) { final TypeInsnNode theNew = (TypeInsnNode) node; if (randomToReplace.equals(theNew.desc)) { m.instructions.set(node, new TypeInsnNode(NEW, newRandom)); madeUpdate = true; foundNew = true; } } else if (node.getOpcode() == INVOKESPECIAL) { final MethodInsnNode theInvoke = (MethodInsnNode) node; if (randomToReplace.equals(theInvoke.owner)) { if (foundNew) { m.instructions.set(node, new MethodInsnNode(INVOKESPECIAL, newRandom, theInvoke.name, theInvoke.desc, false)); foundNew = false; } } } } } if (madeUpdate) { logger.debug("Replaced Random in " + name); ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); cn.accept(cw); return cw.toByteArray(); } return classBytes; }
From source file:org.blockartistry.mod.Jiffy.asm.Transformer.java
License:MIT License
private byte[] replaceMath(final String name, final byte[] classBytes) { boolean madeUpdate = false; final ClassReader cr = new ClassReader(classBytes); final ClassNode cn = new ClassNode(ASM5); cr.accept(cn, 0);/*w ww. ja v a 2 s .c om*/ for (final MethodNode m : cn.methods) { final ListIterator<AbstractInsnNode> itr = m.instructions.iterator(); while (itr.hasNext()) { final AbstractInsnNode node = itr.next(); if (node.getOpcode() == INVOKESTATIC) { final MethodInsnNode theInvoke = (MethodInsnNode) node; if ("java/lang/Math".equals(theInvoke.owner)) { if ("sin".equals(theInvoke.name) || "cos".equals(theInvoke.name) || "random".equals(theInvoke.name)) { madeUpdate = true; m.instructions.set(node, new MethodInsnNode(INVOKESTATIC, "org/blockartistry/util/MathHelper", theInvoke.name, theInvoke.desc, false)); } } } } } if (madeUpdate) { logger.debug("Replaced Math in " + name); ClassWriter cw = new ClassWriter(ClassWriter.COMPUTE_MAXS); cn.accept(cw); return cw.toByteArray(); } return classBytes; }
From source file:org.coldswap.asm.field.PrivateStaticFieldReplacer.java
License:Open Source License
public byte[] replace() { final ClassNode cn = new ClassNode(Opcodes.ASM5); ClassReader cr = new ClassReader(bytes); ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES); cr.accept(cn, 0);/*from w ww .j a v a2s .com*/ // get a list of public/protected/package/private fields but exclude // inherited fields. Field[] refFields = aClass.getDeclaredFields(); List asmFields = cn.fields; Iterator iterator = asmFields.iterator(); while (iterator.hasNext()) { final FieldNode fNode = (FieldNode) iterator.next(); int privateStatic = Opcodes.ACC_STATIC | Opcodes.ACC_PRIVATE; // search only for private static fields if ((fNode.access == privateStatic)) { // check if this field exist in the old loaded class // and if not proceed with the trick. boolean foundIt = false; for (Field refField : refFields) { if (fNode.name.equals(refField.getName())) { if (fNode.desc.equals(Type.getType(refField.getType()).getDescriptor())) { foundIt = true; break; } } } if (!foundIt) { String contClass = cn.name.substring(cn.name.lastIndexOf("/") + 1); String className = TransformerNameGenerator.getPrivateStaticFieldClassName(contClass, fNode.name); // remove the static reference from <clinit> InsnList insnList = cleanClInit(cn, fNode); // create a new class that contains the field // before anything change the field access to public static so that it can be referenced // from other classes. fNode.access = Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC; byte[] newBClass = ByteCodeGenerator.newFieldClass(cn, fNode, insnList, classPackage + className); try { String cp = ClassUtil.getClassPath(aClass); ByteCodeClassWriter.setClassPath(cp); ByteCodeClassWriter.writeClass(className, newBClass); } catch (IOException e) { logger.warning(e.toString()); } iterator.remove(); // replace every reference replaceReferences(cn, fNode); } } } cn.accept(cw); return cw.toByteArray(); }
From source file:org.coldswap.asm.field.ProtectedStaticFieldReplacer.java
License:Open Source License
public byte[] replace() { final ClassNode cn = new ClassNode(Opcodes.ASM5); ClassReader cr = new ClassReader(bytes); ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES); cr.accept(cn, 0);//from www .j a v a 2 s .c o m // get a list of public/protected fields. Field[] refFields = aClass.getDeclaredFields(); List asmFields = getFields(cn); Iterator iterator = asmFields.iterator(); while (iterator.hasNext()) { final FieldNode fNode = (FieldNode) iterator.next(); int protectedStatic = Opcodes.ACC_STATIC | Opcodes.ACC_PROTECTED; // search only for protected static fields if ((fNode.access == protectedStatic)) { // check if this field exist in the old loaded class // and if not proceed with the trick. boolean foundIt = false; for (Field refField : refFields) { if (fNode.name.equals(refField.getName())) { if (fNode.desc.equals(Type.getType(refField.getType()).getDescriptor())) { foundIt = true; break; } } } if (!foundIt) { // register a public static reference replacer String contClass = cn.name.substring(cn.name.lastIndexOf("/") + 1); String className = TransformerNameGenerator.getProtectedStaticFieldClassName(contClass, fNode.name); // make field access as public static fNode.access = Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC; replacerManager.registerFieldReferenceReplacer(new ProtectedStaticFieldReferenceReplacer( contClass, fNode, classPackage + className, contClass)); // remove the static reference from <clinit> InsnList insnList = cleanClInit(cn, fNode, true); // because the field might be inherited from superclass we need to copy // the initializer from the parent. if ((insnList == null) || (insnList.size() > 0)) { insnList = inheritedInitCode.get(fNode); } // create a new class that contains the field // before anything change the field access to public static so that it can be referenced // from other classes. fNode.access = Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC; byte[] newBClass = ByteCodeGenerator.newFieldClass(cn, fNode, insnList, classPackage + className); try { String cp = ClassUtil.getClassPath(aClass); ByteCodeClassWriter.setClassPath(cp); ByteCodeClassWriter.writeClass(className, newBClass); } catch (IOException e) { logger.warning(e.toString()); } iterator.remove(); // replace every reference replaceReferences(cn, fNode); } } } cn.accept(cw); return cw.toByteArray(); }
From source file:org.coldswap.asm.field.ProtectedStaticFieldReplacer.java
License:Open Source License
/** * Returns an array of fields that where declared in this class. In * addition there are also the protected fields that were inherited. * * @param classNode {@link ClassNode} containing the new class version. * @return a list of all fields including the inherited fields. *//*from ww w .jav a 2s . com*/ private List<FieldNode> getFields(ClassNode classNode) { List<FieldNode> toRet = classNode.fields; // get inherited package fields try { String superName = classNode.superName; // filter superclasses for (String pack : ClassUtil.skipTransforming) { if (superName.startsWith(pack)) { return toRet; } } Class<?> c = Class.forName(superName); String path = ClassUtil.getClassPath(c); path = path + ClassUtil.fileSeparator + superName + ".class"; byte[] clazz = ByteCodeClassLoader.loadClassBytes(path); ClassNode cNode = new ClassNode(Opcodes.ASM5); ClassReader cr = new ClassReader(clazz); cr.accept(cNode, 0); List<FieldNode> superFields = cNode.fields; for (FieldNode fieldNode : superFields) { if (fieldNode.access == (Opcodes.ACC_STATIC | Opcodes.ACC_PROTECTED)) { toRet.add(fieldNode); InsnList code = cleanClInit(cNode, fieldNode, false); inheritedInitCode.put(fieldNode, code); } } } catch (ClassNotFoundException e) { logger.warning(e.toString()); } return toRet; }
From source file:org.coldswap.asm.field.PublicStaticFieldReplacer.java
License:Open Source License
public byte[] replace() { final ClassNode cn = new ClassNode(Opcodes.ASM5); ClassReader cr = new ClassReader(bytes); ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES); cr.accept(cn, 0);//w w w. j a v a2s . com // get a list of public/protected/package/private fields but exclude // inherited fields. Field[] refFields = aClass.getDeclaredFields(); List asmFields = cn.fields; Iterator iterator = asmFields.iterator(); while (iterator.hasNext()) { final FieldNode fNode = (FieldNode) iterator.next(); int publicStatic = Opcodes.ACC_STATIC | Opcodes.ACC_PUBLIC; //int publicStaticFinal = Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL; // search only for public static fields if ((fNode.access == publicStatic)) { // check if this field exist in the old loaded class // and if not proceed with the trick. boolean foundIt = false; for (Field refField : refFields) { if (fNode.name.equals(refField.getName())) { if (fNode.desc.equals(Type.getType(refField.getType()).getDescriptor())) { foundIt = true; break; } } } if (!foundIt) { // register a public static reference replacer String contClass = cn.name.substring(cn.name.lastIndexOf("/") + 1); String className = TransformerNameGenerator.getPublicStaticFieldClassName(contClass, fNode.name); replacerManager.registerFieldReferenceReplacer( new PublicStaticFieldReferenceReplacer(contClass, fNode, classPackage + className)); // remove the static reference from <clinit> InsnList insnList = cleanClInit(cn, fNode); // create a new class that contains the field byte[] newBClass = ByteCodeGenerator.newFieldClass(cn, fNode, insnList, classPackage + className); try { String cp = ClassUtil.getClassPath(aClass); ByteCodeClassWriter.setClassPath(cp); ByteCodeClassWriter.writeClass(className, newBClass); } catch (IOException e) { logger.warning(e.toString()); } iterator.remove(); // replace every reference replaceReferences(cn, fNode); } } } cn.accept(cw); return cw.toByteArray(); }
From source file:org.coldswap.asm.method.MethodCleaner.java
License:Open Source License
@Override public byte[] replace() { final ClassNode cn = new ClassNode(Opcodes.ASM5); ClassReader cr = new ClassReader(bytes); ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS); cr.accept(cn, 0);//from www .ja va 2s . c om // get a list of public/protected/package/private methods but exclude // inherited methods. Method[] methods = aClass.getDeclaredMethods(); List asmMethods = cn.methods; Iterator iterator = asmMethods.iterator(); while (iterator.hasNext()) { final MethodNode mNode = (MethodNode) iterator.next(); // exclude <init>() and <clinit>() if (!"<clinit>".equals(mNode.name) && !"<init>".equals(mNode.name)) { boolean foundIt = false; int publicAccessor = Opcodes.ACC_PUBLIC; // search only for public methods if ((mNode.access == publicAccessor)) { // check if this method exist in the old loaded class // and if not proceed with the trick. Type mRetType = MethodUtil.getReturnType(mNode); Type[] mParamType = MethodUtil.getParamsType(mNode); for (Method method : methods) { if (mNode.name.equals(method.getName())) { Type fRetType = Type.getType(method).getReturnType(); if (mRetType.equals(fRetType)) { Type[] fParamType = MethodUtil.classToType(method.getParameterTypes()); boolean tmp = true; if (mParamType.length == fParamType.length) { for (int i = 0; i < mParamType.length; i++) { if (!mParamType[i].equals(fParamType[i])) { tmp = false; } } } foundIt = tmp; } } } if (!foundIt) { // remove counter++; iterator.remove(); } } } } // note user about removed methods. if (counter > 0) { logger.severe( counter + " new methods found and removed. Please consider stopping the application because" + " there might be calls to this methods that would break application state."); } cn.accept(cw); return cw.toByteArray(); }
From source file:org.coldswap.asm.method.PublicFloatMethodReplacer.java
License:Open Source License
@Override public byte[] replace() { int counter = -1; final ClassNode cn = new ClassNode(Opcodes.ASM5); ClassReader cr = new ClassReader(bytes); ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS); cr.accept(cn, 0);//from ww w. j av a 2 s . c o m List<MethodBox> factory = new ArrayList<MethodBox>(); // find first the helper method MethodNode[] helperMethod = new MethodNode[maxNumberOfMethods]; for (int i = 0; i < maxNumberOfMethods; i++) { helperMethod[i] = MethodUtil.createFloatHelperMethod(cn.name, i); cn.methods.add(helperMethod[i]); } // get a list of public/protected/package/private methods but exclude // inherited methods. Method[] methods = aClass.getDeclaredMethods(); List asmMethods = cn.methods; Iterator iterator = asmMethods.iterator(); while (iterator.hasNext()) { final MethodNode mNode = (MethodNode) iterator.next(); // exclude <init>() and <clinit>() if (!"<clinit>".equals(mNode.name) && !"<init>".equals(mNode.name)) { boolean foundIt = false; int publicAccessor = Opcodes.ACC_PUBLIC; // search only for public methods if ((mNode.access == publicAccessor)) { // check if this method exist in the old loaded class // and if not proceed with the trick. Type mRetType = MethodUtil.getReturnType(mNode); Type[] mParamType = MethodUtil.getParamsType(mNode); for (Method method : methods) { if (mNode.name.equals(method.getName())) { Type fRetType = Type.getType(method).getReturnType(); if (mRetType.equals(fRetType)) { Type[] fParamType = MethodUtil.classToType(method.getParameterTypes()); boolean tmp = true; if (mParamType.length == fParamType.length) { for (int i = 0; i < mParamType.length; i++) { if (!mParamType[i].equals(fParamType[i])) { tmp = false; } } } foundIt = tmp; } } } if (!foundIt) { // ignore any method that has return type of void if (!mRetType.equals(Type.VOID_TYPE)) { // work only with methods that have as a parameter int. if (mParamType.length == 1 && mParamType[0].equals(Type.getType("F"))) { if (counter < maxNumberOfMethods) { counter++; refManager.registerFieldReferenceReplacer(new PublicMethodReferenceReplacer( cn.name, mNode.name, mRetType, mParamType, Constants.FLOAT, counter)); // autobox return type. if (AutoBoxing.isPrimitive(mRetType.getDescriptor())) { // replace any return reference with a boxing call and a areturn call mNode.instructions = replaceReturn(mNode.instructions, mRetType); } helperMethod[counter] = ByteCodeGenerator .insertNewNotVoidMethod(helperMethod[counter], mNode); // replace method call factory.add(new VirtualMethodReplacer(cn.name, mNode.name, mRetType, mParamType, Constants.FLOAT, counter)); } // remove method iterator.remove(); } } } } } } // start replacing references for (Object asmMethod : asmMethods) { MethodNode container = (MethodNode) asmMethod; for (MethodBox methodReplacer : factory) { methodReplacer.replaceInvoke(container); } } cn.accept(cw); return cw.toByteArray(); }
From source file:org.coldswap.asm.method.PublicIntMethodReplacer.java
License:Open Source License
@Override public byte[] replace() { int counter = -1; final ClassNode cn = new ClassNode(Opcodes.ASM5); ClassReader cr = new ClassReader(bytes); ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS); cr.accept(cn, 0);/* w w w .j a va 2 s . c o m*/ List<MethodBox> factory = new ArrayList<MethodBox>(); // find first the helper method MethodNode[] helperMethod = new MethodNode[maxNumberOfMethods]; for (int i = 0; i < maxNumberOfMethods; i++) { helperMethod[i] = MethodUtil.createIntHelperMethod(cn.name, i); cn.methods.add(helperMethod[i]); } // get a list of public/protected/package/private methods but exclude // inherited methods. Method[] methods = aClass.getDeclaredMethods(); List asmMethods = cn.methods; Iterator iterator = asmMethods.iterator(); while (iterator.hasNext()) { final MethodNode mNode = (MethodNode) iterator.next(); // exclude <init>() and <clinit>() if (!"<clinit>".equals(mNode.name) && !"<init>".equals(mNode.name)) { boolean foundIt = false; int publicAccessor = Opcodes.ACC_PUBLIC; // search only for public methods if ((mNode.access == publicAccessor)) { // check if this method exist in the old loaded class // and if not proceed with the trick. Type mRetType = MethodUtil.getReturnType(mNode); Type[] mParamType = MethodUtil.getParamsType(mNode); for (Method method : methods) { if (mNode.name.equals(method.getName())) { Type fRetType = Type.getType(method).getReturnType(); if (mRetType.equals(fRetType)) { Type[] fParamType = MethodUtil.classToType(method.getParameterTypes()); boolean tmp = true; if (mParamType.length == fParamType.length) { for (int i = 0; i < mParamType.length; i++) { if (!mParamType[i].equals(fParamType[i])) { tmp = false; } } } foundIt = tmp; } } } if (!foundIt) { // ignore any method that has return type of void if (!mRetType.equals(Type.VOID_TYPE)) { // work only with methods that have as a parameter int. if (mParamType.length == 1 && mParamType[0].equals(Type.getType("I"))) { if (counter < maxNumberOfMethods) { counter++; refManager.registerFieldReferenceReplacer(new PublicMethodReferenceReplacer( cn.name, mNode.name, mRetType, mParamType, Constants.INT, counter)); // autobox return type. if (AutoBoxing.isPrimitive(mRetType.getDescriptor())) { // replace any return reference with a boxing call and a areturn call mNode.instructions = replaceReturn(mNode.instructions, mRetType); } helperMethod[counter] = ByteCodeGenerator .insertNewNotVoidMethod(helperMethod[counter], mNode); // replace method call factory.add(new VirtualMethodReplacer(cn.name, mNode.name, mRetType, mParamType, Constants.INT, counter)); } // remove method iterator.remove(); } } } } } } // start replacing references for (Object asmMethod : asmMethods) { MethodNode container = (MethodNode) asmMethod; for (MethodBox methodReplacer : factory) { methodReplacer.replaceInvoke(container); } } cn.accept(cw); return cw.toByteArray(); }
From source file:org.coldswap.asm.method.PublicLongMethodReplacer.java
License:Open Source License
@Override public byte[] replace() { int counter = -1; final ClassNode cn = new ClassNode(Opcodes.ASM5); ClassReader cr = new ClassReader(bytes); ClassWriter cw = new ClassWriter(cr, ClassWriter.COMPUTE_FRAMES | ClassWriter.COMPUTE_MAXS); cr.accept(cn, 0);//ww w .j av a 2 s . c o m List<MethodBox> factory = new ArrayList<MethodBox>(); // find first the helper method MethodNode[] helperMethod = new MethodNode[maxNumberOfMethods]; for (int i = 0; i < maxNumberOfMethods; i++) { helperMethod[i] = MethodUtil.createLongHelperMethod(cn.name, i); cn.methods.add(helperMethod[i]); } // get a list of public/protected/package/private methods but exclude // inherited methods. Method[] methods = aClass.getDeclaredMethods(); List asmMethods = cn.methods; Iterator iterator = asmMethods.iterator(); while (iterator.hasNext()) { final MethodNode mNode = (MethodNode) iterator.next(); // exclude <init>() and <clinit>() if (!"<clinit>".equals(mNode.name) && !"<init>".equals(mNode.name)) { boolean foundIt = false; int publicAccessor = Opcodes.ACC_PUBLIC; // search only for public methods if ((mNode.access == publicAccessor)) { // check if this method exist in the old loaded class // and if not proceed with the trick. Type mRetType = MethodUtil.getReturnType(mNode); Type[] mParamType = MethodUtil.getParamsType(mNode); for (Method method : methods) { if (mNode.name.equals(method.getName())) { Type fRetType = Type.getType(method).getReturnType(); if (mRetType.equals(fRetType)) { Type[] fParamType = MethodUtil.classToType(method.getParameterTypes()); boolean tmp = true; if (mParamType.length == fParamType.length) { for (int i = 0; i < mParamType.length; i++) { if (!mParamType[i].equals(fParamType[i])) { tmp = false; } } } foundIt = tmp; } } } if (!foundIt) { // ignore any method that has return type of void if (!mRetType.equals(Type.VOID_TYPE)) { // work only with methods that have as a parameter int. if (mParamType.length == 1 && mParamType[0].equals(Type.getType("J"))) { if (counter < maxNumberOfMethods) { counter++; refManager.registerFieldReferenceReplacer(new PublicMethodReferenceReplacer( cn.name, mNode.name, mRetType, mParamType, Constants.LONG, counter)); // autobox return type. if (AutoBoxing.isPrimitive(mRetType.getDescriptor())) { // replace any return reference with a boxing call and a areturn call mNode.instructions = replaceReturn(mNode.instructions, mRetType); } helperMethod[counter] = ByteCodeGenerator .insertNewNotVoidMethod(helperMethod[counter], mNode); // replace method call factory.add(new VirtualMethodReplacer(cn.name, mNode.name, mRetType, mParamType, Constants.LONG, counter)); } // remove method iterator.remove(); } } } } } } // start replacing references for (Object asmMethod : asmMethods) { MethodNode container = (MethodNode) asmMethod; for (MethodBox methodReplacer : factory) { methodReplacer.replaceInvoke(container); } } cn.accept(cw); return cw.toByteArray(); }