Java Code Examples for org.objectweb.asm.Opcodes#ACC_PUBLIC

The following examples show how to use org.objectweb.asm.Opcodes#ACC_PUBLIC . You can vote up the ones you like or vote down the ones you don't like, and go to the original project or source file by following the links above each example. You may check out the related API usage on the sidebar.

Example 1

Source File: WrapperExtender.java From 07kit with GNU General Public License v3.0

6 votes

private FieldNode injectFieldAndGetter(ClassNode classNode) {
    FieldNode field = new FieldNode(Opcodes.ACC_PUBLIC, "wrapper",
            "L" + getWrapperName() + ";", "L" + getWrapperName() + ";", null);
    classNode.fields.add(field);

    MethodNode getter = new MethodNode(Opcodes.ACC_PUBLIC, "getWrapper",
            "()L" + getWrapperName() + ";", null, null);
    getter.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
    getter.instructions.add(new FieldInsnNode(Opcodes.GETFIELD, classNode.name,
            field.name, field.desc));
    getter.instructions.add(new InsnNode(Opcodes.ARETURN));
    getter.visitEnd();
    getter.visitMaxs(1, 1);
    classNode.methods.add(getter);

    return field;
}

Example 2

Source File: Engine.java From JReFrameworker with MIT License

6 votes

private String renameMethod(MethodNode methodToRename) {
	// first remove any annotations from renamed base methods
	AnnotationUtils.clearMethodAnnotations(methodToRename);
	
	// rename the method
	String originalMethodName = methodToRename.name;
	String renamedMethodName = mergeRenamePrefix + methodToRename.name;
	methodToRename.name = renamedMethodName;
	
	// make the method private to hide it from the end user
	methodToRename.access = methodToRename.access & (~Opcodes.ACC_PUBLIC & ~Opcodes.ACC_PROTECTED & ~Opcodes.ACC_PRIVATE);
	methodToRename.access = methodToRename.access | Opcodes.ACC_PRIVATE;

	Log.info("Renamed " + originalMethodName + " to " + renamedMethodName);
	
	return originalMethodName; // return the original name
}

Example 3

Source File: StateTrackingClassVisitor.java From scott with MIT License

6 votes

@Override
public void visitEnd() {
	if (instrumentationActions.isJUnit4RuleInjectionRequired) {
		FieldVisitor fv = super.visitField(Opcodes.ACC_PUBLIC, "scottReportingRule", Type.getDescriptor(ScottReportingRule.class), null, null);
		fv.visitAnnotation(Type.getDescriptor(Rule.class), true).visitEnd();
	}

	if (instrumentationActions.isJUnit5ExtensionInjectionRequired) {
		AnnotationVisitor av0 = super.visitAnnotation("Lorg/junit/jupiter/api/extension/ExtendWith;", true);
		AnnotationVisitor av1 = av0.visitArray("value");
		av1.visit(null, Type.getType("Lhu/advancedweb/scott/runtime/ScottJUnit5Extension;"));
		av1.visitEnd();
		av0.visitEnd();
	}

	super.visitEnd();
}

Example 4

Source File: AsmDeltaSpikeProxyClassGenerator.java From deltaspike with Apache License 2.0

6 votes

private static void defineSuperAccessorMethod(ClassWriter cw, java.lang.reflect.Method method, Type superType,
        String superAccessorMethodSuffix) 
{
    Method originalAsmMethod = Method.getMethod(method);
    Method newAsmMethod = new Method(method.getName() + superAccessorMethodSuffix,
            originalAsmMethod.getReturnType(),
            originalAsmMethod.getArgumentTypes());
    GeneratorAdapter mg = new GeneratorAdapter(Opcodes.ACC_PUBLIC, newAsmMethod, null, null, cw);
    
    mg.visitCode();
    
    // call super method
    mg.loadThis();
    mg.loadArgs();
    mg.visitMethodInsn(Opcodes.INVOKESPECIAL,
            superType.getInternalName(),
            method.getName(),
            Type.getMethodDescriptor(method),
            false);
    mg.returnValue();
    
    // finish the method
    mg.endMethod();
    mg.visitMaxs(10, 10);
    mg.visitEnd();
}

Example 5

Source File: GameObjectTypeExtender.java From 07kit with GNU General Public License v3.0

6 votes

private FieldNode injectFieldAndGetter(ClassNode classNode) {
    FieldNode field = new FieldNode(Opcodes.ACC_PUBLIC, "type",
            "L" + GameObjectType.class.getCanonicalName().replaceAll("\\.", "/") + ";", "L" + GameObjectType.class.getCanonicalName().replaceAll("\\.", "/") + ";", null);
    classNode.fields.add(field);

    MethodNode getter = new MethodNode(Opcodes.ACC_PUBLIC, "getType",
            "()L" + GameObjectType.class.getCanonicalName().replaceAll("\\.", "/") + ";", null, null);
    getter.instructions.add(new VarInsnNode(Opcodes.ALOAD, 0));
    getter.instructions.add(new FieldInsnNode(Opcodes.GETFIELD, classNode.name,
            field.name, field.desc));
    getter.instructions.add(new InsnNode(Opcodes.ARETURN));
    getter.visitEnd();
    getter.visitMaxs(1, 1);
    classNode.methods.add(getter);

    return field;
}

Example 6

Source File: Engine.java From JReFrameworker with MIT License

6 votes

private String renameMethod(MethodNode methodToRename) {
	// first remove any annotations from renamed base methods
	AnnotationUtils.clearMethodAnnotations(methodToRename);
	
	// rename the method
	String originalMethodName = methodToRename.name;
	String renamedMethodName = mergeRenamePrefix + methodToRename.name;
	methodToRename.name = renamedMethodName;
	
	// make the method private to hide it from the end user
	methodToRename.access = methodToRename.access & (~Opcodes.ACC_PUBLIC & ~Opcodes.ACC_PROTECTED & ~Opcodes.ACC_PRIVATE);
	methodToRename.access = methodToRename.access | Opcodes.ACC_PRIVATE;

	Log.info("Renamed " + originalMethodName + " to " + renamedMethodName);
	
	return originalMethodName; // return the original name
}

Example 7

Source File: MainAdapter.java From jumbune with GNU Lesser General Public License v3.0

5 votes

/**
 * @see org.jumbune.debugger.instrumentation.adapter.BaseAdapter#visitEnd()
 */
@Override
public void visitEnd() {
	for (Object o : methods) {
		MethodNode mn = (MethodNode) o;

		// finding main method
		if (InstrumentUtil.validateMethodName(mn.name, MAIN_METHOD)
				&& Opcodes.ACC_PUBLIC + Opcodes.ACC_STATIC == mn.access
				&& Type.getMethodDescriptor(Type.VOID_TYPE,
						TYPE_STRING_ARRAY).equals(mn.desc)) {
			LOGGER.debug(MessageFormat.format(InstrumentationMessageLoader
					.getMessage(MessageConstants.MAIN_METHOD_FOUND),
					getClassName()));

			InsnList insnList = mn.instructions;

			InsnList il = new InsnList();
			il.add(loadClasses());

			// insert as first instruction
			insnList.insertBefore(insnList.getFirst(), il);
			break;
		}
		mn.visitMaxs(0, 0);
	}
	accept(cv);
}

Example 8

Source File: ASMReflector.java From meghanada-server with GNU General Public License v3.0

5 votes

private static void readClassIndex(
    Map<ClassIndex, File> indexes, InputStream in, File file, boolean allowSuper)
    throws IOException {

  ClassReader classReader = new ClassReader(in);
  String className = ClassNameUtils.replaceSlash(classReader.getClassName());

  boolean projectOutput = file.isDirectory();

  int access = classReader.getAccess();

  boolean isPublic = (Opcodes.ACC_PUBLIC & access) == Opcodes.ACC_PUBLIC;
  boolean isProtected = (Opcodes.ACC_PROTECTED & access) == Opcodes.ACC_PROTECTED;

  boolean isInterface = (Opcodes.ACC_INTERFACE & access) == Opcodes.ACC_INTERFACE;
  boolean isAnnotation = (Opcodes.ACC_ANNOTATION & access) == Opcodes.ACC_ANNOTATION;

  boolean isSuper = false;

  if (allowSuper) {
    isSuper = (Opcodes.ACC_SUPER & access) == Opcodes.ACC_SUPER;
  }
  if (projectOutput || (isPublic || isProtected || isSuper)) {
    String pkg = ClassNameUtils.getPackage(className);
    boolean onlyClassName = !preloadClassPackages.contains(pkg);
    ClassAnalyzeVisitor classAnalyzeVisitor =
        new ClassAnalyzeVisitor(className, onlyClassName, false);
    classReader.accept(classAnalyzeVisitor, 0);
    ClassIndex classIndex = classAnalyzeVisitor.getClassIndex();
    if (!classIndex.isAnonymous) {
      classIndex.setInterface(isInterface);
      classIndex.setAnnotation(isAnnotation);
      indexes.put(classIndex, file);
      if (!onlyClassName) {
        innerCache.putIfAbsent(className, classAnalyzeVisitor.getMembers());
      }
    }
  }
}

Example 9

Source File: CoverageClassVisitor.java From pitest with Apache License 2.0

5 votes

private void addCoverageProbeField() {

    super.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_FINAL | Opcodes.ACC_PUBLIC
            | Opcodes.ACC_SYNTHETIC, CodeCoverageStore.PROBE_FIELD_NAME, "[Z", null,
        null);

    super.visitField(Opcodes.ACC_STATIC | Opcodes.ACC_FINAL | Opcodes.ACC_PUBLIC
            | Opcodes.ACC_SYNTHETIC, CodeCoverageStore.PROBE_LENGTH_FIELD_NAME, "I",
        null, this.probeCount + 1);

    //If there is no <clinit>, then generate one that sets the probe field directly
    if (!foundClinit) {
      MethodVisitor clinitMv = this.cv
          .visitMethod(Opcodes.ACC_STATIC, "<clinit>", "()V", null, null);
      clinitMv.visitCode();


      pushConstant(clinitMv, this.classId);
      pushConstant(clinitMv, this.probeCount);
      clinitMv
          .visitMethodInsn(Opcodes.INVOKESTATIC, CodeCoverageStore.CLASS_NAME,
              "getOrRegisterClassProbes", "(II)[Z", false);

      clinitMv.visitFieldInsn(Opcodes.PUTSTATIC, className,
          CodeCoverageStore.PROBE_FIELD_NAME, "[Z");
      clinitMv.visitInsn(Opcodes.RETURN);
      clinitMv.visitMaxs(0, 0);
      clinitMv.visitEnd();
    }
  }

Example 10

Source File: Concurnifier.java From Concurnas with MIT License

5 votes

private void addNullCopier(){
      	String rawclsName = currentClass.peek();
	MethodVisitor mv = super.visitMethod(Opcodes.ACC_PUBLIC, "copy", "(Lcom/concurnas/bootstrap/runtime/CopyTracker;Lcom/concurnas/bootstrap/runtime/CopyDefinition;)" + rawclsName, null, null);
      	mv.visitCode();
      	
      	mv.visitInsn(ACONST_NULL);
	mv.visitInsn(ARETURN);
      	
	
	mv.visitMaxs(0, 0); 
	mv.visitEnd();
}

Example 11

Source File: HideAccessTransformer.java From deobfuscator with Apache License 2.0

4 votes

@Override
public boolean transform() throws Throwable {
    decryptionClasses = new HideAccessClassFinder().findNames(classes.values());
    logger.info("Detected the following hide access decryption classes: {}", decryptionClasses);

    vm = TransformerHelper.newVirtualMachine(this);
    prepareVM();

    JavaClass reflectField = JavaClass.forName(vm, "java/lang/reflect/Field");

    int decrypted = 0;

    for (ClassNode classNode : classes.values()) {
        for (MethodNode methodNode : new ArrayList<>(classNode.methods)) {
            InstructionModifier modifier = new InstructionModifier();

            for (AbstractInsnNode insn : TransformerHelper.instructionIterator(methodNode)) {
                InstructionMatcher matcher = Helper.findMatch(insn,
                        HIDE_ACCESS_GETFIELD,
                        HIDE_ACCESS_GETSTATIC,
                        HIDE_ACCESS_PUTFIELD,
                        HIDE_ACCESS_PUTSTATIC,
                        HIDE_ACCESS_INVOKEVIRTUAL,
                        HIDE_ACCESS_INVOKESTATIC_INVOKESPECIAL
                );

                if (matcher == null) {
                    continue;
                }

                InsnList instructions = Constants.HIDE_ACCESS_HANDLERS.get(matcher.getPattern()).apply(this, matcher);
                if (instructions == null) {
                    continue;
                }

                MethodNode decryptorMethod = new MethodNode(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, methodNode.name, "()V", null, null);
                decryptorMethod.instructions.add(instructions);

                captured.set(null);
                classNode.methods.add(decryptorMethod);
                vm.execute(classNode, decryptorMethod, null, Collections.<JavaWrapper>emptyList());
                classNode.methods.remove(decryptorMethod);
                if (captured.get() == null) {
                    throw new WrongTransformerException("Expected non-null java/lang/reflect/*");
                }
                logger.debug("Decrypted {} in {} {}{}", captured.get().asObject().javaToString(), classNode.name, methodNode.name, methodNode.desc);

                modifier.removeAll(matcher.getCapturedInstructions("all"));

                JavaWrapper classObj = captured.get().asObject().getField("clazz", "Ljava/lang/Class;");
                ClassNode reflClass = java_lang_Class.getJavaClass(classObj).getClassNode();
                if (captured.get().getJavaClass() == reflectField) {
                    FieldNode reflField = reflClass.fields.get(captured.get().asObject().getField("slot", "I").asInt());

                    int opcode;
                    if (Modifier.isStatic(reflField.access)) {
                        opcode = matcher.getPattern() == HIDE_ACCESS_GETSTATIC ? GETSTATIC : PUTSTATIC;
                    } else {
                        opcode = matcher.getPattern() == HIDE_ACCESS_GETFIELD ? GETFIELD : PUTFIELD;
                    }

                    InsnList replace = new InsnList();
                    if (opcode == PUTSTATIC || opcode == PUTFIELD) {
                        replace.add(TransformerHelper.unbox(Type.getType(reflField.desc)));
                    }
                    replace.add(new FieldInsnNode(opcode, reflClass.name, reflField.name, reflField.desc));
                    if (opcode == GETSTATIC || opcode == GETFIELD) {
                        replace.add(TransformerHelper.box(Type.getType(reflField.desc)));
                    }

                    modifier.replace(matcher.getEnd(), replace);
                } else {
                    modifier.replace(matcher.getEnd(), convertMethodInvocation(methodNode, matcher.getCapturedInstruction("call"), captured.get()));
                }

                decrypted++;
            }

            modifier.apply(methodNode);
        }
    }

    vm.shutdown();

    logger.info("Decrypted {} hide access instruction", decrypted);
    return true;
}

Example 12

Source File: MissingClassDetector.java From javaide with GNU General Public License v3.0

4 votes

@Override
public void checkClass(@NonNull ClassContext context, @NonNull ClassNode classNode) {
    if (!mHaveClasses && !context.isFromClassLibrary()
            && context.getProject() == context.getMainProject()) {
        mHaveClasses = true;
    }
    String curr = classNode.name;
    if (mReferencedClasses != null && mReferencedClasses.containsKey(curr)) {
        boolean isCustomView = mCustomViews.contains(curr);
        removeReferences(curr);

        // Ensure that the class is public, non static and has a null constructor!

        if ((classNode.access & Opcodes.ACC_PUBLIC) == 0) {
            context.report(INSTANTIATABLE, context.getLocation(classNode), String.format(
                    "This class should be public (%1$s)",
                        ClassContext.createSignature(classNode.name, null, null)));
            return;
        }

        if (classNode.name.indexOf('$') != -1 && !LintUtils.isStaticInnerClass(classNode)) {
            context.report(INSTANTIATABLE, context.getLocation(classNode), String.format(
                    "This inner class should be static (%1$s)",
                        ClassContext.createSignature(classNode.name, null, null)));
            return;
        }

        boolean hasDefaultConstructor = false;
        @SuppressWarnings("rawtypes") // ASM API
        List methodList = classNode.methods;
        for (Object m : methodList) {
            MethodNode method = (MethodNode) m;
            if (method.name.equals(CONSTRUCTOR_NAME)) {
                if (method.desc.equals("()V")) { //$NON-NLS-1$
                    // The constructor must be public
                    if ((method.access & Opcodes.ACC_PUBLIC) != 0) {
                        hasDefaultConstructor = true;
                    } else {
                        context.report(INSTANTIATABLE, context.getLocation(method, classNode),
                                "The default constructor must be public");
                        // Also mark that we have a constructor so we don't complain again
                        // below since we've already emitted a more specific error related
                        // to the default constructor
                        hasDefaultConstructor = true;
                    }
                }
            }
        }

        if (!hasDefaultConstructor && !isCustomView && !context.isFromClassLibrary()
                && context.getProject().getReportIssues()) {
            context.report(INSTANTIATABLE, context.getLocation(classNode), String.format(
                    "This class should provide a default constructor (a public " +
                    "constructor with no arguments) (%1$s)",
                        ClassContext.createSignature(classNode.name, null, null)));
        }
    }
}

Example 13

Source File: PanacheRepositoryEnhancer.java From quarkus with Apache License 2.0

4 votes

private void generateModelBridge(MethodInfo method, AnnotationValue targetReturnTypeErased) {
    String descriptor = AsmUtil.getDescriptor(method, name -> typeArguments.get(name));
    // JpaOperations erases the Id type to Object
    String descriptorForJpaOperations = AsmUtil.getDescriptor(method,
            name -> name.equals("Entity") ? entitySignature : null);
    String signature = AsmUtil.getSignature(method, name -> typeArguments.get(name));
    List<org.jboss.jandex.Type> parameters = method.parameters();

    String castTo = null;
    if (targetReturnTypeErased != null && targetReturnTypeErased.asBoolean()) {
        org.jboss.jandex.Type type = method.returnType();
        if (type.kind() == Kind.TYPE_VARIABLE &&
                type.asTypeVariable().identifier().equals("Entity")) {
            castTo = entityBinaryType;
        }
        if (castTo == null)
            castTo = type.name().toString('/');
    }

    // Note: we can't use SYNTHETIC here because otherwise Mockito will never mock these methods
    MethodVisitor mv = super.visitMethod(Opcodes.ACC_PUBLIC,
            method.name(),
            descriptor,
            signature,
            null);
    for (int i = 0; i < parameters.size(); i++) {
        mv.visitParameter(method.parameterName(i), 0 /* modifiers */);
    }
    mv.visitCode();
    injectModel(mv);
    for (int i = 0; i < parameters.size(); i++) {
        mv.visitIntInsn(Opcodes.ALOAD, i + 1);
    }
    // inject Class
    String forwardingDescriptor = "(" + getModelDescriptor() + descriptorForJpaOperations.substring(1);
    if (castTo != null) {
        // return type is erased to Object
        int lastParen = forwardingDescriptor.lastIndexOf(')');
        forwardingDescriptor = forwardingDescriptor.substring(0, lastParen + 1) + "Ljava/lang/Object;";
    }
    mv.visitMethodInsn(Opcodes.INVOKESTATIC,
            getPanacheOperationsBinaryName(),
            method.name(),
            forwardingDescriptor, false);
    if (castTo != null)
        mv.visitTypeInsn(Opcodes.CHECKCAST, castTo);
    String returnTypeDescriptor = descriptor.substring(descriptor.lastIndexOf(")") + 1);
    mv.visitInsn(AsmUtil.getReturnInstruction(returnTypeDescriptor));
    mv.visitMaxs(0, 0);
    mv.visitEnd();
}

Example 14

Source File: Field.java From OSRS-Deobfuscator with BSD 2-Clause "Simplified" License

4 votes

public boolean isPublic()
{
	return (accessFlags & Opcodes.ACC_PUBLIC) != 0;
}

Example 15

Source File: Engine.java From JReFrameworker with MIT License

4 votes

@SuppressWarnings("unused")
private static String getAccessModifiers(int access){
	LinkedList<String> modifiers = new LinkedList<String>();
	if((Opcodes.ACC_ABSTRACT & access) == Opcodes.ACC_ABSTRACT){
		modifiers.add("abstract");
	}
	if((Opcodes.ACC_ANNOTATION & access) == Opcodes.ACC_ANNOTATION){
		modifiers.add("annotation");
	}
	if((Opcodes.ACC_BRIDGE & access) == Opcodes.ACC_BRIDGE){
		modifiers.add("bridge");
	}
	if((Opcodes.ACC_DEPRECATED & access) == Opcodes.ACC_DEPRECATED){
		modifiers.add("deprecated");
	}
	if((Opcodes.ACC_ENUM & access) == Opcodes.ACC_ENUM){
		modifiers.add("enum");
	}
	if((Opcodes.ACC_FINAL & access) == Opcodes.ACC_FINAL){
		modifiers.add("final");
	}
	if((Opcodes.ACC_INTERFACE & access) == Opcodes.ACC_INTERFACE){
		modifiers.add("interface");
	}
	if((Opcodes.ACC_MANDATED & access) == Opcodes.ACC_MANDATED){
		modifiers.add("mandated");
	}
	if((Opcodes.ACC_NATIVE & access) == Opcodes.ACC_NATIVE){
		modifiers.add("native");
	}
	if((Opcodes.ACC_PRIVATE & access) == Opcodes.ACC_PRIVATE){
		modifiers.add("private");
	}
	if((Opcodes.ACC_PROTECTED & access) == Opcodes.ACC_PROTECTED){
		modifiers.add("protected");
	}
	if((Opcodes.ACC_PUBLIC & access) == Opcodes.ACC_PUBLIC){
		modifiers.add("public");
	}
	if((Opcodes.ACC_STATIC & access) == Opcodes.ACC_STATIC){
		modifiers.add("static");
	}
	if((Opcodes.ACC_STRICT & access) == Opcodes.ACC_STRICT){
		modifiers.add("strict");
	}
	if((Opcodes.ACC_SUPER & access) == Opcodes.ACC_SUPER){
		modifiers.add("super");
	}
	if((Opcodes.ACC_SYNCHRONIZED & access) == Opcodes.ACC_SYNCHRONIZED){
		modifiers.add("synchronized");
	}
	if((Opcodes.ACC_SYNTHETIC & access) == Opcodes.ACC_SYNTHETIC){
		modifiers.add("synthetic");
	}
	if((Opcodes.ACC_TRANSIENT & access) == Opcodes.ACC_TRANSIENT){
		modifiers.add("transient");
	}
	if((Opcodes.ACC_VARARGS & access) == Opcodes.ACC_VARARGS){
		modifiers.add("varargs");
	}
	if((Opcodes.ACC_VOLATILE & access) == Opcodes.ACC_VOLATILE){
		modifiers.add("volatile");
	}
	return modifiers.toString();
}

Example 16

Source File: JumpTest.java From obfuscator with MIT License

4 votes

@Before
    public void generateClass() throws NoSuchMethodException, InvocationTargetException, IllegalAccessException, ClassNotFoundException, IOException {
        Class.forName(JObfImpl.class.getCanonicalName());
        InsnList methodInsns = new InsnList();

        ClassNode classNode = new ClassNode();
        classNode.name = "Test";
        classNode.access = Opcodes.ACC_PUBLIC;
        classNode.version = 52;
        classNode.superName = "java/lang/Object";

        MethodNode methodNode = new MethodNode(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "test", "()V", null, new String[0]);

        for (int i1 = 0; i1 < 10; i1++) {
            for (int i = 0; i <= 13; i++) {
                LabelNode end = new LabelNode(new Label());
                methodInsns.add(FlowObfuscator.generateIfGoto(i, end));
                methodInsns.add(new TypeInsnNode(Opcodes.NEW, "java/lang/RuntimeException"));
                methodInsns.add(new InsnNode(Opcodes.DUP));
                methodInsns.add(new LdcInsnNode("JumpGenerator row=" + i1 + " id=" + i + " failed"));
                methodInsns.add(new MethodInsnNode(Opcodes.INVOKESPECIAL, "java/lang/RuntimeException", "<init>", "(Ljava/lang/String;)V", false));
                methodInsns.add(new InsnNode(Opcodes.ATHROW));
                methodInsns.add(end);
//            methodInsns.add(new FrameNode(Opcodes.F_SAME, 0, null, 0, null));
            }
        }
        methodInsns.add(new InsnNode(Opcodes.RETURN));


        methodNode.instructions = methodInsns;
        methodNode.visitEnd();


        classNode.methods.add(methodNode);

        ModifiedClassWriter writer = new ModifiedClassWriter(ModifiedClassWriter.COMPUTE_FRAMES);

        classNode.accept(writer);

        writer.visitEnd();

        byte[] bytes = writer.toByteArray();

        Files.write(bytes, File.createTempFile("JumpTestClass", ".class"));

        Class<?> classLoaderClass = ClassLoader.class;

        Method defineClass = classLoaderClass.getDeclaredMethod("defineClass", byte[].class, int.class, int.class);
        defineClass.setAccessible(true);

        generatedClass = (Class) defineClass.invoke(getClass().getClassLoader(), bytes, 0, bytes.length);
    }

Example 17

Source File: MaybeContinuableClassVisitor.java From tascalate-javaflow with Apache License 2.0

4 votes

@Override
public MethodVisitor visitMethod(int access, final String name, final String desc, String signature, String[] exceptions) {
    if (isAnnotation) {
        return null;
    }

    boolean isSynthetic = (access & Opcodes.ACC_SYNTHETIC) != 0;
    boolean isPackagePrivate = (access & (Opcodes.ACC_PRIVATE | Opcodes.ACC_PUBLIC | Opcodes.ACC_PROTECTED)) == 0;
    if (isSynthetic) {
        final boolean isAccessor = isPackagePrivate && name.startsWith("access$") && (access & Opcodes.ACC_STATIC) != 0;
        final boolean isBridge = (access & Opcodes.ACC_BRIDGE) != 0;
        if (isAccessor || isBridge) {
            return new MethodVisitor(this.api) {
                @Override
                public void visitMethodInsn(int opcode, String owner, String targetName, String targetDesc) {
                    if (selfclass.equals(owner)) {
                        if (isAccessor) {
                            actual2accessor.put(targetName + targetDesc, name + desc);
                        }
                        if (isBridge) {
                            bridge2specialization.put(name + desc, targetName + targetDesc);
                        }
                    }
                }
            };
        }
    }

    // If this method is desugared lambda body
    if ( isSynthetic && isPackagePrivate && name.startsWith("lambda$") ) {
        // RetroLambda desugars method body to package private
        desugaredLambdaBodies.add(name + desc);
        return null;
    }

    return new MethodVisitor(this.api) {

        private boolean methodContinuableAnnotationFound = false;

        @Override
        public AnnotationVisitor visitAnnotation(String description, boolean visible) {
            if (!methodContinuableAnnotationFound) {
                methodContinuableAnnotationFound = cciResolver.isContinuableAnnotation(description);
            }
            return null;
        }

        @Override 
        public void visitEnd() {
            if (methodContinuableAnnotationFound) {
                continuableMethods.add(name + desc);
            }
        }

    };
}

Example 18

Source File: IncrementalSupportVisitor.java From AnoleFix with MIT License

3 votes

/**
 * If a method/field is not private, make it public. This is to workaround the fact
 * <ul>Our restart.dex files are loaded with a different class loader than the main dex file
 * class loader on restart. so we need methods/fields to be public</ul>
 * <ul>Our reload.dex are loaded from a different class loader as well but methods/fields
 * are accessed through reflection, yet you need class visibility.</ul>
 * <p>
 * remember that in Java, protected methods or fields can be acessed by classes in the same
 * package :
 * {@see https://docs.oracle.com/javase/tutorial/java/javaOO/accesscontrol.html}
 *
 * @param access the original class/method/field access.
 * @return the new access or the same one depending on the original access rights.
 */
private static int transformAccessForInstantRun(int access) {
    AccessRight accessRight = AccessRight.fromNodeAccess(access);
    if (accessRight != AccessRight.PRIVATE) {
        access &= ~Opcodes.ACC_PROTECTED;
        access &= ~Opcodes.ACC_PRIVATE;
        return access | Opcodes.ACC_PUBLIC;
    }
    return access;
}

Example 19

Source File: IncrementalSupportVisitor.java From AnoleFix with MIT License

2 votes

/**
 * If a class is package private, make it public so instrumented code living in a different
 * class loader can instantiate them.
 *
 * @param access the original class/method/field access.
 * @return the new access or the same one depending on the original access rights.
 */
private static int transformClassAccessForInstantRun(int access) {
    AccessRight accessRight = AccessRight.fromNodeAccess(access);
    return accessRight == AccessRight.PACKAGE_PRIVATE ? access | Opcodes.ACC_PUBLIC : access;
}

Example 20

Source File: ClassHelper.java From groovy with Apache License 2.0

2 votes

/**
 * Creates a ClassNode using a given class.
 * Unlike make(String) this method will not use the cache
 * to create the ClassNode. This means the ClassNode created
 * from this method using the same name will have a different
 * reference
 *
 * @param name of the class the ClassNode is representing
 * @see #make(String)
 */
public static ClassNode makeWithoutCaching(String name) {
    ClassNode cn = new ClassNode(name, Opcodes.ACC_PUBLIC, OBJECT_TYPE);
    cn.isPrimaryNode = false;
    return cn;
}