Java Opcodes类代码示例

import scouter.org.objectweb.asm.Opcodes; //导入依赖的package包/类
@Override
public void visit(final int version, final int access, final String name,
        final String signature, final String superName,
        final String[] interfaces) {
    computeSVUID = (access & Opcodes.ACC_INTERFACE) == 0;

    if (computeSVUID) {
        this.name = name;
        this.access = access;
        this.interfaces = new String[interfaces.length];
        System.arraycopy(interfaces, 0, this.interfaces, 0,
                interfaces.length);
    }

    super.visit(version, access, name, signature, superName, interfaces);
}
 

import scouter.org.objectweb.asm.Opcodes; //导入依赖的package包/类
@Override
public MethodVisitor visitMethod(final int access, final String name,
        final String desc, final String signature, final String[] exceptions) {
    MethodVisitor mv;
    if ("<clinit>".equals(name)) {
        int a = Opcodes.ACC_PRIVATE + Opcodes.ACC_STATIC;
        String n = prefix + counter++;
        mv = cv.visitMethod(a, n, desc, signature, exceptions);

        if (clinit == null) {
            clinit = cv.visitMethod(a, name, desc, null, null);
        }
        clinit.visitMethodInsn(Opcodes.INVOKESTATIC, this.name, n, desc,
                false);
    } else {
        mv = cv.visitMethod(access, name, desc, signature, exceptions);
    }
    return mv;
}
 

import scouter.org.objectweb.asm.Opcodes; //导入依赖的package包/类
/**
 * Makes the given visitor visit this stack map frame.
 * 
 * @param mv
 *            a method visitor.
 */
@Override
public void accept(final MethodVisitor mv) {
    switch (type) {
    case Opcodes.F_NEW:
    case Opcodes.F_FULL:
        mv.visitFrame(type, local.size(), asArray(local), stack.size(),
                asArray(stack));
        break;
    case Opcodes.F_APPEND:
        mv.visitFrame(type, local.size(), asArray(local), 0, null);
        break;
    case Opcodes.F_CHOP:
        mv.visitFrame(type, local.size(), null, 0, null);
        break;
    case Opcodes.F_SAME:
        mv.visitFrame(type, 0, null, 0, null);
        break;
    case Opcodes.F_SAME1:
        mv.visitFrame(type, 0, null, 1, asArray(stack));
        break;
    }
}
 

import scouter.org.objectweb.asm.Opcodes; //导入依赖的package包/类
/**
 * Constructs a new {@link LookupSwitchInsnNode}.
 * 
 * @param dflt
 *            beginning of the default handler block.
 * @param keys
 *            the values of the keys.
 * @param labels
 *            beginnings of the handler blocks. <tt>labels[i]</tt> is the
 *            beginning of the handler block for the <tt>keys[i]</tt> key.
 */
public LookupSwitchInsnNode(final LabelNode dflt, final int[] keys,
        final LabelNode[] labels) {
    super(Opcodes.LOOKUPSWITCH);
    this.dflt = dflt;
    this.keys = new ArrayList<Integer>(keys == null ? 0 : keys.length);
    this.labels = new ArrayList<LabelNode>(labels == null ? 0
            : labels.length);
    if (keys != null) {
        for (int i = 0; i < keys.length; ++i) {
            this.keys.add(new Integer(keys[i]));
        }
    }
    if (labels != null) {
        this.labels.addAll(Arrays.asList(labels));
    }
}
 

import scouter.org.objectweb.asm.Opcodes; //导入依赖的package包/类
/**
 * Checks that this class node is compatible with the given ASM API version.
 * This methods checks that this node, and all its nodes recursively, do not
 * contain elements that were introduced in more recent versions of the ASM
 * API than the given version.
 * 
 * @param api
 *            an ASM API version. Must be one of {@link Opcodes#ASM4} or
 *            {@link Opcodes#ASM5}.
 */
public void check(final int api) {
    if (api == Opcodes.ASM4) {
        if (visibleTypeAnnotations != null
                && visibleTypeAnnotations.size() > 0) {
            throw new RuntimeException();
        }
        if (invisibleTypeAnnotations != null
                && invisibleTypeAnnotations.size() > 0) {
            throw new RuntimeException();
        }
        for (FieldNode f : fields) {
            f.check(api);
        }
        for (MethodNode m : methods) {
            m.check(api);
        }
    }
}
 

import scouter.org.objectweb.asm.Opcodes; //导入依赖的package包/类
/**
 * Constructs a new {@link LookupSwitchInsnNode}.
 * 
 * @param dflt
 *            beginning of the default handler block.
 * @param keys
 *            the values of the keys.
 * @param labels
 *            beginnings of the handler blocks. <tt>labels[i]</tt> is the
 *            beginning of the handler block for the <tt>keys[i]</tt> key.
 */
public LookupSwitchInsnNode(final LabelNode dflt, final int[] keys,
        final LabelNode[] labels) {
    super(Opcodes.LOOKUPSWITCH);
    this.dflt = dflt;
    this.keys = new ArrayList<Integer>(keys == null ? 0 : keys.length);
    this.labels = new ArrayList<LabelNode>(labels == null ? 0
            : labels.length);
    if (keys != null) {
        for (int i = 0; i < keys.length; ++i) {
            this.keys.add(keys[i]);
        }
    }
    if (labels != null) {
        this.labels.addAll(Arrays.asList(labels));
    }
}
 

import scouter.org.objectweb.asm.Opcodes; //导入依赖的package包/类
@Override
public void visitMaxs(int maxStack, int maxLocals) {
	Label endFinally = new Label();
	mv.visitTryCatchBlock(startFinally, endFinally, endFinally, null);
	mv.visitLabel(endFinally);
	mv.visitInsn(DUP);
	int errIdx = newLocal(Type.getType(Throwable.class));
	mv.visitVarInsn(Opcodes.ASTORE, errIdx);

	mv.visitVarInsn(Opcodes.ALOAD, statIdx);
	mv.visitVarInsn(Opcodes.ALOAD, errIdx);
	AsmUtil.PUSH(mv, -3);

	mv.visitMethodInsn(Opcodes.INVOKESTATIC, TRACESQL, END_METHOD, END_SIGNATURE, false);
	mv.visitInsn(ATHROW);
	mv.visitMaxs(maxStack + 8, maxLocals + 2);
}
 

import scouter.org.objectweb.asm.Opcodes; //导入依赖的package包/类
@Override
public void visitInsn(int opcode) {
	if ((opcode >= IRETURN && opcode <= RETURN)) {
		Type tp = returnType;
		if(!"javax/servlet/AsyncContext".equals(tp.getInternalName())) {
			return;
		}
		int i = newLocal(tp);
		mv.visitVarInsn(Opcodes.ASTORE, i);
		mv.visitVarInsn(Opcodes.ALOAD, i);
		mv.visitVarInsn(Opcodes.ALOAD, i);

		mv.visitMethodInsn(Opcodes.INVOKESTATIC, TRACEMAIN, END_METHOD, END_SIGNATURE, false);
	}
	mv.visitInsn(opcode);
}
 

import scouter.org.objectweb.asm.Opcodes; //导入依赖的package包/类
@Override
public final void visitTableSwitchInsn(final int min, final int max,
        final Label dflt, final Label... labels) {
    AttributesImpl attrs = new AttributesImpl();
    attrs.addAttribute("", "min", "min", "", Integer.toString(min));
    attrs.addAttribute("", "max", "max", "", Integer.toString(max));
    attrs.addAttribute("", "dflt", "dflt", "", getLabel(dflt));
    String o = Printer.OPCODES[Opcodes.TABLESWITCH];
    sa.addStart(o, attrs);
    for (int i = 0; i < labels.length; i++) {
        AttributesImpl att2 = new AttributesImpl();
        att2.addAttribute("", "name", "name", "", getLabel(labels[i]));
        sa.addElement("label", att2);
    }
    sa.addEnd(o);
}
 

import scouter.org.objectweb.asm.Opcodes; //导入依赖的package包/类
@Override
public FieldVisitor visitField(final int access, final String name,
        final String desc, final String signature, final Object value) {
    checkState();
    checkAccess(access, Opcodes.ACC_PUBLIC + Opcodes.ACC_PRIVATE
            + Opcodes.ACC_PROTECTED + Opcodes.ACC_STATIC
            + Opcodes.ACC_FINAL + Opcodes.ACC_VOLATILE
            + Opcodes.ACC_TRANSIENT + Opcodes.ACC_SYNTHETIC
            + Opcodes.ACC_ENUM + Opcodes.ACC_DEPRECATED + 0x40000); // ClassWriter.ACC_SYNTHETIC_ATTRIBUTE
    CheckMethodAdapter.checkUnqualifiedName(version, name, "field name");
    CheckMethodAdapter.checkDesc(desc, false);
    if (signature != null) {
        checkFieldSignature(signature);
    }
    if (value != null) {
        CheckMethodAdapter.checkConstant(value);
    }
    FieldVisitor av = super
            .visitField(access, name, desc, signature, value);
    return new CheckFieldAdapter(av);
}
 

import scouter.org.objectweb.asm.Opcodes; //导入依赖的package包/类
@Override
public void visitFrame(final int type, final int nLocal,
        final Object[] local, final int nStack, final Object[] stack) {
    if (type != Opcodes.F_NEW) { // uncompressed frame
        throw new IllegalStateException(
                "ClassReader.accept() should be called with EXPAND_FRAMES flag");
    }

    if (mv != null) {
        mv.visitFrame(type, nLocal, local, nStack, stack);
    }

    if (this.locals != null) {
        this.locals.clear();
        this.stack.clear();
    } else {
        this.locals = new ArrayList<Object>();
        this.stack = new ArrayList<Object>();
    }
    visitFrameTypes(nLocal, local, this.locals);
    visitFrameTypes(nStack, stack, this.stack);
    maxStack = Math.max(maxStack, this.stack.size());
}
 

import scouter.org.objectweb.asm.Opcodes; //导入依赖的package包/类
@Override
public MethodVisitor visitMethod(final int access, final String name,
        final String desc, final String signature, final String[] exceptions) {
    if (computeSVUID) {
        if ("<clinit>".equals(name)) {
            hasStaticInitializer = true;
        }
        /*
         * Remembers non private constructors and methods for SVUID
         * computation For constructor and method modifiers, only the
         * ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC, ACC_FINAL,
         * ACC_SYNCHRONIZED, ACC_NATIVE, ACC_ABSTRACT and ACC_STRICT flags
         * are used.
         */
        int mods = access
                & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PRIVATE
                        | Opcodes.ACC_PROTECTED | Opcodes.ACC_STATIC
                        | Opcodes.ACC_FINAL | Opcodes.ACC_SYNCHRONIZED
                        | Opcodes.ACC_NATIVE | Opcodes.ACC_ABSTRACT | Opcodes.ACC_STRICT);

        // all non private methods
        if ((access & Opcodes.ACC_PRIVATE) == 0) {
            if ("<init>".equals(name)) {
                svuidConstructors.add(new Item(name, mods, desc));
            } else if (!"<clinit>".equals(name)) {
                svuidMethods.add(new Item(name, mods, desc));
            }
        }
    }

    return super.visitMethod(access, name, desc, signature, exceptions);
}
 

import scouter.org.objectweb.asm.Opcodes; //导入依赖的package包/类
@Override
public FieldVisitor visitField(final int access, final String name,
        final String desc, final String signature, final Object value) {
    if (computeSVUID) {
        if ("serialVersionUID".equals(name)) {
            // since the class already has SVUID, we won't be computing it.
            computeSVUID = false;
            hasSVUID = true;
        }
        /*
         * Remember field for SVUID computation For field modifiers, only
         * the ACC_PUBLIC, ACC_PRIVATE, ACC_PROTECTED, ACC_STATIC,
         * ACC_FINAL, ACC_VOLATILE, and ACC_TRANSIENT flags are used when
         * computing serialVersionUID values.
         */
        if ((access & Opcodes.ACC_PRIVATE) == 0
                || (access & (Opcodes.ACC_STATIC | Opcodes.ACC_TRANSIENT)) == 0) {
            int mods = access
                    & (Opcodes.ACC_PUBLIC | Opcodes.ACC_PRIVATE
                            | Opcodes.ACC_PROTECTED | Opcodes.ACC_STATIC
                            | Opcodes.ACC_FINAL | Opcodes.ACC_VOLATILE | Opcodes.ACC_TRANSIENT);
            svuidFields.add(new Item(name, mods, desc));
        }
    }

    return super.visitField(access, name, desc, signature, value);
}
 

import scouter.org.objectweb.asm.Opcodes; //导入依赖的package包/类
protected void addSVUID(long svuid) {
    FieldVisitor fv = super.visitField(Opcodes.ACC_FINAL
            + Opcodes.ACC_STATIC, "serialVersionUID", "J", null, new Long(
            svuid));
    if (fv != null) {
        fv.visitEnd();
    }
}
 

import scouter.org.objectweb.asm.Opcodes; //导入依赖的package包/类
@Deprecated
@Override
public void visitMethodInsn(final int opcode, final String owner,
        final String name, final String desc) {
    if (api >= Opcodes.ASM5) {
        super.visitMethodInsn(opcode, owner, name, desc);
        return;
    }
    doVisitMethodInsn(opcode, owner, name, desc,
            opcode == Opcodes.INVOKEINTERFACE);
}