Java Bytecode.addOpcode方法代码示例

import scouter.javassist.bytecode.Bytecode; //导入方法依赖的package包/类
protected void atAssignParamList(CtClass[] params, Bytecode code)
    throws CompileError
{
    if (params == null)
        return;

    int varNo = indexOfParam1();
    int n = params.length;
    for (int i = 0; i < n; ++i) {
        code.addOpcode(DUP);
        code.addIconst(i);
        code.addOpcode(AALOAD);
        compileUnwrapValue(params[i], code);
        code.addStore(varNo, params[i]);
        varNo += is2word(exprType, arrayDim) ? 2 : 1;
    }
}
 

import scouter.javassist.bytecode.Bytecode; //导入方法依赖的package包/类
private static void compileReturn(Bytecode code, CtClass type) {
    if (type.isPrimitive()) {
        CtPrimitiveType pt = (CtPrimitiveType)type;
        if (pt != CtClass.voidType) {
            String wrapper = pt.getWrapperName();
            code.addCheckcast(wrapper);
            code.addInvokevirtual(wrapper, pt.getGetMethodName(),
                                  pt.getGetMethodDescriptor());
        }

        code.addOpcode(pt.getReturnOp());
    }
    else {
        code.addCheckcast(type);
        code.addOpcode(Bytecode.ARETURN);
    }
}
 

import scouter.javassist.bytecode.Bytecode; //导入方法依赖的package包/类
/**
 * @param thisMethod        might be null.
 */
private static void callFind2Methods(Bytecode code, String superMethod, String thisMethod,
                                     int index, String desc, int classVar, int arrayVar) {
    String findClass = RuntimeSupport.class.getName();
    String findDesc
        = "(Ljava/lang/Class;Ljava/lang/String;Ljava/lang/String;ILjava/lang/String;[Ljava/lang/reflect/Method;)V";

    code.addAload(classVar);
    code.addLdc(superMethod);
    if (thisMethod == null)
        code.addOpcode(Opcode.ACONST_NULL);
    else
        code.addLdc(thisMethod);

    code.addIconst(index);
    code.addLdc(desc);
    code.addAload(arrayVar);
    code.addInvokestatic(findClass, "find2Methods", findDesc);
}
 

import scouter.javassist.bytecode.Bytecode; //导入方法依赖的package包/类
private static int addReturn(Bytecode code, Class type) {
    if (type.isPrimitive()) {
        if (type == Long.TYPE) {
            code.addOpcode(Opcode.LRETURN);
            return 2;
        }
        else if (type == Float.TYPE)
            code.addOpcode(Opcode.FRETURN);
        else if (type == Double.TYPE) {
            code.addOpcode(Opcode.DRETURN);
            return 2;
        }
        else if (type == Void.TYPE) {
            code.addOpcode(Opcode.RETURN);
            return 0;
        }
        else
            code.addOpcode(Opcode.IRETURN);
    }
    else
        code.addOpcode(Opcode.ARETURN);

    return 1;
}
 

import scouter.javassist.bytecode.Bytecode; //导入方法依赖的package包/类
private static void makeParameterList(Bytecode code, Class[] params) {
    int regno = 1;
    int n = params.length;
    code.addIconst(n);
    code.addAnewarray("java/lang/Object");
    for (int i = 0; i < n; i++) {
        code.addOpcode(Opcode.DUP);
        code.addIconst(i);
        Class type = params[i];
        if (type.isPrimitive())
            regno = makeWrapper(code, type, regno);
        else {
            code.addAload(regno);
            regno++;
        }

        code.addOpcode(Opcode.AASTORE);
    }
}
 

import scouter.javassist.bytecode.Bytecode; //导入方法依赖的package包/类
private static MethodInfo makeWriteReplace(ConstPool cp) {
    MethodInfo minfo = new MethodInfo(cp, "writeReplace", "()Ljava/lang/Object;");
    String[] list = new String[1];
    list[0] = "java.io.ObjectStreamException";
    ExceptionsAttribute ea = new ExceptionsAttribute(cp);
    ea.setExceptions(list);
    minfo.setExceptionsAttribute(ea);
    Bytecode code = new Bytecode(cp, 0, 1);
    code.addAload(0);
    code.addInvokestatic("RuntimeSupport",
                         "makeSerializedProxy",
                         "(Ljava/lang/Object;)Ljavassist/util/proxy/SerializedProxy;");
    code.addOpcode(Opcode.ARETURN);
    minfo.setCodeAttribute(code.toCodeAttribute());
    return minfo;
}
 

import scouter.javassist.bytecode.Bytecode; //导入方法依赖的package包/类
/**
 * Adds a finally clause for earch return statement.
 */
private void addFinally(ArrayList returnList, Stmnt finallyBlock)
    throws CompileError
{
    Bytecode bc = bytecode;
    int n = returnList.size();
    for (int i = 0; i < n; ++i) {
        final int[] ret = (int[])returnList.get(i);
        int pc = ret[0];
        bc.write16bit(pc, bc.currentPc() - pc + 1);
        ReturnHook hook = new JsrHook2(this, ret);
        finallyBlock.accept(this);
        hook.remove(this);
        if (!hasReturned) {
            bc.addOpcode(Opcode.GOTO);
            bc.addIndex(pc + 3 - bc.currentPc());
        }
    }
}
 

import scouter.javassist.bytecode.Bytecode; //导入方法依赖的package包/类
public void doit(JvstCodeGen gen, Bytecode bytecode, ASTList args)
    throws CompileError
{
    int num = gen.getMethodArgsLength(args); 
    if (num != dimension)
        throw new CompileError(Javac.proceedName
                + "() with a wrong number of parameters");

    gen.atMethodArgs(args, new int[num],
                     new int[num], new String[num]);
    bytecode.addOpcode(opcode);
    if (opcode == Opcode.ANEWARRAY)
        bytecode.addIndex(index);
    else if (opcode == Opcode.NEWARRAY)
        bytecode.add(index);
    else /* if (opcode == Opcode.MULTIANEWARRAY) */ {
        bytecode.addIndex(index);
        bytecode.add(dimension);
        bytecode.growStack(1 - dimension);
    }

    gen.setType(arrayType);
}
 

import scouter.javassist.bytecode.Bytecode; //导入方法依赖的package包/类
public static int compileParameterList(Bytecode code,
                            CtClass[] params, int regno) {
    if (params == null) {
        code.addIconst(0);                          // iconst_0
        code.addAnewarray(javaLangObject);          // anewarray Object
        return 1;
    }
    else {
        CtClass[] args = new CtClass[1];
        int n = params.length;
        code.addIconst(n);                          // iconst_<n>
        code.addAnewarray(javaLangObject);          // anewarray Object
        for (int i = 0; i < n; ++i) {
            code.addOpcode(Bytecode.DUP);           // dup
            code.addIconst(i);                      // iconst_<i>
            if (params[i].isPrimitive()) {
                CtPrimitiveType pt = (CtPrimitiveType)params[i];
                String wrapper = pt.getWrapperName();
                code.addNew(wrapper);               // new <wrapper>
                code.addOpcode(Bytecode.DUP);       // dup
                int s = code.addLoad(regno, pt);    // ?load <regno>
                regno += s;
                args[0] = pt;
                code.addInvokespecial(wrapper, "<init>",
                            Descriptor.ofMethod(CtClass.voidType, args));
                                                    // invokespecial
            }
            else {
                code.addAload(regno);               // aload <regno>
                ++regno;
            }

            code.addOpcode(Bytecode.AASTORE);       // aastore
        }

        return 8;
    }
}
 

import scouter.javassist.bytecode.Bytecode; //导入方法依赖的package包/类
protected boolean doit(Bytecode b, int opcode) {
    switch (opcode) {
    case Opcode.RETURN :
        break;
    case ARETURN :
        b.addAstore(var);
        break;
    case IRETURN :
        b.addIstore(var);
        break;
    case LRETURN :
        b.addLstore(var);
        break;
    case DRETURN :
        b.addDstore(var);
        break;
    case FRETURN :
        b.addFstore(var);
        break;
    default :
        throw new RuntimeException("fatal");
    }

    b.addOpcode(Opcode.GOTO);
    b.addIndex(target - b.currentPc() + 3);
    return true;
}
 

import scouter.javassist.bytecode.Bytecode; //导入方法依赖的package包/类
private static void addGetter(String classname, ClassFile cf, ConstPool cp)
    throws CannotCompileException
{
    MethodInfo minfo = new MethodInfo(cp, HANDLER_GETTER,
                                      HANDLER_GETTER_TYPE);
    minfo.setAccessFlags(AccessFlag.PUBLIC);
    Bytecode code = new Bytecode(cp, 1, 1);
    code.addAload(0);
    code.addGetfield(classname, HANDLER, HANDLER_TYPE);
    code.addOpcode(Bytecode.ARETURN);
    minfo.setCodeAttribute(code.toCodeAttribute());
    cf.addMethod(minfo);
}
 

import scouter.javassist.bytecode.Bytecode; //导入方法依赖的package包/类
private static MethodInfo makeConstructor(String thisClassName, Constructor cons,
                                          ConstPool cp, Class superClass, boolean doHandlerInit) {
    String desc = RuntimeSupport.makeDescriptor(cons.getParameterTypes(),
                                                Void.TYPE);
    MethodInfo minfo = new MethodInfo(cp, "<init>", desc);
    minfo.setAccessFlags(Modifier.PUBLIC);      // cons.getModifiers() & ~Modifier.NATIVE
    setThrows(minfo, cp, cons.getExceptionTypes());
    Bytecode code = new Bytecode(cp, 0, 0);

    // legacy: if we are not using caching then we initialise the instance's handler
    // from the class's static default interceptor and skip the next few instructions if
    // it is non-null
    if (doHandlerInit) {
        code.addAload(0);
        code.addGetstatic(thisClassName, DEFAULT_INTERCEPTOR, HANDLER_TYPE);
        code.addPutfield(thisClassName, HANDLER, HANDLER_TYPE);
        code.addGetstatic(thisClassName, DEFAULT_INTERCEPTOR, HANDLER_TYPE);
        code.addOpcode(Opcode.IFNONNULL);
        code.addIndex(10);
    }
    // if caching is enabled then we don't have a handler to initialise so this else branch will install
    // the handler located in the static field of class RuntimeSupport.
    code.addAload(0);
    code.addGetstatic(NULL_INTERCEPTOR_HOLDER, DEFAULT_INTERCEPTOR, HANDLER_TYPE);
    code.addPutfield(thisClassName, HANDLER, HANDLER_TYPE);
    int pc = code.currentPc();

    code.addAload(0);
    int s = addLoadParameters(code, cons.getParameterTypes(), 1);
    code.addInvokespecial(superClass.getName(), "<init>", desc);
    code.addOpcode(Opcode.RETURN);
    code.setMaxLocals(s + 1);
    CodeAttribute ca = code.toCodeAttribute();
    minfo.setCodeAttribute(ca);

    StackMapTable.Writer writer = new StackMapTable.Writer(32);
    writer.sameFrame(pc);
    ca.setAttribute(writer.toStackMapTable(cp));
    return minfo;
}
 

import scouter.javassist.bytecode.Bytecode; //导入方法依赖的package包/类
private static void makeDefaultBody(Bytecode b, CtClass type) {
    int op;
    int value;
    if (type instanceof CtPrimitiveType) {
        CtPrimitiveType pt = (CtPrimitiveType)type;
        op = pt.getReturnOp();
        if (op == Opcode.DRETURN)
            value = Opcode.DCONST_0;
        else if (op == Opcode.FRETURN)
            value = Opcode.FCONST_0;
        else if (op == Opcode.LRETURN)
            value = Opcode.LCONST_0;
        else if (op == Opcode.RETURN)
            value = Opcode.NOP;
        else
            value = Opcode.ICONST_0;
    }
    else {
        op = Opcode.ARETURN;
        value = Opcode.ACONST_NULL;
    }

    if (value != Opcode.NOP)
        b.addOpcode(value);

    b.addOpcode(op);
}
 

import scouter.javassist.bytecode.Bytecode; //导入方法依赖的package包/类
public void doit(JvstCodeGen gen, Bytecode bytecode, ASTList args)
    throws CompileError
{
    if (gen.getMethodArgsLength(args) != 1)
        throw new CompileError(Javac.proceedName
                + "() cannot take more than one parameter "
                + "for instanceof");

    gen.atMethodArgs(args, new int[1], new int[1], new String[1]);
    bytecode.addOpcode(Opcode.INSTANCEOF);
    bytecode.addIndex(index);
    gen.setType(CtClass.booleanType);
}
 

import scouter.javassist.bytecode.Bytecode; //导入方法依赖的package包/类
public void doit(JvstCodeGen gen, Bytecode bytecode, ASTList args)
    throws CompileError
{
    bytecode.addOpcode(NEW);
    bytecode.addIndex(newIndex);
    bytecode.addOpcode(DUP);
    gen.atMethodCallCore(newType, MethodInfo.nameInit, args,
                         false, true, -1, null);
    gen.setType(newType);
}