Example usage for org.objectweb.asm Opcodes ACC_STATIC

Introduction

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

Prototype

int ACC_STATIC

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

Click Source Link

Usage

From source file:org.evosuite.instrumentation.mutation.ReplaceVariable.java

License:Open Source License

private Map<String, InsnList> getFieldReplacements(MethodNode mn, String className, String desc,
        AbstractInsnNode node) {//  w  w  w.j av  a2  s.  c  om
    Map<String, InsnList> alternatives = new HashMap<String, InsnList>();

    boolean isStatic = (mn.access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC;

    String otherName = "";
    if (node instanceof FieldInsnNode) {
        FieldInsnNode fNode = (FieldInsnNode) node;
        otherName = fNode.name;
    }
    try {
        logger.info("Checking class " + className);
        Class<?> clazz = Class.forName(className, false, ReplaceVariable.class.getClassLoader());

        for (Field field : TestClusterUtils.getFields(clazz)) {
            // We have to use a special version of canUse to avoid
            // that we access the CUT before it is fully initialised
            if (!canUse(field))
                continue;

            Type type = Type.getType(field.getType());
            logger.info("Checking replacement field variable " + field.getName());

            if (field.getName().equals(otherName))
                continue;

            if (isStatic && !(Modifier.isStatic(field.getModifiers())))
                continue;

            if (type.getDescriptor().equals(desc)) {
                logger.info("Adding replacement field variable " + field.getName());
                InsnList list = new InsnList();
                if (node.getOpcode() == Opcodes.GETFIELD) {
                    list.add(new InsnNode(Opcodes.POP)); // Remove field owner from stack
                }

                // new fieldinsnnode
                if (Modifier.isStatic(field.getModifiers()))
                    list.add(new FieldInsnNode(Opcodes.GETSTATIC, className.replace('.', '/'), field.getName(),
                            type.getDescriptor()));
                else {
                    list.add(new VarInsnNode(Opcodes.ALOAD, 0)); // this
                    list.add(new FieldInsnNode(Opcodes.GETFIELD, className.replace('.', '/'), field.getName(),
                            type.getDescriptor()));
                }
                alternatives.put(field.getName(), list);
            } else {
                logger.info("Descriptor does not match: " + field.getName() + " - " + type.getDescriptor());
            }
        }
    } catch (Throwable t) {
        logger.info("Class not found: " + className);
        // TODO Auto-generated catch block
        //e.printStackTrace();
    }
    return alternatives;
}

---

From source file:org.evosuite.instrumentation.testability.BooleanTestabilityTransformation.java

License:Open Source License

/**
 * Apply testability transformation to an individual method
 * // w  w w  .  java 2 s  .c o m
 * @param mn
 */
private void transformMethod(MethodNode mn) {
    logger.info("Transforming method " + mn.name + mn.desc);

    //currentCFG = GraphPool.getActualCFG(className, mn.name + mn.desc);

    // TODO: Skipping interfaces for now, but will need to handle Booleans in interfaces!
    if ((mn.access & Opcodes.ACC_ABSTRACT) == Opcodes.ACC_ABSTRACT)
        return;

    String origDesc = getOriginalDesc(className, mn.name, mn.desc);
    logger.info("Analyzing " + mn.name + " for TT, signature " + origDesc + "/" + mn.desc);
    try {
        Analyzer a = new Analyzer(
                new BooleanValueInterpreter(origDesc, (mn.access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC));
        a.analyze(className, mn);
        currentFrames = a.getFrames();
    } catch (Exception e) {
        logger.info("1. Error during analysis: " + e);
        //e.printStackTrace();
        // TODO: Handle error
    }
    generateCDG(mn);
    currentMethodNode = mn;
    // First expand ifs without else/*
    new ImplicitElseTransformer(this).transform(mn);
    try {
        Analyzer a = new Analyzer(
                new BooleanValueInterpreter(origDesc, (mn.access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC));
        a.analyze(className, mn);
        currentFrames = a.getFrames();
    } catch (Exception e) {
        logger.info("2. Error during analysis: " + e);
        //e.printStackTrace();
        // TODO: Handle error
    }

    //      BytecodeInstructionPool.reRegisterMethodNode(mn, className, mn.name + mn.desc);
    // Replace all bitwise operators
    logger.info("Transforming Boolean bitwise operators");
    new BitwiseOperatorTransformer(this).transform(mn);

    // Transform IFEQ/IFNE to IFLE/IFGT
    logger.info("Transforming Boolean IFs");
    new BooleanIfTransformer(this).transform(mn);

    // Insert call to BooleanHelper.get after ICONST_0/1 or Boolean fields
    logger.info("Transforming Boolean definitions");
    new BooleanDefinitionTransformer(this).transform(mn);

    // Replace all instanceof comparisons
    logger.info("Transforming instanceof");
    new InstanceOfTransformer().transform(mn);

    // Replace all calls to methods/fields returning booleans
    new BooleanCallsTransformer(this).transform(mn);

    // Transform all flag based comparisons
    logger.info("Transforming Boolean distances");
    new BooleanDistanceTransformer(this).transform(mn);
    mn.maxStack += 3;

    // Replace all boolean arrays
    new BooleanArrayTransformer().transform(mn);

    new BooleanArrayIndexTransformer(getArrayFrames(mn)).transform(mn);

    // Replace all boolean return values
    logger.info("Transforming Boolean return values");
    new BooleanReturnTransformer(this).transform(mn);

    //      GraphPool.clear(className, mn.name + mn.desc);
    //      BytecodeInstructionPool.clear(className, mn.name + mn.desc);
    //      BranchPool.clear(className, mn.name + mn.desc);

    // Actually this should be done automatically by the ClassWriter...
    // +2 because we might do a DUP2
    mn.maxStack += 1;
}

---

From source file:org.evosuite.instrumentation.testability.MethodNodeTransformer.java

License:Open Source License

protected void setupLocals(MethodNode mn) {
    Type[] args = Type.getArgumentTypes(mn.desc);
    nextLocal = (Opcodes.ACC_STATIC & mn.access) == 0 ? 1 : 0;
    for (int i = 0; i < args.length; i++) {
        nextLocal += args[i].getSize();//  ww  w .  j av  a  2s.  c om
    }
    firstLocal = nextLocal;
}

---

From source file:org.evosuite.runtime.instrumentation.CreateClassResetClassAdapter.java

License:Open Source License

/**
 * Returns true iif the access modifiers has a static modifier
 * //from   ww  w .  j  a  v a  2s . c  o  m
 * @param access
 * @return
 */
private boolean hasStaticModifier(int access) {
    return (access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC;
}

---

From source file:org.evosuite.runtime.instrumentation.CreateClassResetClassAdapter.java

License:Open Source License

/** {@inheritDoc} */
@Override/*  w w  w.j a  v a2  s  .  c  o m*/
public MethodVisitor visitMethod(int methodAccess, String methodName, String descriptor, String signature,
        String[] exceptions) {

    MethodVisitor mv = super.visitMethod(methodAccess, methodName, descriptor, signature, exceptions);

    if (methodName.equals("<clinit>") && !isInterface && !isAnonymous && !resetMethodAdded) {
        clinitFound = true;
        logger.info("Found static initializer in class " + className);
        // determineSerialisableUID();

        // duplicates existing <clinit>
        // TODO: Removed | Opcodes.ACC_PUBLIC
        // Does __STATIC_RESET need to be public?
        // <clinit> apparently can be private, resulting
        // in illegal modifiers
        MethodVisitor visitMethod = super.visitMethod(methodAccess | Opcodes.ACC_STATIC | Opcodes.ACC_SYNTHETIC,
                ClassResetter.STATIC_RESET, descriptor, signature, exceptions);

        CreateClassResetMethodAdapter staticResetMethodAdapter = new CreateClassResetMethodAdapter(visitMethod,
                className, this.static_fields, finalFields);

        resetMethodAdded = true;

        if (this.removeUpdatesOnFinalFields) {
            MethodVisitor mv2 = new RemoveFinalMethodAdapter(className, staticResetMethodAdapter, finalFields);

            return new MultiMethodVisitor(mv2, mv);
        } else {
            return new MultiMethodVisitor(staticResetMethodAdapter, mv);
        }
    } else if (methodName.equals(ClassResetter.STATIC_RESET)) {
        if (resetMethodAdded) {
            // Do not add reset method a second time
        } else {
            resetMethodAdded = true;
        }
    }
    return mv;
}

---

From source file:org.evosuite.runtime.instrumentation.CreateClassResetClassAdapter.java

License:Open Source License

@Deprecated
// This method is a code clone from MethodCallReplacementClassAdapter
private void createSerialisableUID() {
    // Only add this for serialisable classes
    if (serialUID < 0)
        return;//from   www . j  av  a 2s  .  c  om
    /*
     * If the class is serializable, then adding a hashCode will change the
     * serialVersionUID if it is not defined in the class. Hence, if it is
     * not defined, we have to define it to avoid problems in serialising
     * the class.
     */
    logger.info("Adding serialId to class " + className);
    visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL, "serialVersionUID", "J", null,
            serialUID);
}

---

From source file:org.evosuite.runtime.instrumentation.CreateClassResetClassAdapter.java

License:Open Source License

/**
 * Creates an empty __STATIC_RESET method where no <clinit> was found.
 *///from  w  w  w.j  a va 2s  .c  o  m
private void createEmptyStaticReset() {
    logger.info("Creating brand-new static initializer in class " + className);
    MethodVisitor mv = cv.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC | Opcodes.ACC_SYNTHETIC,
            ClassResetter.STATIC_RESET, "()V", null, null);
    mv.visitCode();
    for (StaticField staticField : static_fields) {

        if (!finalFields.contains(staticField.name) && !staticField.name.startsWith("__cobertura")
                && !staticField.name.startsWith("$jacoco") && !staticField.name.startsWith("$VRc") // Old
        // Emma
        ) {

            logger.info("Adding bytecode for initializing field " + staticField.name);

            if (staticField.value != null) {
                mv.visitLdcInsn(staticField.value);
            } else {
                Type type = Type.getType(staticField.desc);
                switch (type.getSort()) {
                case Type.BOOLEAN:
                case Type.BYTE:
                case Type.CHAR:
                case Type.SHORT:
                case Type.INT:
                    mv.visitInsn(Opcodes.ICONST_0);
                    break;
                case Type.FLOAT:
                    mv.visitInsn(Opcodes.FCONST_0);
                    break;
                case Type.LONG:
                    mv.visitInsn(Opcodes.LCONST_0);
                    break;
                case Type.DOUBLE:
                    mv.visitInsn(Opcodes.DCONST_0);
                    break;
                case Type.ARRAY:
                case Type.OBJECT:
                    mv.visitInsn(Opcodes.ACONST_NULL);
                    break;
                }
            }
            mv.visitFieldInsn(Opcodes.PUTSTATIC, className, staticField.name, staticField.desc);

        }
    }
    mv.visitInsn(Opcodes.RETURN);
    mv.visitMaxs(0, 0);
    mv.visitEnd();

}

---

From source file:org.evosuite.runtime.instrumentation.MethodCallReplacementClassAdapter.java

License:Open Source License

@Override
public void visitEnd() {
    if (canChangeSignature && !definesHashCode && !isInterface && RuntimeSettings.mockJVMNonDeterminism) {

        logger.info("No hashCode defined for: " + className + ", superclass = " + superClassName);

        if (superClassName.equals("java.lang.Object")) { //TODO: why only if superclass is Object??? unclear
            Method hashCodeMethod = Method.getMethod("int hashCode()");
            GeneratorAdapter mg = new GeneratorAdapter(Opcodes.ACC_PUBLIC, hashCodeMethod, null, null, this);
            mg.loadThis();/*from   w  w w.  j  a  va  2  s . co m*/
            mg.visitAnnotation(Type.getDescriptor(EvoSuiteExclude.class), true);
            mg.invokeStatic(Type.getType(org.evosuite.runtime.System.class),
                    Method.getMethod("int identityHashCode(Object)"));
            mg.returnValue();
            mg.endMethod();
        }

    }

    /*
     * If the class is serializable, then doing any change (adding hashCode, static reset, etc)
     * will change the serialVersionUID if it is not defined in the class.
     * Hence, if it is not defined, we have to define it to
     * avoid problems in serialising the class, as reading Master will not do instrumentation.
     * The serialVersionUID HAS to be the same as the un-instrumented class
     */
    if (!definesUid && !isInterface && RuntimeSettings.applyUIDTransformation) {
        ClassLoader threadCL = Thread.currentThread().getContextClassLoader();
        try {
            ClassLoader evoCL = MethodCallReplacementClassAdapter.class.getClassLoader();
            Thread.currentThread().setContextClassLoader(evoCL);

            Class<?> clazz = Class.forName(className.replace('/', '.'), false, evoCL);

            if (Serializable.class.isAssignableFrom(clazz)) {
                ObjectStreamClass c = ObjectStreamClass.lookup(clazz);
                long serialID = c.getSerialVersionUID();
                logger.info("Adding serialId to class " + className);
                visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL, "serialVersionUID",
                        "J", null, serialID);
            }
        } catch (ClassNotFoundException e) {
            logger.warn("Failed to add serialId to class " + className + ": " + e.getMessage());
        } catch (NoClassDefFoundError e) {
            logger.warn("Failed to add serialId to class " + className + ": " + e.getMessage());

        } finally {
            Thread.currentThread().setContextClassLoader(threadCL);
        }
    }

    super.visitEnd();
}

---

From source file:org.evosuite.seeding.PrimitiveClassAdapter.java

License:Open Source License

/** {@inheritDoc} */
@Override//from  w  ww. j a v  a 2 s  . c om
public FieldVisitor visitField(int access, String name, String desc, String signature, Object value) {

    // We don't use serial numbers because they can be very long and are not used in any branches
    if (!"serialVersionUID".equals(name)) {
        if (DependencyAnalysis.isTargetClassName(className)) {
            poolManager.addSUTConstant(value);
            poolManager.addSUTConstant(Type.getType(desc));
        } else {
            poolManager.addNonSUTConstant(value);
        }
        if (isEnum) {
            // static final values in enums are likely enum values
            if ((access & Opcodes.ACC_FINAL) == Opcodes.ACC_FINAL
                    && (access & Opcodes.ACC_STATIC) == Opcodes.ACC_STATIC) {
                if (DependencyAnalysis.isTargetClassName(className)) {
                    poolManager.addSUTConstant(name);
                } else {
                    poolManager.addNonSUTConstant(name);
                }
            }
        }
        // primitive_pool.add(value);
    }
    return super.visitField(access, name, desc, signature, value);
}

---

From source file:org.evosuite.symbolic.instrument.AccessFlags.java

License:Open Source License

static boolean isStatic(int access) {
    return is(access, Opcodes.ACC_STATIC);
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• 10
• 11
• 12
• 13
• 14
• 15
• 16
• 17
• 18
• 19
• 20
• 21
• 22
• 23
• 24
• 25
• 26
• 27
• 28
• 29
• 30
• 31
• 32
• 33
• 34
• 35
• 36
• 37
• 38
• 39
• 40
• 41
• 42
• 43
• 44
• 45
• 46
• 47
• 48
• 49
• 50
• »