Example usage for org.objectweb.asm Opcodes LRETURN

Introduction

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

Prototype

int LRETURN

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

Click Source Link

Usage

From source file:org.jboss.byteman.agent.adapter.RuleTriggerMethodAdapter.java

License:Open Source License

@Override
public void visitInsn(int opcode) {
    super.visitInsn(opcode);
    // look for interesting instructions which need inserting into the CFG
    switch (opcode) {
    case Opcodes.IRETURN:
    case Opcodes.LRETURN:
    case Opcodes.FRETURN:
    case Opcodes.DRETURN:
    case Opcodes.ARETURN:
    case Opcodes.RETURN:
    case Opcodes.ATHROW: {
        // add this instruction to the current block and then start a new current block
        cfg.add(opcode);/*from   w  w  w .  j ava 2s . com*/
        Label newStart = super.newLabel();
        // must call split before visiting the label
        cfg.split(newStart);
        visitLabel(newStart);
    }
        break;
    case Opcodes.MONITORENTER:
    case Opcodes.MONITOREXIT: {
        // just add this instruction to the current block
        cfg.add(opcode);
    }
        break;
    default: {
        cfg.add(opcode);
    }
    }
}

---

From source file:org.mbte.groovypp.compiler.bytecode.BytecodeExpr.java

License:Apache License

public static void doReturn(MethodVisitor mv, ClassNode returnType) {
    if (returnType == double_TYPE) {
        mv.visitInsn(Opcodes.DRETURN);//w  ww .  ja va  2 s  .c o  m
    } else if (returnType == float_TYPE) {
        mv.visitInsn(Opcodes.FRETURN);
    } else if (returnType == long_TYPE) {
        mv.visitInsn(Opcodes.LRETURN);
    } else if (returnType == boolean_TYPE || returnType == char_TYPE || returnType == byte_TYPE
            || returnType == int_TYPE || returnType == short_TYPE) {
        //byte,short,boolean,int are all IRETURN
        mv.visitInsn(Opcodes.IRETURN);
    } else if (returnType == VOID_TYPE) {
        mv.visitInsn(Opcodes.RETURN);
    } else {
        mv.visitInsn(Opcodes.ARETURN);
    }

}

---

From source file:org.openquark.cal.internal.javamodel.AsmJavaBytecodeGenerator.java

License:Open Source License

/**    
 * @param type/*from w w  w  .j ava  2s.  c o m*/
 * @return the RETURN, IRETURN,... op code, depending on type.
 */
private static int getReturnOpCode(JavaTypeName type) {

    switch (type.getTag()) {
    case JavaTypeName.VOID_TAG:
        return Opcodes.RETURN;

    case JavaTypeName.BOOLEAN_TAG:
    case JavaTypeName.BYTE_TAG:
    case JavaTypeName.SHORT_TAG:
    case JavaTypeName.CHAR_TAG:
    case JavaTypeName.INT_TAG:
        return Opcodes.IRETURN;

    case JavaTypeName.LONG_TAG:
        return Opcodes.LRETURN;

    case JavaTypeName.DOUBLE_TAG:
        return Opcodes.DRETURN;

    case JavaTypeName.FLOAT_TAG:
        return Opcodes.FRETURN;

    case JavaTypeName.ARRAY_TAG:
    case JavaTypeName.OBJECT_TAG:
        return Opcodes.ARETURN;

    default: {
        throw new IllegalArgumentException("invalid type: " + type);
    }
    }
}

---

From source file:org.sonar.java.bytecode.se.BytecodeEGWalkerExecuteTest.java

License:Open Source License

@Test
public void test_xReturn() throws Exception {
    SymbolicValue returnValue = new SymbolicValue();
    int[] opcodes = { Opcodes.IRETURN, Opcodes.LRETURN, Opcodes.FRETURN, Opcodes.DRETURN, Opcodes.ARETURN };
    for (int opcode : opcodes) {
        ProgramState programState = execute(new Instruction(opcode),
                ProgramState.EMPTY_STATE.stackValue(returnValue));
        assertThat(programState.peekValue()).isNull();
        assertThat(programState.exitValue()).isEqualTo(returnValue);
    }//from  w  ww .j av  a2 s.co  m
}

---

From source file:org.spongepowered.despector.emitter.bytecode.statement.BytecodeReturnEmitter.java

License:Open Source License

@Override
public void emit(BytecodeEmitterContext ctx, Return stmt, boolean semicolon) {
    MethodVisitor mv = ctx.getMethodVisitor();
    if (!stmt.getValue().isPresent()) {
        mv.visitInsn(Opcodes.RETURN);//from  ww w.java2 s.  co  m
    } else {
        ctx.updateStack(-1);
        Instruction insn = stmt.getValue().get();
        ctx.emitInstruction(insn, ctx.getMethod().getReturnType());
        TypeSignature ret = ctx.getMethod().getReturnType();
        if (ret == ClassTypeSignature.INT || ret == ClassTypeSignature.BOOLEAN || ret == ClassTypeSignature.BYTE
                || ret == ClassTypeSignature.SHORT || ret == ClassTypeSignature.CHAR) {
            mv.visitInsn(Opcodes.IRETURN);
        } else if (ret == ClassTypeSignature.LONG) {
            mv.visitInsn(Opcodes.LRETURN);
        } else if (ret == ClassTypeSignature.FLOAT) {
            mv.visitInsn(Opcodes.FRETURN);
        } else if (ret == ClassTypeSignature.DOUBLE) {
            mv.visitInsn(Opcodes.DRETURN);
        } else {
            mv.visitInsn(Opcodes.ARETURN);
        }
    }
}

---

From source file:serianalyzer.JVMImpl.java

License:Open Source License

/**
 * @param opcode/*from   w w w  . j ava 2s  .  co m*/
 * @param s
 */
static void handleJVMInsn(int opcode, JVMStackState s) {
    BaseType o1;
    BaseType o2;
    BaseType o3;
    List<BaseType> l1;
    List<BaseType> l2;
    switch (opcode) {
    case Opcodes.NOP:
        break;

    case Opcodes.ARRAYLENGTH:
        o1 = s.pop();
        s.push(new BasicConstant(Type.INT_TYPE, 0, !(o1 != null && !o1.isTainted())));
        break;
    case Opcodes.ACONST_NULL:
        s.push(new BasicConstant(Type.VOID_TYPE, "<null>")); //$NON-NLS-1$
        break;
    case Opcodes.ICONST_M1:
    case Opcodes.ICONST_0:
    case Opcodes.ICONST_1:
    case Opcodes.ICONST_2:
    case Opcodes.ICONST_3:
    case Opcodes.ICONST_4:
    case Opcodes.ICONST_5:
        s.push(new BasicConstant(Type.INT_TYPE, opcode - 3));
        break;
    case Opcodes.LCONST_0:
    case Opcodes.LCONST_1:
        s.push(new BasicConstant(Type.LONG_TYPE, opcode - 9L));
        break;
    case Opcodes.FCONST_0:
    case Opcodes.FCONST_1:
    case Opcodes.FCONST_2:
        s.push(new BasicConstant(Type.FLOAT_TYPE, opcode - 11f));
        break;
    case Opcodes.DCONST_0:
    case Opcodes.DCONST_1:
        s.push(new BasicConstant(Type.DOUBLE_TYPE, opcode - 14d));
        break;
    case Opcodes.IALOAD:
    case Opcodes.LALOAD:
    case Opcodes.FALOAD:
    case Opcodes.DALOAD:
    case Opcodes.BALOAD:
    case Opcodes.CALOAD:
    case Opcodes.SALOAD:
        o1 = s.pop();
        o2 = s.pop();
        s.push(new BasicVariable(toType(opcode), "primitive array elem", //$NON-NLS-1$
                (o1 == null || o1.isTainted()) | (o2 == null || o2.isTainted())));
        break;

    case Opcodes.AALOAD:
        o1 = s.pop();
        o2 = s.pop();
        if (o1 != null && o2 instanceof SimpleType && ((SimpleType) o2).getType().toString().startsWith("[")) { //$NON-NLS-1$
            Type atype = Type.getType(((SimpleType) o2).getType().toString().substring(1));
            if (o2.getAlternativeTypes() != null && !o2.getAlternativeTypes().isEmpty()) {
                s.clear();
                break;
            }
            s.push(new BasicVariable(atype, "array elem " + atype, o1.isTainted() | o2.isTainted())); //$NON-NLS-1$
        } else {
            s.clear();
        }
        break;

    case Opcodes.IASTORE:
    case Opcodes.LASTORE:
    case Opcodes.FASTORE:
    case Opcodes.DASTORE:
    case Opcodes.AASTORE:
    case Opcodes.BASTORE:
    case Opcodes.CASTORE:
    case Opcodes.SASTORE:
        s.pop(3);
        break;

    case Opcodes.POP2:
        s.pop();
    case Opcodes.MONITORENTER:
    case Opcodes.MONITOREXIT:
    case Opcodes.POP:
        s.pop();
        break;

    case Opcodes.DUP:
        if (!s.isEmpty()) {
            o1 = s.pop();
            s.push(o1);
            s.push(o1);
        }
        break;
    case Opcodes.DUP_X1:
        o1 = s.pop();
        o2 = s.pop();
        s.push(o1);
        s.push(o2);
        s.push(o1);
        break;
    case Opcodes.DUP_X2:
        o1 = s.pop();
        o2 = s.pop();
        o3 = s.pop();
        s.push(o1);
        s.push(o3);
        s.push(o2);
        s.push(o1);
        break;
    case Opcodes.DUP2:
        l1 = s.popWord();
        if (l1.isEmpty()) {
            log.trace("DUP2 with unknown operand"); //$NON-NLS-1$
            s.clear();
        } else {
            s.pushWord(l1);
            s.pushWord(l1);
        }
        break;
    case Opcodes.DUP2_X1:
        l1 = s.popWord();
        o1 = s.pop();
        if (l1.isEmpty()) {
            log.trace("DUP2 with unknown operand"); //$NON-NLS-1$
            s.clear();
        } else {
            s.pushWord(l1);
            s.push(o1);
            s.pushWord(l1);
        }
        break;
    case Opcodes.DUP2_X2:
        l1 = s.popWord();
        l2 = s.popWord();
        if (l1.isEmpty() || l2.isEmpty()) {
            log.trace("DUP2 with unknown operand"); //$NON-NLS-1$
            s.clear();
        } else {
            s.pushWord(l1);
            s.pushWord(l2);
            s.pushWord(l1);
        }
        break;

    case Opcodes.SWAP:
        o1 = s.pop();
        o2 = s.pop();
        s.push(o1);
        s.push(o2);
        break;

    case Opcodes.IADD:
    case Opcodes.LADD:
    case Opcodes.FADD:
    case Opcodes.DADD:
    case Opcodes.ISUB:
    case Opcodes.LSUB:
    case Opcodes.FSUB:
    case Opcodes.DSUB:
    case Opcodes.IMUL:
    case Opcodes.LMUL:
    case Opcodes.FMUL:
    case Opcodes.DMUL:
    case Opcodes.IDIV:
    case Opcodes.LDIV:
    case Opcodes.FDIV:
    case Opcodes.DDIV:
    case Opcodes.IREM:
    case Opcodes.LREM:
    case Opcodes.FREM:
    case Opcodes.DREM:
    case Opcodes.IAND:
    case Opcodes.LAND:
    case Opcodes.IOR:
    case Opcodes.LOR:
    case Opcodes.IXOR:
    case Opcodes.LXOR:
    case Opcodes.LCMP:
    case Opcodes.FCMPL:
    case Opcodes.FCMPG:
    case Opcodes.DCMPL:
    case Opcodes.DCMPG:
        s.merge(2);
        break;

    case Opcodes.ISHL:
    case Opcodes.LSHL:
    case Opcodes.ISHR:
    case Opcodes.LSHR:
    case Opcodes.IUSHR:
    case Opcodes.LUSHR:
        s.pop(); // amount
        // ignore value
        break;

    case Opcodes.INEG:
    case Opcodes.F2I:
    case Opcodes.D2I:
    case Opcodes.L2I:
        s.push(cast(s.pop(), Type.INT_TYPE));
        break;

    case Opcodes.LNEG:
    case Opcodes.I2L:
    case Opcodes.F2L:
    case Opcodes.D2L:
        s.push(cast(s.pop(), Type.LONG_TYPE));
        break;

    case Opcodes.FNEG:
    case Opcodes.I2F:
    case Opcodes.L2F:
    case Opcodes.D2F:
        s.push(cast(s.pop(), Type.FLOAT_TYPE));

    case Opcodes.DNEG:
    case Opcodes.I2D:
    case Opcodes.L2D:
    case Opcodes.F2D:
        s.push(cast(s.pop(), Type.DOUBLE_TYPE));

    case Opcodes.I2B:
        s.push(cast(s.pop(), Type.BYTE_TYPE));
        break;
    case Opcodes.I2C:
        s.push(cast(s.pop(), Type.CHAR_TYPE));
        break;
    case Opcodes.I2S:
        s.push(cast(s.pop(), Type.SHORT_TYPE));
        break;

    case Opcodes.ARETURN:
        s.clear();
        break;

    case Opcodes.IRETURN:
    case Opcodes.LRETURN:
    case Opcodes.FRETURN:
    case Opcodes.DRETURN:
    case Opcodes.RETURN:
        if (log.isTraceEnabled()) {
            log.trace("Found return " + s.pop()); //$NON-NLS-1$
        }
        s.clear();
        break;

    case Opcodes.ATHROW:
        Object thrw = s.pop();
        log.trace("Found throw " + thrw); //$NON-NLS-1$
        s.clear();
        break;

    default:
        log.warn("Unsupported instruction code " + opcode); //$NON-NLS-1$
    }
}

---

From source file:serianalyzer.SerianalyzerMethodVisitor.java

License:Open Source License

/**
 * {@inheritDoc}//w  w w .j  a  va2 s.  c o  m
 *
 * @see org.objectweb.asm.MethodVisitor#visitInsn(int)
 */
@Override
public void visitInsn(int opcode) {

    switch (opcode) {
    case Opcodes.ARETURN:
        Object ret = this.stack.pop();
        Type sigType = Type.getReturnType(this.ref.getSignature());
        Type retType = null;
        Set<Type> altTypes = null;
        if (ret != null) {
            if (ret instanceof SimpleType) {
                retType = ((SimpleType) ret).getType();
                altTypes = ((SimpleType) ret).getAlternativeTypes();
            } else if (ret instanceof MultiAlternatives) {
                retType = ((MultiAlternatives) ret).getCommonType();
            }
        }

        if (retType != null) {
            this.returnTypes.add(retType);
            if (altTypes != null) {
                this.returnTypes.addAll(altTypes);
            }
        } else {
            this.returnTypes.add(sigType);
        }
        this.stack.clear();
        break;

    case Opcodes.IRETURN:
    case Opcodes.LRETURN:
    case Opcodes.FRETURN:
    case Opcodes.DRETURN:
    case Opcodes.RETURN:
        if (this.log.isTraceEnabled()) {
            this.log.trace("Found return " + this.stack.pop()); //$NON-NLS-1$
        }
        this.stack.clear();
        break;

    case Opcodes.ATHROW:
        Object thrw = this.stack.pop();
        this.log.trace("Found throw " + thrw); //$NON-NLS-1$
        this.stack.clear();
        break;

    default:
        JVMImpl.handleJVMInsn(opcode, this.stack);
    }

    super.visitInsn(opcode);
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• 7
• 8
• 9
• »