Example usage for org.objectweb.asm Opcodes ACC_BRIDGE

Introduction

In this page you can find the example usage for org.objectweb.asm Opcodes ACC_BRIDGE.

Prototype

int ACC_BRIDGE

To view the source code for org.objectweb.asm Opcodes ACC_BRIDGE.

Click Source Link

Usage

From source file:de.unisb.cs.st.javalanche.mutation.bytecodeMutations.MutationsCollectorClassAdapter.java

License:Open Source License

public MethodVisitor visitMethod(int access, String name, String desc, String signature,
        final String[] exceptions) {
    MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);
    if ((access & Opcodes.ACC_SYNTHETIC) > 0 || (access & Opcodes.ACC_BRIDGE) > 0 || name.equals("<clinit>")) {
        return mv;
    }//  w ww. jav  a 2  s  . c o m
    if (debug) {
        mv = new CheckMethodAdapter(mv);
    }
    JavalancheConfiguration configuration = ConfigurationLocator.getJavalancheConfiguration();
    if (configuration.enableMutationType(REPLACE_CONSTANT)) {
        mv = new PossibilitiesRicMethodAdapter(mv, className, name, mpc, ricPossibilities, desc);
    }
    if (configuration.enableMutationType(NEGATE_JUMP)) {
        mv = new NegateJumpsPossibilitiesMethodAdapter(mv, className, name, mpc, negatePossibilities, desc);
    }
    if (configuration.enableMutationType(ARITHMETIC_REPLACE)) {
        mv = new PossibilitiesArithmeticReplaceMethodAdapter(mv, className, name, mpc, arithmeticPossibilities,
                desc);
    }
    if (configuration.enableMutationType(REMOVE_CALL)) {
        mv = new RemoveCallsPossibilitiesMethodAdapter(new MyAdviceAdapter(mv, access, name, desc), className,
                name, mpc, removeCallsPossibilities, desc);
    }
    if (configuration.enableMutationType(REPLACE_VARIABLE)) {
        ReplaceVariablesPossibilitiesMethodAdapter rvAdapter = new ReplaceVariablesPossibilitiesMethodAdapter(
                mv, className, name, mpc, replaceVariablesPossibilities, desc,
                projectVariables.getStaticVariables(className), projectVariables.getClassVariables(className));
        mv = rvAdapter;
        AnalyzerAdapter analyzerAdapter = new AnalyzerAdapter(className, access, name, desc, mv);
        rvAdapter.setAnlyzeAdapter(analyzerAdapter);
        mv = analyzerAdapter;
    }
    if (configuration.enableMutationType(ABSOLUTE_VALUE)) {
        mv = new AbsoluteValuePossibilitiesAdapter(mv, className, name, absoluteValuePossibilities, desc, mpc);
    }
    if (configuration.enableMutationType(UNARY_OPERATOR)) {
        mv = new UnaryOperatorPossibilitiesAdapter(mv, className, name, unaryOperatorPossibilities, desc, mpc);
    }

    if (configuration.enableMutationType(MONITOR_REMOVE)) {
        mv = new MonitorRemovePossibilitiesMethodAdapter(mv, className, name, mpc, monitorPossibilities, desc);
    }
    if (configuration.enableMutationType(REPLACE_THREAD_CALL)) {
        mv = new ReplaceThreadCallsPossibilitiesMethodAdapter(new ReplaceAdviceAdapter(mv, access, name, desc),
                className, name, mpc, replaceThreadCallsPossibilities, desc);
    }
    return mv;
}

---

From source file:erjang.ETuple.java

License:Apache License

private static void make_blank_bridge(ClassAdapter cw, String this_class_name, String super_class_name) {
    MethodVisitor mv;/*from w  w  w  .java 2 s. c  om*/
    mv = cw.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_SYNTHETIC | Opcodes.ACC_BRIDGE, "blank",
            "()L" + super_class_name + ";", null, null);
    mv.visitCode();
    mv.visitVarInsn(Opcodes.ALOAD, 0);
    mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, this_class_name, "blank", "()L" + this_class_name + ";");
    mv.visitInsn(Opcodes.ARETURN);
    mv.visitMaxs(1, 1);
    mv.visitEnd();
}

---

From source file:gnu.classpath.tools.javah.MethodHelper.java

License:Open Source License

public static String getBridgeTarget(MethodNode meth) {
    if ((meth.access & Opcodes.ACC_BRIDGE) == 0)
        return null;
    Iterator i = meth.instructions.iterator();
    while (i.hasNext()) {
        AbstractInsnNode insn = (AbstractInsnNode) i.next();
        if (!(insn instanceof MethodInsnNode))
            continue;
        return ((MethodInsnNode) insn).desc;
    }/*from   www .  j  av  a  2s  . c o  m*/
    return null;
}

---

From source file:graph.Modifier.java

License:Apache License

/**
 * Returns an integer bit field for the EnumSet, where the bit values are
 * defined as in the class file format.//from  w w w .j  a va2s  .  c  o m
 *
 * @param  set   Set of modifiers to convert to a bit field.
 * @return       Integer bit field.
 */
public static int getBitField(EnumSet<Modifier> set) {
    int access = 0;

    if (set.contains(PUBLIC)) {
        access |= Opcodes.ACC_PUBLIC;
    }

    if (set.contains(PROTECTED)) {
        access |= Opcodes.ACC_PROTECTED;
    }

    if (set.contains(PRIVATE)) {
        access |= Opcodes.ACC_PRIVATE;
    }

    if (set.contains(STATIC)) {
        access |= Opcodes.ACC_STATIC;
    }

    if (set.contains(FINAL)) {
        access |= Opcodes.ACC_FINAL;
    }

    if (set.contains(SUPER)) {
        access |= Opcodes.ACC_SUPER;
    }

    if (set.contains(INTERFACE)) {
        access |= Opcodes.ACC_INTERFACE;
    }

    if (set.contains(ABSTRACT)) {
        access |= Opcodes.ACC_ABSTRACT;
    }

    if (set.contains(SYNTHETIC)) {
        access |= Opcodes.ACC_SYNTHETIC;
    }

    if (set.contains(ANNOTATION)) {
        access |= Opcodes.ACC_ANNOTATION;
    }

    if (set.contains(ENUM)) {
        access |= Opcodes.ACC_ENUM;
    }

    if (set.contains(VOLATILE)) {
        access |= Opcodes.ACC_VOLATILE;
    }

    if (set.contains(TRANSIENT)) {
        access |= Opcodes.ACC_TRANSIENT;
    }

    if (set.contains(SYNCHRONIZED)) {
        access |= Opcodes.ACC_SYNCHRONIZED;
    }

    if (set.contains(BRIDGE)) {
        access |= Opcodes.ACC_BRIDGE;
    }

    if (set.contains(VARARGS)) {
        access |= Opcodes.ACC_VARARGS;
    }

    if (set.contains(NATIVE)) {
        access |= Opcodes.ACC_NATIVE;
    }

    return access;
}

---

From source file:graph.Modifier.java

License:Apache License

/**
 * Returns an EnumSet of the modifiers, based on the given bit field (where
 * the bit values are defined as in the class file format).
 *
 * @param access Integer bit field giving access modifiers.
 * @return       Set of modifiers.//from w ww .j av a  2  s.c  o  m
 */
public static EnumSet<Modifier> getSet(int access) {
    EnumSet<Modifier> modifiers = EnumSet.noneOf(Modifier.class);

    if ((access & Opcodes.ACC_PUBLIC) != 0) {
        modifiers.add(Modifier.PUBLIC);
    }

    if ((access & Opcodes.ACC_PROTECTED) != 0) {
        modifiers.add(Modifier.PROTECTED);
    }

    if ((access & Opcodes.ACC_PRIVATE) != 0) {
        modifiers.add(Modifier.PRIVATE);
    }

    if ((access & Opcodes.ACC_STATIC) != 0) {
        modifiers.add(Modifier.STATIC);
    }

    if ((access & Opcodes.ACC_FINAL) != 0) {
        modifiers.add(Modifier.FINAL);
    }

    if ((access & Opcodes.ACC_SUPER) != 0) {
        modifiers.add(Modifier.SUPER);
    }

    if ((access & Opcodes.ACC_INTERFACE) != 0) {
        modifiers.add(Modifier.INTERFACE);
    }

    if ((access & Opcodes.ACC_ABSTRACT) != 0) {
        modifiers.add(Modifier.ABSTRACT);
    }

    if ((access & Opcodes.ACC_SYNTHETIC) != 0) {
        modifiers.add(Modifier.SYNTHETIC);
    }

    if ((access & Opcodes.ACC_ANNOTATION) != 0) {
        modifiers.add(Modifier.ANNOTATION);
    }

    if ((access & Opcodes.ACC_ENUM) != 0) {
        modifiers.add(Modifier.ENUM);
    }

    if ((access & Opcodes.ACC_VOLATILE) != 0) {
        modifiers.add(Modifier.VOLATILE);
    }

    if ((access & Opcodes.ACC_TRANSIENT) != 0) {
        modifiers.add(Modifier.TRANSIENT);
    }

    if ((access & Opcodes.ACC_SYNCHRONIZED) != 0) {
        modifiers.add(Modifier.SYNCHRONIZED);
    }

    if ((access & Opcodes.ACC_BRIDGE) != 0) {
        modifiers.add(Modifier.BRIDGE);
    }

    if ((access & Opcodes.ACC_VARARGS) != 0) {
        modifiers.add(Modifier.VARARGS);
    }

    if ((access & Opcodes.ACC_NATIVE) != 0) {
        modifiers.add(Modifier.NATIVE);
    }

    if ((access & Opcodes.ACC_STRICT) != 0) {
        modifiers.add(Modifier.STRICT);
    }

    return modifiers;
}

---

From source file:jp.co.dgic.testing.common.virtualmock.asm2x.AsmClassVisitor2x.java

License:Open Source License

public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {

    boolean isStatic = false;
    if ((access & Opcodes.ACC_STATIC) > 0) {
        isStatic = true;/*from  w ww  .  ja va 2  s.c o  m*/
    }

    InternalMockObjectManager.printConsole("#################################################################");
    InternalMockObjectManager.printConsole("#################################################################");
    InternalMockObjectManager
            .printConsole("### " + access + (isStatic ? " static " : " ") + name + " " + signature);
    InternalMockObjectManager.printConsole("#################################################################");
    InternalMockObjectManager.printConsole("#################################################################");

    MethodVisitor mv = super.visitMethod(access, name, desc, signature, exceptions);

    // is abstract or native
    if ((access & Opcodes.ACC_ABSTRACT) > 0)
        return mv;
    if ((access & Opcodes.ACC_NATIVE) > 0)
        return mv;
    if ((access & Opcodes.ACC_BRIDGE) > 0)
        return mv;

    int maxLocals = acc.getMaxLocals(name, desc);

    return createMethodVisitor(mv, name, desc, signature, isStatic, exceptions, maxLocals);
}

---

From source file:net.sf.cglib.proxy.TestEnhancer.java

License:Apache License

public void testBridgeParameterCheckcast() throws Exception {

    // If the compiler used for Z omits the bridge method, and X is compiled with javac,
    // javac will generate an invokespecial bridge in X.

    // public interface I<A, B> {
    //   public A f(B b);
    // }/*www . j ava2 s.c  om*/
    // public abstract class Z<U extends Number> implements I<U, Long> {
    //   public U f(Long id) {
    //     return null;
    //   }
    // }
    // public class X extends Z<Integer> {}

    final Map<String, byte[]> classes = new HashMap<String, byte[]>();

    {
        ClassWriter cw = new ClassWriter(0);
        cw.visit(49, Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT | Opcodes.ACC_INTERFACE, "I",
                "<A:Ljava/lang/Object;B:Ljava/lang/Object;>Ljava/lang/Object;", "java/lang/Object", null);
        {
            MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_ABSTRACT, "f",
                    "(Ljava/lang/Object;)Ljava/lang/Object;", "(TB;)TA;", null);
            mv.visitEnd();
        }
        cw.visitEnd();
        classes.put("I.class", cw.toByteArray());
    }
    {
        ClassWriter cw = new ClassWriter(0);
        cw.visit(49, Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER | Opcodes.ACC_ABSTRACT, "Z",
                "<U:Ljava/lang/Number;>Ljava/lang/Object;LI<TU;Ljava/lang/String;>;", "java/lang/Object",
                new String[] { "I" });
        {
            MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
            mv.visitCode();
            mv.visitVarInsn(Opcodes.ALOAD, 0);
            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/Object", "<init>", "()V", false);
            mv.visitInsn(Opcodes.RETURN);
            mv.visitMaxs(1, 1);
            mv.visitEnd();
        }
        {
            MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "f", "(Ljava/lang/String;)Ljava/lang/Number;",
                    "(Ljava/lang/String;)TU;", null);
            mv.visitCode();
            mv.visitInsn(Opcodes.ACONST_NULL);
            mv.visitInsn(Opcodes.ARETURN);
            mv.visitMaxs(1, 2);
            mv.visitEnd();
        }
        cw.visitEnd();
        classes.put("Z.class", cw.toByteArray());
    }
    {
        ClassWriter cw = new ClassWriter(0);
        cw.visit(49, Opcodes.ACC_PUBLIC | Opcodes.ACC_SUPER, "X", "LZ<Ljava/lang/Integer;>;", "Z", null);
        {
            MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC, "<init>", "()V", null, null);
            mv.visitCode();
            mv.visitVarInsn(Opcodes.ALOAD, 0);
            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "Z", "<init>", "()V", false);
            mv.visitInsn(Opcodes.RETURN);
            mv.visitMaxs(1, 1);
            mv.visitEnd();
        }
        {
            MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_BRIDGE | Opcodes.ACC_SYNTHETIC,
                    "f", "(Ljava/lang/Object;)Ljava/lang/Object;", null, null);
            mv.visitCode();
            mv.visitVarInsn(Opcodes.ALOAD, 0);
            mv.visitVarInsn(Opcodes.ALOAD, 1);
            mv.visitTypeInsn(Opcodes.CHECKCAST, "java/lang/String");
            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, "Z", "f", "(Ljava/lang/String;)Ljava/lang/Number;",
                    false);
            mv.visitInsn(Opcodes.ARETURN);
            mv.visitMaxs(2, 2);
            mv.visitEnd();
        }

        cw.visitEnd();

        classes.put("X.class", cw.toByteArray());
    }

    ClassLoader classLoader = new ClassLoader(getClass().getClassLoader()) {
        @Override
        public InputStream getResourceAsStream(String name) {
            InputStream is = super.getResourceAsStream(name);
            if (is != null) {
                return is;
            }
            if (classes.containsKey(name)) {
                return new ByteArrayInputStream(classes.get(name));
            }
            return null;
        }

        public Class findClass(String name) throws ClassNotFoundException {
            byte[] ba = classes.get(name.replace('.', '/') + ".class");
            if (ba != null) {
                return defineClass(name, ba, 0, ba.length);
            }
            throw new ClassNotFoundException(name);
        }
    };

    List<Class> retTypes = new ArrayList<Class>();
    List<Class> paramTypes = new ArrayList<Class>();
    Interceptor interceptor = new Interceptor(retTypes, paramTypes);

    Enhancer e = new Enhancer();
    e.setClassLoader(classLoader);
    e.setSuperclass(classLoader.loadClass("X"));
    e.setCallback(interceptor);

    Object c = e.create();

    for (Method m : c.getClass().getDeclaredMethods()) {
        if (m.getName().equals("f") && m.getReturnType().equals(Object.class)) {
            m.invoke(c, new Object[] { null });
        }
    }

    // f(Object)Object should bridge to f(Number)String
    assertEquals(Arrays.asList(Object.class, Number.class), retTypes);
    assertEquals(Arrays.asList(Object.class, String.class), paramTypes);
}

---

From source file:org.adjective.stout.writer.ByteCodeWriter.java

License:Apache License

private int getModifierCode(Set<ElementModifier> modifiers, MemberType type) {
    int code = getModifierCode(modifiers, (Sort) null);
    int illegal = Opcodes.ACC_ANNOTATION | Opcodes.ACC_BRIDGE | Opcodes.ACC_ENUM | Opcodes.ACC_INTERFACE
            | Opcodes.ACC_SUPER;// ww  w .j a va 2 s  .c  om
    switch (type) {
    case FIELD:
        illegal |= Opcodes.ACC_ABSTRACT | Opcodes.ACC_NATIVE | Opcodes.ACC_STRICT | Opcodes.ACC_SYNCHRONIZED;
        break;
    case METHOD:
        if (isBitSet(Opcodes.ACC_ABSTRACT, code)) {
            illegal |= Opcodes.ACC_NATIVE | Opcodes.ACC_STRICT | Opcodes.ACC_SYNCHRONIZED | Opcodes.ACC_STATIC
                    | Opcodes.ACC_FINAL;
        }
        break;
    }
    if (isBitSet(illegal, code)) {
        throw new IllegalStateException(
                "Illegal combination of modifier codes: " + code + " (illegal codes: " + illegal + ")");
    }
    return code;
}

---

From source file:org.codehaus.groovy.transform.stc.StaticTypeCheckingVisitor.java

License:Apache License

private List<MethodNode> disambiguateMethods(List<MethodNode> methods, final ClassNode receiver,
        final ClassNode[] argTypes, final Expression call) {
    if (methods.size() > 1 && receiver != null && argTypes != null) {
        List<MethodNode> filteredWithGenerics = new LinkedList<>();
        for (MethodNode methodNode : methods) {
            if (typeCheckMethodsWithGenerics(receiver, argTypes, methodNode)) {
                if ((methodNode.getModifiers() & Opcodes.ACC_BRIDGE) == 0) {
                    filteredWithGenerics.add(methodNode);
                }//  ww  w .  j  a  v a 2  s.c  o m
            }
        }
        if (filteredWithGenerics.size() == 1) {
            return filteredWithGenerics;
        }
        methods = extension.handleAmbiguousMethods(methods, call);
    }

    if (methods.size() > 1) {
        if (call instanceof MethodCall) {
            List<MethodNode> methodNodeList = new LinkedList<>();

            String methodName = ((MethodCall) call).getMethodAsString();

            for (MethodNode methodNode : methods) {
                if (!methodNode.getName().equals(methodName)) {
                    continue;
                }
                methodNodeList.add(methodNode);
            }

            methods = methodNodeList;
        }
    }

    return methods;
}

---

From source file:org.evosuite.graphs.cfg.CFGClassAdapter.java

License:Open Source License

/** {@inheritDoc} */
@Override//from w  w w  . j  a  v  a2s.c  om
public MethodVisitor visitMethod(int methodAccess, String name, String descriptor, String signature,
        String[] exceptions) {

    MethodVisitor mv = super.visitMethod(methodAccess, name, descriptor, signature, exceptions);
    mv = new JSRInlinerAdapter(mv, methodAccess, name, descriptor, signature, exceptions);

    if ((methodAccess & Opcodes.ACC_SYNTHETIC) != 0 || (methodAccess & Opcodes.ACC_BRIDGE) != 0) {
        return mv;
    }

    // We ignore deprecated only for dependencies, not for the SUT
    //      if (!Properties.USE_DEPRECATED
    //              && (methodAccess & Opcodes.ACC_DEPRECATED) == Opcodes.ACC_DEPRECATED) {
    //         logger.info("Skipping deprecated method " + name);
    //         return mv;
    //      }

    if (isEnum) {
        if (name.equals("valueOf") || name.equals("values")) {
            logger.info("Skipping enum valueOf");
            return mv;
        }
        if (name.equals("<init>") && descriptor.equals("(Ljava/lang/String;I)V")) {
            logger.info("Skipping enum default constructor");
            return mv;
        }
    }

    logger.info("Analyzing CFG of " + className);

    String classNameWithDots = ResourceList.getClassNameFromResourcePath(className);

    mv = new CFGMethodAdapter(classLoader, classNameWithDots, methodAccess, name, descriptor, signature,
            exceptions, mv);
    return mv;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• »