Example usage for org.objectweb.asm Opcodes IADD

List of usage examples for org.objectweb.asm Opcodes IADD

  1. HOME
  2. Java
  3. org.objectweb.asm
  4. org.objectweb.asm.*
  5. Opcodes
  6. IADD

Introduction

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

Prototype

int IADD

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

Click Source Link

Usage

From source file:com.codename1.tools.translator.bytecodes.ArithmeticExpression.java

public String getExpressionAsString() {

    Instruction instr = lastInstruction;
    int opcode = lastInstruction.getOpcode();
    if (subExpression == null) {
        // This is the root of it... probably an FLOAD
        if (lastInstruction instanceof AssignableExpression
                && !(lastInstruction instanceof ArithmeticExpression)) {
            StringBuilder out = new StringBuilder();
            if (((AssignableExpression) lastInstruction).assignTo(null, out)) {
                String strOut = out.toString();
                if (strOut.trim().isEmpty()) {
                    throw new RuntimeException("Instruction produces blank string output: " + lastInstruction);
                }/*from w ww. j  a  v  a2  s  . c o m*/
                if (strOut == null || "null".equals(strOut)) {
                    throw new RuntimeException(
                            "ArithmeticExpression produced null value.  This shouldn't happen: "
                                    + lastInstruction);
                }
                return strOut;
            }
        }

        if (lastInstruction instanceof VarOp) {
            VarOp var = (VarOp) lastInstruction;
            switch (opcode) {
            case Opcodes.FLOAD: {
                return "flocals_" + var.getIndex() + "_";

            }
            case Opcodes.DLOAD: {
                return "dlocals_" + var.getIndex() + "_";
            }

            case Opcodes.ILOAD: {
                return "ilocals_" + var.getIndex() + "_";
            }

            case Opcodes.LLOAD: {
                return "llocals_" + var.getIndex() + "_";
            }

            case org.objectweb.asm.Opcodes.ICONST_0: {
                return "0";

            }
            case org.objectweb.asm.Opcodes.ICONST_1: {
                return "1";

            }
            case org.objectweb.asm.Opcodes.ICONST_2: {
                return "2";

            }
            case org.objectweb.asm.Opcodes.ICONST_3: {
                return "3";

            }
            case org.objectweb.asm.Opcodes.ICONST_4: {
                return "4";

            }
            case org.objectweb.asm.Opcodes.ICONST_5: {
                return "5";

            }
            case org.objectweb.asm.Opcodes.ICONST_M1: {
                return "(-1)";

            }
            case org.objectweb.asm.Opcodes.LCONST_0: {
                return "((JAVA_LONG)0)";

            }
            case Opcodes.DCONST_0: {
                return "((JAVA_DOUBLE)0)";
            }
            case Opcodes.DCONST_1: {
                return "((JAVA_DOUBLE)1)";
            }
            case Opcodes.FCONST_0: {
                return "((JAVA_FLOAT)0)";
            }
            case Opcodes.FCONST_1: {
                return "((JAVA_FLOAT)1)";
            }
            case Opcodes.FCONST_2: {
                return "((JAVA_FLOAT)2";
            }

            case org.objectweb.asm.Opcodes.LCONST_1: {
                return "((JAVA_LONG)1)";

            }
            case org.objectweb.asm.Opcodes.BIPUSH:
            case org.objectweb.asm.Opcodes.SIPUSH: {
                return String.valueOf(var.getIndex());
            }
            default: {
                throw new RuntimeException("Unsupported Opcode in ArithmeticExpression: " + opcode + " " + var);
            }
            }
        } else {
            switch (instr.getOpcode()) {

            case org.objectweb.asm.Opcodes.ICONST_0: {
                return "0";

            }
            case org.objectweb.asm.Opcodes.ICONST_1: {
                return "1";

            }
            case org.objectweb.asm.Opcodes.ICONST_2: {
                return "2";

            }
            case org.objectweb.asm.Opcodes.ICONST_3: {
                return "3";

            }
            case org.objectweb.asm.Opcodes.ICONST_4: {
                return "4";

            }
            case org.objectweb.asm.Opcodes.ICONST_5: {
                return "5";

            }
            case org.objectweb.asm.Opcodes.ICONST_M1: {
                return "(-1)";

            }
            case org.objectweb.asm.Opcodes.LCONST_0: {
                return "((JAVA_LONG)0)";

            }
            case org.objectweb.asm.Opcodes.LCONST_1: {
                return "(JAVA_LONG)1";

            }
            case org.objectweb.asm.Opcodes.BIPUSH: {
                if (instr instanceof BasicInstruction) {
                    return String.valueOf(((BasicInstruction) instr).getValue());
                }
                break;
            }
            case org.objectweb.asm.Opcodes.LDC: {
                if (instr instanceof Ldc) {
                    Ldc ldc = (Ldc) instr;
                    return ldc.getValueAsString();

                }
                break;
            }
            default: {
                throw new RuntimeException(
                        "Unsupported Opcode in ArithmeticExpression: " + opcode + " " + instr);
            }

            }
        }

    } else {

        switch (opcode) {

        case Opcodes.ISHL: {
            return "BC_ISHL_EXPR(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }
        case Opcodes.ISHR: {
            return "BC_ISHR_EXPR(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }
        case Opcodes.LSHL: {
            return "BC_LSHL_EXPR(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }
        case Opcodes.LSHR: {
            return "BC_LSHR_EXPR(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }
        case Opcodes.IUSHR: {
            return "BC_IUSHR_EXPR(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }
        case Opcodes.LUSHR: {
            return "BC_LUSHR_EXPR(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }

        case Opcodes.DCMPG:
        case Opcodes.DCMPL:
        case Opcodes.FCMPG:
        case Opcodes.FCMPL:
        case Opcodes.LCMP: {
            return "CN1_CMP_EXPR(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }
        case Opcodes.D2F: {
            return "((JAVA_FLOAT)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.F2D: {
            return subExpression.getExpressionAsString().trim();
        }
        case Opcodes.F2I: {
            return "((JAVA_INT)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.F2L: {
            return "((JAVA_LONG)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.D2I: {
            return "((JAVA_INT)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.D2L: {
            return "((JAVA_LONG)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.I2B: {
            return "((" + subExpression.getExpressionAsString() + " << 24) >> 24)";
        }
        case Opcodes.I2C: {
            return "(" + subExpression.getExpressionAsString().trim() + " & 0xffff)";
        }
        case Opcodes.I2D: {
            return "((JAVA_DOUBLE)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.I2F: {
            return "((JAVA_FLOAT)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.I2L: {
            return "((JAVA_LONG)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.I2S: {
            return "((" + subExpression.getExpressionAsString().trim() + " << 16) >> 16)";
        }
        case Opcodes.L2D: {
            return "((JAVA_DOUBLE)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.L2F: {
            return "((JAVA_FLOAT)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.L2I: {
            return "((JAVA_INT)" + subExpression.getExpressionAsString().trim() + ")";
        }
        case Opcodes.IAND:
        case Opcodes.LAND: {
            return "(" + subExpression.getExpressionAsString().trim() + " & "
                    + subExpression2.getExpressionAsString().trim() + ")";

        }
        case Opcodes.IOR:
        case Opcodes.LOR: {
            return "(" + subExpression.getExpressionAsString().trim() + " | "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }
        case Opcodes.IXOR:
        case Opcodes.LXOR: {
            return "(" + subExpression.getExpressionAsString().trim() + " ^ "
                    + subExpression2.getExpressionAsString().trim() + ")";

        }
        case Opcodes.DADD:
        case Opcodes.IADD:
        case Opcodes.LADD:
        case Opcodes.FADD: {
            return "(" + subExpression.getExpressionAsString().trim() + " + "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }

        case Opcodes.DSUB:
        case Opcodes.ISUB:
        case Opcodes.LSUB:
        case Opcodes.FSUB: {
            return "(" + subExpression.getExpressionAsString().trim() + " - "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }

        case Opcodes.DMUL:
        case Opcodes.IMUL:
        case Opcodes.LMUL:
        case Opcodes.FMUL: {
            return "(" + subExpression.getExpressionAsString().trim() + " * "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }

        case Opcodes.DDIV:
        case Opcodes.IDIV:
        case Opcodes.LDIV:
        case Opcodes.FDIV: {
            return "(" + subExpression.getExpressionAsString().trim() + " / "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }

        case Opcodes.FREM:
        case Opcodes.DREM: {
            return "fmod(" + subExpression.getExpressionAsString().trim() + ", "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }

        case Opcodes.LREM:
        case Opcodes.IREM: {
            if (subExpression2.getExpressionAsString() == null
                    || "null".equals(subExpression2.getExpressionAsString())) {
                throw new RuntimeException("2nd param of REM is null.  Should never happen.  Expression is "
                        + subExpression2 + " with last instruction " + subExpression2.lastInstruction);
            }
            return "(" + subExpression.getExpressionAsString().trim() + " % "
                    + subExpression2.getExpressionAsString().trim() + ")";
        }

        case Opcodes.FNEG:
        case Opcodes.INEG:
        case Opcodes.LNEG:
        case Opcodes.DNEG:
            return "(-(" + subExpression.getExpressionAsString().trim() + "))";

        default: {
            throw new RuntimeException("Unsupported Opcode in ArithmeticExpression: " + opcode + " " + instr);
        }

        }
    }
    throw new RuntimeException("Did not return a value in getExpressionAsString() with lastInstruction "
            + lastInstruction + " subExpression " + subExpression + " and subExpression2 " + subExpression2);
}

From source file:com.codename1.tools.translator.bytecodes.BasicInstruction.java

License:Open Source License

@Override
public void appendInstruction(StringBuilder b, List<Instruction> instructions) {
    switch (opcode) {
    case Opcodes.NOP:
        break;/*from   w w  w.  j ava  2s  .c om*/

    case Opcodes.ACONST_NULL:
        b.append("    PUSH_POINTER(JAVA_NULL); /* ACONST_NULL */\n");
        break;

    case Opcodes.ICONST_M1:
        b.append("    PUSH_INT(-1); /* ICONST_M1 */\n");
        break;

    case Opcodes.ICONST_0:
        b.append("    PUSH_INT(0); /* ICONST_0 */\n");
        break;

    case Opcodes.ICONST_1:
        b.append("    PUSH_INT(1); /* ICONST_1 */\n");
        break;

    case Opcodes.ICONST_2:
        b.append("    PUSH_INT(2); /* ICONST_2 */\n");
        break;

    case Opcodes.ICONST_3:
        b.append("    PUSH_INT(3); /* ICONST_3 */\n");
        break;

    case Opcodes.ICONST_4:
        b.append("    PUSH_INT(4); /* ICONST_4 */\n");
        break;

    case Opcodes.ICONST_5:
        b.append("    PUSH_INT(5); /* ICONST_5 */\n");
        break;

    case Opcodes.LCONST_0:
        b.append("    PUSH_LONG(0); /* LCONST_0 */\n");
        break;

    case Opcodes.LCONST_1:
        b.append("    PUSH_LONG(1); /* LCONST_1 */\n");
        break;

    case Opcodes.FCONST_0:
        b.append("    PUSH_FLOAT(0); /* FCONST_0 */\n");
        break;

    case Opcodes.FCONST_1:
        b.append("    PUSH_FLOAT(1); /* FCONST_1 */\n");
        break;

    case Opcodes.FCONST_2:
        b.append("    PUSH_FLOAT(2); /* FCONST_2 */\n");
        break;

    case Opcodes.DCONST_0:
        b.append("    PUSH_DOUBLE(0); /* DCONST_0 */\n");
        break;

    case Opcodes.DCONST_1:
        b.append("    PUSH_DOUBLE(1); /* DCONST_1 */\n");
        break;

    case Opcodes.BALOAD:
        b.append("    { CHECK_ARRAY_ACCESS(2, SP[-1].data.i); /* BALOAD */ \n"
                + "    SP--; SP[-1].type = CN1_TYPE_INT; \n"
                + "    SP[-1].data.i = ((JAVA_ARRAY_BYTE*) (*(JAVA_ARRAY)SP[-1].data.o).data)[(*SP).data.i]; \n"
                + "    }\n");
        break;

    case Opcodes.CALOAD:
        b.append("    CHECK_ARRAY_ACCESS(2, SP[-1].data.i); /* CALOAD */\n"
                + "    SP--; SP[-1].type = CN1_TYPE_INT; \n"
                + "    SP[-1].data.i = ((JAVA_ARRAY_CHAR*) (*(JAVA_ARRAY)SP[-1].data.o).data)[(*SP).data.i];\n");
        break;

    case Opcodes.IALOAD:
        b.append("    CHECK_ARRAY_ACCESS(2, SP[-1].data.i); /* IALOAD */\n"
                + "    SP--; SP[-1].type = CN1_TYPE_INT; \n"
                + "    SP[-1].data.i = ((JAVA_ARRAY_INT*) (*(JAVA_ARRAY)SP[-1].data.o).data)[(*SP).data.i];\n");
        break;

    case Opcodes.SALOAD:
        b.append("    CHECK_ARRAY_ACCESS(2, SP[-1].data.i); \n" + "    SP--; SP[-1].type = CN1_TYPE_INT; \n"
                + "    SP[-1].data.i = ((JAVA_ARRAY_SHORT*) (*(JAVA_ARRAY)SP[-1].data.o).data)[(*SP).data.i]; /* SALOAD */\n");
        break;

    case Opcodes.LALOAD:
        b.append("    CHECK_ARRAY_ACCESS(2, SP[-1].data.i); /* LALOAD */\n"
                + "    SP--; SP[-1].type = CN1_TYPE_LONG; \n"
                + "    SP[-1].data.l = LONG_ARRAY_LOOKUP((JAVA_ARRAY)SP[-1].data.o, (*SP).data.i);\n");
        break;

    case Opcodes.FALOAD:
        b.append("    CHECK_ARRAY_ACCESS(2, SP[-1].data.i); /* FALOAD */\n"
                + "    SP--; SP[-1].type = CN1_TYPE_FLOAT; \n"
                + "    SP[-1].data.f = FLOAT_ARRAY_LOOKUP((JAVA_ARRAY)SP[-1].data.o, (*SP).data.i);\n");
        break;

    case Opcodes.DALOAD:
        b.append("    CHECK_ARRAY_ACCESS(2, SP[-1].data.i); /* DALOAD */\n"
                + "    SP--; SP[-1].type = CN1_TYPE_DOUBLE; \n"
                + "    SP[-1].data.d = DOUBLE_ARRAY_LOOKUP((JAVA_ARRAY)SP[-1].data.o, (*SP).data.i);\n");
        break;

    case Opcodes.AALOAD:
        b.append("    CHECK_ARRAY_ACCESS(2, SP[-1].data.i); /* AALOAD */\n"
                + "    SP--; SP[-1].type = CN1_TYPE_INVALID; \n"
                + "    SP[-1].data.o = ((JAVA_ARRAY_OBJECT*) (*(JAVA_ARRAY)SP[-1].data.o).data)[(*SP).data.i]; \n"
                + "    SP[-1].type = CN1_TYPE_OBJECT; \n");
        break;

    case Opcodes.BASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); /* BASTORE */\n"
                + "    ((JAVA_ARRAY_BYTE*) (*(JAVA_ARRAY)SP[-3].data.o).data)[SP[-2].data.i] = SP[-1].data.i; SP -= 3;\n");
        break;

    case Opcodes.CASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); /* CASTORE */\n"
                + "    ((JAVA_ARRAY_CHAR*) (*(JAVA_ARRAY)SP[-3].data.o).data)[SP[-2].data.i] = SP[-1].data.i; SP -= 3;\n\n");
        break;

    case Opcodes.SASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); /* SASTORE */\n"
                + "    ((JAVA_ARRAY_SHORT*) (*(JAVA_ARRAY)SP[-3].data.o).data)[SP[-2].data.i] = SP[-1].data.i; SP -= 3;\n");
        break;

    case Opcodes.IASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); /* IASTORE */\n"
                + "    ((JAVA_ARRAY_INT*) (*(JAVA_ARRAY)SP[-3].data.o).data)[SP[-2].data.i] = SP[-1].data.i; SP -= 3;\n");
        break;

    case Opcodes.LASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); /* LASTORE */\n"
                + "    LONG_ARRAY_LOOKUP((JAVA_ARRAY)SP[-3].data.o, SP[-2].data.i) = SP[-1].data.l; SP -= 3;\n");
        break;

    case Opcodes.FASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); /* FASTORE */\n"
                + "    FLOAT_ARRAY_LOOKUP((JAVA_ARRAY)SP[-3].data.o, SP[-2].data.i) = SP[-1].data.f; SP -= 3;\n");
        break;

    case Opcodes.DASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); /* DASTORE */\n"
                + "    DOUBLE_ARRAY_LOOKUP((JAVA_ARRAY)SP[-3].data.o, SP[-2].data.i) = SP[-1].data.d; SP -= 3;\n");
        break;

    case Opcodes.AASTORE:
        b.append("    CHECK_ARRAY_ACCESS(3, SP[-2].data.i); { /* BC_AASTORE */\n"
                + "    JAVA_OBJECT aastoreTmp = SP[-3].data.o; \n"
                + "    ((JAVA_ARRAY_OBJECT*) (*(JAVA_ARRAY)aastoreTmp).data)[SP[-2].data.i] = SP[-1].data.o; \n"
                + "    SP -= 3; }\n");
        break;

    case Opcodes.POP:
        b.append("    SP--; /* POP */\n");
        break;

    case Opcodes.POP2:
        b.append("    popMany(threadStateData, 2, &SP); /* POP2 */\n");
        break;

    /*case Opcodes.DUP:
        b.append("    PUSH_INT(PEEK_INT(1));\n");
        break;
            
    case Opcodes.DUP_X1:
        b.append("    DUP_X1();\n");
        break;
                
    case Opcodes.DUP_X2:
        b.append("    DUP_X2();\n");
        break;*/

    case Opcodes.DUP:
        b.append("    BC_DUP(); /* DUP */\n");
        break;

    case Opcodes.DUP2:
        b.append("    BC_DUP2(); /* DUP2 */\n");
        break;

    case Opcodes.DUP_X1:
        b.append("    BC_DUP2_X1(); /* DUP_X1 */\n");
        break;

    case Opcodes.DUP2_X1:
        b.append("    BC_DUP2_X1(); /* DUP2_X1 */\n");
        break;

    case Opcodes.DUP_X2:
        b.append("    BC_DUP2_X2(); /* DUP_X2 */\n");
        break;

    case Opcodes.DUP2_X2:
        b.append("    BC_DUP2_X2(); /* DUP2_X2 */\n");
        break;

    case Opcodes.SWAP:
        b.append("    swapStack(SP); /* SWAP */\n");
        break;

    case Opcodes.IADD:
        b.append("    SP--; SP[-1].data.i = SP[-1].data.i + (*SP).data.i; /* IADD */\n");
        break;

    case Opcodes.LADD:
        b.append("    SP--; SP[-1].data.l = SP[-1].data.l + (*SP).data.l; /* LADD */\n");
        break;

    case Opcodes.FADD:
        b.append("    SP--; SP[-1].data.f = SP[-1].data.f + (*SP).data.f; /* FADD */\n");
        break;

    case Opcodes.DADD:
        b.append("    SP--; SP[-1].data.d = SP[-1].data.d + (*SP).data.d; /* DADD */\n");
        break;

    case Opcodes.ISUB:
        b.append("    SP--; SP[-1].data.i = (SP[-1].data.i - (*SP).data.i); /* ISUB */\n");
        break;

    case Opcodes.LSUB:
        b.append("    SP--; SP[-1].data.l = (SP[-1].data.l - (*SP).data.l); /* LSUB */\n");
        break;

    case Opcodes.FSUB:
        b.append("    SP--; SP[-1].data.f = (SP[-1].data.f - (*SP).data.f); /* FSUB */\n");
        break;

    case Opcodes.DSUB:
        b.append("    SP--; SP[-1].data.d = (SP[-1].data.d - (*SP).data.d); /* DSUB */\n");
        break;

    case Opcodes.IMUL:
        b.append("    SP--; SP[-1].data.i = SP[-1].data.i * (*SP).data.i; /* IMUL */\n");
        break;

    case Opcodes.LMUL:
        b.append("    SP--; SP[-1].data.l = SP[-1].data.l * (*SP).data.l; /* LMUL */\n");
        break;

    case Opcodes.FMUL:
        b.append("    SP--; SP[-1].data.f = SP[-1].data.f * (*SP).data.f; /* FMUL */\n");
        break;

    case Opcodes.DMUL:
        b.append("    SP--; SP[-1].data.d = SP[-1].data.d * (*SP).data.d; /* DMUL */\n");
        break;

    case Opcodes.IDIV:
        b.append("    SP--; SP[-1].data.i = SP[-1].data.i / (*SP).data.i; /* IDIV */\n");
        break;

    case Opcodes.LDIV:
        b.append("    SP--; SP[-1].data.l = SP[-1].data.l / (*SP).data.l; /* LDIV */\n");
        break;

    case Opcodes.FDIV:
        b.append("    SP--; SP[-1].data.f = SP[-1].data.f / (*SP).data.f; /* FDIV */\n");
        break;

    case Opcodes.DDIV:
        b.append("    SP--; SP[-1].data.d = SP[-1].data.d / (*SP).data.d; /* DDIV */\n");
        break;

    case Opcodes.IREM:
        b.append("    SP--; SP[-1].data.i = SP[-1].data.i % (*SP).data.i; /* IREM */\n");
        break;

    case Opcodes.LREM:
        b.append("    SP--; SP[-1].data.l = SP[-1].data.l % (*SP).data.l; /* LREM */\n");
        break;

    case Opcodes.FREM:
        b.append("    SP--; SP[-1].data.f = fmod(SP[-1].data.f, (*SP).data.f); /* FREM */\n");
        break;

    case Opcodes.DREM:
        b.append("    SP--; SP[-1].data.d = fmod(SP[-1].data.d, (*SP).data.d); /* DREM */\n");
        break;

    case Opcodes.INEG:
        b.append("    SP[-1].data.i *= -1; /* INEG */\n");
        break;

    case Opcodes.LNEG:
        b.append("    SP[-1].data.l *= -1; /* LNEG */\n");
        break;

    case Opcodes.FNEG:
        b.append("    SP[-1].data.f *= -1; /* FNEG */\n");
        break;

    case Opcodes.DNEG:
        b.append("    SP[-1].data.d *= -1; /* DNEG */\n");
        break;

    case Opcodes.ISHL:
        b.append("    SP--; SP[-1].data.i = (SP[-1].data.i << (0x1f & (*SP).data.i)); /* ISHL */\n");
        break;

    case Opcodes.LSHL:
        b.append("    SP--; SP[-1].data.l = (SP[-1].data.l << (0x3f & (*SP).data.i)); /* LSHL */\n");
        break;

    case Opcodes.ISHR:
        b.append("    SP--; SP[-1].data.i = (SP[-1].data.i >> (0x1f & (*SP).data.i)); /* ISHR */\n");
        break;

    case Opcodes.LSHR:
        b.append("    SP--; SP[-1].data.l = (SP[-1].data.l >> (0x3f & (*SP).data.l)); /* LSHR */\n");
        break;

    case Opcodes.IUSHR:
        b.append(
                "    SP--; SP[-1].data.i = (((unsigned int)SP[-1].data.i) >> (0x1f & ((unsigned int)(*SP).data.i))); /* IUSHR */\n");
        break;

    case Opcodes.LUSHR:
        b.append(
                "    SP--; SP[-1].data.l = (((unsigned long long)SP[-1].data.l) >> (0x3f & ((unsigned long long)(*SP).data.i))); /* LUSHR */\n");
        break;

    case Opcodes.IAND:
        b.append("    SP--; SP[-1].data.i = SP[-1].data.i & (*SP).data.i; /* IAND */\n");
        break;

    case Opcodes.LAND:
        b.append("    SP--; SP[-1].data.l = SP[-1].data.l & (*SP).data.l; /* LAND */\n");
        break;

    case Opcodes.IOR:
        b.append("    SP--; SP[-1].data.i = SP[-1].data.i | (*SP).data.i; /* IOR */\n");
        break;

    case Opcodes.LOR:
        b.append("    SP--; SP[-1].data.l = SP[-1].data.l | (*SP).data.l; /* LOR */\n");
        break;

    case Opcodes.IXOR:
        b.append("    SP--; SP[-1].data.i = SP[-1].data.i ^ (*SP).data.i; /* IXOR */\n");
        break;

    case Opcodes.LXOR:
        b.append("    SP--; SP[-1].data.l = SP[-1].data.l ^ (*SP).data.l; /* LXOR */\n");
        break;

    case Opcodes.I2L:
        b.append("    SP[-1].data.l = SP[-1].data.i; /* I2L */\n");
        break;

    case Opcodes.I2F:
        b.append("    SP[-1].data.f = (JAVA_FLOAT)SP[-1].data.i; /* I2F */\n");
        break;

    case Opcodes.I2D:
        b.append("    SP[-1].data.d = SP[-1].data.i; /* I2D */;\n");
        break;

    case Opcodes.L2I:
        b.append("    SP[-1].data.i = (JAVA_INT)SP[-1].data.l; /* L2I */\n");
        break;

    case Opcodes.L2F:
        b.append("    SP[-1].data.f = (JAVA_FLOAT)SP[-1].data.l; /* L2F */\n");
        break;

    case Opcodes.L2D:
        b.append("    SP[-1].data.d = (JAVA_DOUBLE)SP[-1].data.l; /* L2D */\n");
        break;

    case Opcodes.F2I:
        b.append("    SP[-1].data.i = (JAVA_INT)SP[-1].data.f; /* F2I */\n");
        break;

    case Opcodes.F2L:
        b.append("    SP[-1].data.l = (JAVA_LONG)SP[-1].data.f; /* F2L */\n");
        break;

    case Opcodes.F2D:
        b.append("    SP[-1].data.d = SP[-1].data.f; /* F2D */\n");
        break;

    case Opcodes.D2I:
        b.append("    SP[-1].data.i = (JAVA_INT)SP[-1].data.d; /* D2I */\n");
        break;

    case Opcodes.D2L:
        b.append("    SP[-1].data.l = (JAVA_LONG)SP[-1].data.d; /* D2L */\n");
        break;

    case Opcodes.D2F:
        b.append("    SP[-1].data.f = (JAVA_FLOAT)SP[-1].data.d; /* D2F */\n");
        break;

    case Opcodes.I2B:
        b.append("    SP[-1].data.i = ((SP[-1].data.i << 24) >> 24); /* I2B */\n");
        break;

    case Opcodes.I2C:
        b.append("    SP[-1].data.i = (SP[-1].data.i & 0xffff); /* I2C */\n");
        break;

    case Opcodes.I2S:
        b.append("    SP[-1].data.i = ((SP[-1].data.i << 16) >> 16); /* I2S */\n");
        break;

    case Opcodes.LCMP:
        b.append("    BC_LCMP();\n");
        break;

    case Opcodes.FCMPG:
    case Opcodes.FCMPL:
        b.append("    BC_FCMPL();\n");
        break;

    case Opcodes.DCMPL:
    case Opcodes.DCMPG:
        b.append("    BC_DCMPL();\n");
        break;

    case Opcodes.IRETURN:
        appendSynchronized(b);

        if (TryCatch.isTryCatchInMethod()) {
            b.append(
                    "    releaseForReturnInException(threadStateData, cn1LocalsBeginInThread, methodBlockOffset); return SP[-1].data.i;\n");
            //                    b.append(maxLocals);
            //                    b.append(", stack, locals, methodBlockOffset); \n    return SP[-1].data.i;\n");
        } else {
            b.append("    releaseForReturn(threadStateData, cn1LocalsBeginInThread); return SP[-1].data.i;\n");
            //                    b.append(maxLocals);
            //                    b.append(", stack, locals); \n    return SP[-1].data.i;\n");
        }
        break;

    case Opcodes.LRETURN:
        appendSynchronized(b);

        if (TryCatch.isTryCatchInMethod()) {
            b.append(
                    "    releaseForReturnInException(threadStateData, cn1LocalsBeginInThread, methodBlockOffset); \n    return POP_LONG();\n");
        } else {
            b.append(
                    "    releaseForReturn(threadStateData, cn1LocalsBeginInThread); \n    return POP_LONG();\n");
        }
        break;

    case Opcodes.FRETURN:
        appendSynchronized(b);

        if (TryCatch.isTryCatchInMethod()) {
            b.append(
                    "    releaseForReturnInException(threadStateData, cn1LocalsBeginInThread, methodBlockOffset); \n    return POP_FLOAT();\n");
        } else {
            b.append(
                    "    releaseForReturn(threadStateData, cn1LocalsBeginInThread); \n    return POP_FLOAT();\n");
        }
        break;

    case Opcodes.DRETURN:
        appendSynchronized(b);

        if (TryCatch.isTryCatchInMethod()) {
            b.append(
                    "    releaseForReturnInException(threadStateData, cn1LocalsBeginInThread, methodBlockOffset); \n    return POP_DOUBLE();\n");
        } else {
            b.append(
                    "    releaseForReturn(threadStateData, cn1LocalsBeginInThread); \n    return POP_DOUBLE();\n");
        }
        break;

    case Opcodes.ARETURN:
        appendSynchronized(b);

        if (TryCatch.isTryCatchInMethod()) {
            b.append(
                    "    releaseForReturnInException(threadStateData, cn1LocalsBeginInThread, methodBlockOffset); \n    return POP_OBJ();\n");
        } else {
            b.append(
                    "    releaseForReturn(threadStateData, cn1LocalsBeginInThread); \n    return POP_OBJ();\n");
        }
        break;

    case Opcodes.RETURN:
        appendSynchronized(b);

        if (!hasInstructions) {
            b.append("    return;\n");
            break;
        }
        if (TryCatch.isTryCatchInMethod()) {
            b.append(
                    "    releaseForReturnInException(threadStateData, cn1LocalsBeginInThread, methodBlockOffset); \n    return;\n");
        } else {
            b.append("    releaseForReturn(threadStateData, cn1LocalsBeginInThread); \n    return;\n");
        }
        break;

    case Opcodes.ARRAYLENGTH:
        b.append("    { /* ARRAYLENGTH */\n" + "        if(SP[-1].data.o == JAVA_NULL) { \n"
                + "            throwException(threadStateData, __NEW_INSTANCE_java_lang_NullPointerException(threadStateData)); \n"
                + "        }; \n" + "        SP[-1].type = CN1_TYPE_INT; \n"
                + "        SP[-1].data.i = (*((JAVA_ARRAY)SP[-1].data.o)).length; \n" + "    }\n");
        break;

    case Opcodes.ATHROW:
        //b.append("    NSLog(@\"Exception thrown %s %d %s %s\\n\", __FILE__, __LINE__, __PRETTY_FUNCTION__, __FUNCTION__);\n");
        b.append("    throwException(threadStateData, POP_OBJ());\n");
        break;

    case Opcodes.MONITORENTER:
        b.append("    monitorEnter(threadStateData, POP_OBJ());\n");
        break;

    case Opcodes.MONITOREXIT:
        b.append("    monitorExit(threadStateData, POP_OBJ());\n");
        break;

    // int instructions
    case Opcodes.SIPUSH:
    case Opcodes.BIPUSH:
        b.append("    PUSH_INT(");
        b.append(value);
        b.append(");\n");
        break;

    case Opcodes.NEWARRAY:
        switch (value) {
        case 4: // boolean
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_BOOLEAN, sizeof(JAVA_ARRAY_BOOLEAN), 1));\n");
            break;
        case 5: // char
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_CHAR, sizeof(JAVA_ARRAY_CHAR), 1));\n");
            break;
        case 6: // float
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_FLOAT, sizeof(JAVA_ARRAY_FLOAT), 1));\n");
            break;
        case 7: // double
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_DOUBLE, sizeof(JAVA_ARRAY_DOUBLE), 1));\n");
            break;
        case 8: // byte
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_BYTE, sizeof(JAVA_ARRAY_BYTE), 1));\n");
            break;
        case 9: // short
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_SHORT, sizeof(JAVA_ARRAY_SHORT), 1));\n");
            break;
        case 10: // int
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_INT, sizeof(JAVA_ARRAY_INT), 1));\n");
            break;
        case 11: // long 
            b.append(
                    "    SP--; PUSH_OBJ(allocArray(threadStateData, (*SP).data.i, &class_array1__JAVA_LONG, sizeof(JAVA_ARRAY_LONG), 1));\n");
            break;
        }
        break;
    }
}

From source file:com.codename1.tools.translator.Util.java

License:Open Source License

public static char[] getStackInputTypes(Instruction instr) {
    char[] out = instr.getStackInputTypes();
    if (out != null) {
        return out;
    }//w ww .j  ava 2s .  co m

    switch (instr.getOpcode()) {

    case Opcodes.NOP:
    case Opcodes.ACONST_NULL:
    case Opcodes.ICONST_M1:
    case Opcodes.ICONST_0:
    case Opcodes.ICONST_2:
    case Opcodes.ICONST_3:
    case Opcodes.ICONST_4:
    case Opcodes.ICONST_5:
    case Opcodes.LCONST_0:
    case Opcodes.LCONST_1:
    case Opcodes.FCONST_0:
    case Opcodes.FCONST_1:
    case Opcodes.FCONST_2:
    case Opcodes.DCONST_0:
    case Opcodes.DCONST_1:
    case Opcodes.SIPUSH:
    case Opcodes.BIPUSH:
        return new char[0];
    case Opcodes.BALOAD:
    case Opcodes.CALOAD:
    case Opcodes.IALOAD:
    case Opcodes.SALOAD:
    case Opcodes.LALOAD:
    case Opcodes.FALOAD:
    case Opcodes.DALOAD:
    case Opcodes.AALOAD:
        return new char[] { 'i', 'o' };

    case Opcodes.BASTORE:
    case Opcodes.CASTORE:
    case Opcodes.SASTORE:
    case Opcodes.IASTORE:
        return new char[] { 'i', 'i', 'o' };
    case Opcodes.LASTORE:
        return new char[] { 'l', 'i', 'o' };
    case Opcodes.FASTORE:
        return new char[] { 'f', 'i', 'o' };
    case Opcodes.DASTORE:
        return new char[] { 'd', 'i', 'o' };
    case Opcodes.AASTORE:
        return new char[] { 'o', 'i', 'o' };

    case Opcodes.POP:
        return new char[] { '*' };

    case Opcodes.POP2:
        return new char[] { '*', '*' };

    case Opcodes.DUP:
        return new char[] { '0' };

    case Opcodes.DUP2:
    case Opcodes.DUP_X2:
    case Opcodes.DUP2_X2:
        return null; // DUP2 depends on the types on the stack so we don't statically know the input types

    case Opcodes.DUP_X1:
    case Opcodes.DUP2_X1:
        return new char[] { '0', '1' };
    case Opcodes.SWAP:
        return new char[] { '0', '1' };
    case Opcodes.IADD:
    case Opcodes.ISUB:
    case Opcodes.IMUL:
    case Opcodes.IDIV:
    case Opcodes.IREM:
    case Opcodes.ISHL:
    case Opcodes.ISHR:
    case Opcodes.IUSHR:
    case Opcodes.IAND:
    case Opcodes.IOR:
    case Opcodes.IXOR:
        return new char[] { 'i', 'i' };

    case Opcodes.LADD:
    case Opcodes.LSUB:
    case Opcodes.LMUL:
    case Opcodes.LDIV:
    case Opcodes.LREM:
    case Opcodes.LSHL:
    case Opcodes.LSHR:
    case Opcodes.LAND:
    case Opcodes.LOR:
    case Opcodes.LXOR:
    case Opcodes.LCMP:
        return new char[] { 'l', 'l' };
    case Opcodes.FADD:
    case Opcodes.FSUB:
    case Opcodes.FMUL:
    case Opcodes.FDIV:
    case Opcodes.FREM:
    case Opcodes.FCMPG:
    case Opcodes.FCMPL:
        return new char[] { 'f', 'f' };
    case Opcodes.DADD:
    case Opcodes.DSUB:
    case Opcodes.DMUL:
    case Opcodes.DDIV:
    case Opcodes.DREM:
    case Opcodes.DCMPL:
    case Opcodes.DCMPG:
        return new char[] { 'd', 'd' };

    case Opcodes.INEG:
    case Opcodes.I2L:
    case Opcodes.I2F:
    case Opcodes.I2D:
    case Opcodes.I2B:
    case Opcodes.I2C:
    case Opcodes.I2S:
    case Opcodes.NEWARRAY:
        return new char[] { 'i' };
    case Opcodes.LNEG:
    case Opcodes.L2I:
    case Opcodes.L2F:
    case Opcodes.L2D:
        return new char[] { 'l' };

    case Opcodes.FNEG:
    case Opcodes.F2I:
    case Opcodes.F2L:
    case Opcodes.F2D:
        return new char[] { 'f' };
    case Opcodes.DNEG:
    case Opcodes.D2I:
    case Opcodes.D2L:
    case Opcodes.D2F:
        return new char[] { 'd' };
    case Opcodes.LUSHR:
        return new char[] { 'i', 'l' };

    case Opcodes.ARRAYLENGTH:
    case Opcodes.MONITORENTER:
    case Opcodes.MONITOREXIT:
    case Opcodes.ATHROW:
        return new char[] { 'o' };
    default:
        return null;

    }

}

From source file:com.codename1.tools.translator.Util.java

License:Open Source License

public static char[] getStackOutputTypes(Instruction instr) {
    char[] out = instr.getStackOutputTypes();
    if (out != null) {
        return out;
    }/*  w w w  . j av a 2  s  .co m*/

    switch (instr.getOpcode()) {
    case Opcodes.NOP:
    case Opcodes.BASTORE:
    case Opcodes.CASTORE:
    case Opcodes.SASTORE:
    case Opcodes.IASTORE:
    case Opcodes.LASTORE:
    case Opcodes.FASTORE:
    case Opcodes.DASTORE:
    case Opcodes.AASTORE:
    case Opcodes.POP:
    case Opcodes.POP2:
    case Opcodes.MONITORENTER:
    case Opcodes.MONITOREXIT:
    case Opcodes.ATHROW:
        return new char[0];

    case Opcodes.ACONST_NULL:
    case Opcodes.AALOAD:
    case Opcodes.NEWARRAY:
        return new char[] { 'o' };

    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:
    case Opcodes.BALOAD:
    case Opcodes.CALOAD:
    case Opcodes.IALOAD:
    case Opcodes.SALOAD:
    case Opcodes.IADD:
    case Opcodes.ISUB:
    case Opcodes.IMUL:
    case Opcodes.IDIV:
    case Opcodes.IREM:
    case Opcodes.INEG:
    case Opcodes.ISHL:
    case Opcodes.ISHR:
    case Opcodes.IUSHR:
    case Opcodes.IAND:
    case Opcodes.IOR:
    case Opcodes.IXOR:
    case Opcodes.F2I:
    case Opcodes.D2I:
    case Opcodes.L2I:
    case Opcodes.I2C:
    case Opcodes.I2S:
    case Opcodes.LCMP:
    case Opcodes.FCMPG:
    case Opcodes.FCMPL:
    case Opcodes.DCMPL:
    case Opcodes.DCMPG:
    case Opcodes.ARRAYLENGTH:
    case Opcodes.SIPUSH:
    case Opcodes.BIPUSH:
        return new char[] { 'i' };
    case Opcodes.LCONST_0:
    case Opcodes.LCONST_1:
    case Opcodes.LALOAD:
    case Opcodes.LADD:
    case Opcodes.LSUB:
    case Opcodes.LMUL:
    case Opcodes.LDIV:
    case Opcodes.LREM:
    case Opcodes.LNEG:
    case Opcodes.LSHL:
    case Opcodes.LSHR:
    case Opcodes.LUSHR:
    case Opcodes.LAND:
    case Opcodes.LOR:
    case Opcodes.LXOR:
    case Opcodes.I2L:
    case Opcodes.F2L:
    case Opcodes.D2L:
        return new char[] { 'l' };
    case Opcodes.FCONST_0:
    case Opcodes.FCONST_1:
    case Opcodes.FCONST_2:
    case Opcodes.FALOAD:
    case Opcodes.FADD:
    case Opcodes.FSUB:
    case Opcodes.FMUL:
    case Opcodes.FDIV:
    case Opcodes.FREM:
    case Opcodes.FNEG:
    case Opcodes.I2F:
    case Opcodes.D2F:
    case Opcodes.L2F:
        return new char[] { 'f' };
    case Opcodes.DCONST_0:
    case Opcodes.DCONST_1:
    case Opcodes.DALOAD:
    case Opcodes.DADD:
    case Opcodes.DSUB:
    case Opcodes.DMUL:
    case Opcodes.DDIV:
    case Opcodes.DREM:
    case Opcodes.DNEG:
    case Opcodes.I2D:
    case Opcodes.F2D:
    case Opcodes.L2D:
        return new char[] { 'd' };
    case Opcodes.DUP:
        return new char[] { '0', '0' };

    case Opcodes.DUP2:
    case Opcodes.DUP_X2:
    case Opcodes.DUP2_X2:
        return null;

    case Opcodes.DUP_X1:
    case Opcodes.DUP2_X1:
        return new char[] { '0', '1', '0' };
    case Opcodes.SWAP:
        return new char[] { '1', '0' };

    default:
        return null;
    }

}

From source file:com.friz.instruction.visitor.impl.SubtractionVisitor.java

License:Open Source License

@Override
public void visitArithmetic(ArithmeticInstruction arithmetic) {
    if (arithmetic.isSubtraction()) {
        if (InstructionUtil.isStaticPush(arithmetic.second())) {
            // var - #
            // switch var - -# to var + #
            if (arithmetic.isInt()) {
                int val = InstructionUtil.getNumericPush(arithmetic.second()).intValue();
                int valv = Math.abs(val);
                if (val != valv) {
                    arithmetic.set(new InsnNode(Opcodes.IADD));
                    arithmetic.replace(InstructionUtil.createNumericPush(valv), false);
                    count++;// w  w w .j  av  a 2  s. c  om
                }
            } else if (arithmetic.isLong()) {
                long val = InstructionUtil.getNumericPush(arithmetic.second()).longValue();
                long valv = Math.abs(val);
                if (val != valv) {
                    arithmetic.set(new InsnNode(Opcodes.LADD));
                    arithmetic.replace(InstructionUtil.createNumericPush(valv), false);
                    count++;
                }
            } else if (arithmetic.isFloat()) {
                float val = InstructionUtil.getNumericPush(arithmetic.second()).floatValue();
                float valv = Math.abs(val);
                if (val != valv) {
                    arithmetic.set(new InsnNode(Opcodes.FADD));
                    arithmetic.replace(InstructionUtil.createNumericPush(valv), false);
                    count++;
                }
            } else if (arithmetic.isDouble()) {
                double val = InstructionUtil.getNumericPush(arithmetic.second()).doubleValue();
                double valv = Math.abs(val);
                if (val != valv) {
                    arithmetic.set(new InsnNode(Opcodes.DADD));
                    arithmetic.replace(InstructionUtil.createNumericPush(valv), false);
                    count++;
                }
            }
        }
    }
}

From source file:com.github.anba.es6draft.compiler.assembler.InstructionAssembler.java

License:Open Source License

public final void add(Type type) {
    switch (type.getOpcode(Opcodes.IADD)) {
    case Opcodes.IADD:
        iadd();//  w w  w  . j  a  va  2s.c o  m
        return;
    case Opcodes.LADD:
        ladd();
        return;
    case Opcodes.FADD:
        fadd();
        return;
    case Opcodes.DADD:
        dadd();
        return;
    default:
        throw new IllegalArgumentException();
    }
}

From source file:com.github.anba.es6draft.compiler.assembler.InstructionAssembler.java

License:Open Source License

public void iadd() {
    methodVisitor.visitInsn(Opcodes.IADD);
    stack.iadd();
}

From source file:com.google.code.jconts.instrument.gen.ContinuationClassGenerator.java

License:Apache License

private void generateExecute(ClassVisitor cv, boolean execute) {
    final String name = info.continuationClassName;
    final Type outerType = Type.getObjectType(info.owner);

    // Generate invoke(T result);
    String signature = null;//ww w.  j a v a  2s  .  c  o  m
    if (execute) {
        SignatureWriter sign = new SignatureWriter();
        sign.visitParameterType().visitTypeVariable("T");
        sign.visitReturnType().visitBaseType('V'); // void
        signature = sign.toString();
    }
    MethodVisitor mv = cv.visitMethod(Opcodes.ACC_FINAL | Opcodes.ACC_PUBLIC,
            execute ? CONTINUATION_INVOKE_NAME : CONTINUATION_SET_EXCEPTION_NAME,
            execute ? CONTINUATION_INVOKE_DESC : CONTINUATION_SET_EXCEPTION_DESC, signature, null);
    mv.visitCode();
    Label start = new Label();
    Label end = new Label();
    mv.visitLabel(start);

    // Load outer this
    if (!info.isStatic()) {
        mv.visitVarInsn(Opcodes.ALOAD, 0);
        mv.visitFieldInsn(Opcodes.GETFIELD, name, "this$0", outerType.getDescriptor());
    }

    // state.result = result or state.exception = throwable
    mv.visitVarInsn(Opcodes.ALOAD, 0);
    mv.visitFieldInsn(Opcodes.GETFIELD, name, "state", stateDesc);
    mv.visitVarInsn(Opcodes.ALOAD, 1);
    mv.visitFieldInsn(Opcodes.PUTFIELD, info.stateClassName, execute ? "result" : "exception",
            execute ? OBJECT_DESC : THROWABLE_DESC);

    // Load state field
    mv.visitVarInsn(Opcodes.ALOAD, 0);
    mv.visitFieldInsn(Opcodes.GETFIELD, name, "state", stateDesc);

    // Continue from this index or index+1 (for exception)
    mv.visitVarInsn(Opcodes.ALOAD, 0);
    mv.visitFieldInsn(Opcodes.GETFIELD, name, "index", "I");
    if (!execute) {
        mv.visitInsn(Opcodes.ICONST_1);
        mv.visitInsn(Opcodes.IADD);
    }

    mv.visitMethodInsn(info.isStatic() ? Opcodes.INVOKESTATIC : Opcodes.INVOKEVIRTUAL, info.owner,
            info.name + "$async",
            Type.getMethodDescriptor(Type.VOID_TYPE, new Type[] { info.stateType, Type.INT_TYPE }));

    mv.visitInsn(Opcodes.RETURN);
    mv.visitLabel(end);

    mv.visitLocalVariable("this", 'L' + name + ';', signature, start, end, 0);
    if (!info.isStatic()) {
        mv.visitLocalVariable("this$0", outerType.getDescriptor(), null, start, end, 1);
    }
    mv.visitLocalVariable("result", OBJECT_DESC, "TT;", start, end, 1 + info.thisOffset);

    mv.visitMaxs(3 + info.thisOffset + (execute ? 0 : 1), 2 + info.thisOffset);
    mv.visitEnd();
}

From source file:com.google.devtools.build.android.desugar.BytecodeTypeInference.java

License:Open Source License

@Override
public void visitInsn(int opcode) {
    switch (opcode) {
    case Opcodes.NOP:
    case Opcodes.INEG:
    case Opcodes.LNEG:
    case Opcodes.FNEG:
    case Opcodes.DNEG:
    case Opcodes.I2B:
    case Opcodes.I2C:
    case Opcodes.I2S:
    case Opcodes.RETURN:
        break;//  w  ww .  j ava  2 s. c  o  m
    case Opcodes.ACONST_NULL:
        push(InferredType.NULL);
        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:
        push(InferredType.INT);
        break;
    case Opcodes.LCONST_0:
    case Opcodes.LCONST_1:
        push(InferredType.LONG);
        push(InferredType.TOP);
        break;
    case Opcodes.FCONST_0:
    case Opcodes.FCONST_1:
    case Opcodes.FCONST_2:
        push(InferredType.FLOAT);
        break;
    case Opcodes.DCONST_0:
    case Opcodes.DCONST_1:
        push(InferredType.DOUBLE);
        push(InferredType.TOP);
        break;
    case Opcodes.IALOAD:
    case Opcodes.BALOAD:
    case Opcodes.CALOAD:
    case Opcodes.SALOAD:
        pop(2);
        push(InferredType.INT);
        break;
    case Opcodes.LALOAD:
    case Opcodes.D2L:
        pop(2);
        push(InferredType.LONG);
        push(InferredType.TOP);
        break;
    case Opcodes.DALOAD:
    case Opcodes.L2D:
        pop(2);
        push(InferredType.DOUBLE);
        push(InferredType.TOP);
        break;
    case Opcodes.AALOAD:
        InferredType arrayType = pop(2);
        InferredType elementType = arrayType.getElementTypeIfArrayOrThrow();
        push(elementType);
        break;
    case Opcodes.IASTORE:
    case Opcodes.BASTORE:
    case Opcodes.CASTORE:
    case Opcodes.SASTORE:
    case Opcodes.FASTORE:
    case Opcodes.AASTORE:
        pop(3);
        break;
    case Opcodes.LASTORE:
    case Opcodes.DASTORE:
        pop(4);
        break;
    case Opcodes.POP:
    case Opcodes.IRETURN:
    case Opcodes.FRETURN:
    case Opcodes.ARETURN:
    case Opcodes.ATHROW:
    case Opcodes.MONITORENTER:
    case Opcodes.MONITOREXIT:
        pop();
        break;
    case Opcodes.POP2:
    case Opcodes.LRETURN:
    case Opcodes.DRETURN:
        pop(2);
        break;
    case Opcodes.DUP:
        push(top());
        break;
    case Opcodes.DUP_X1: {
        InferredType top = pop();
        InferredType next = pop();
        push(top);
        push(next);
        push(top);
        break;
    }
    case Opcodes.DUP_X2: {
        InferredType top = pop();
        InferredType next = pop();
        InferredType bottom = pop();
        push(top);
        push(bottom);
        push(next);
        push(top);
        break;
    }
    case Opcodes.DUP2: {
        InferredType top = pop();
        InferredType next = pop();
        push(next);
        push(top);
        push(next);
        push(top);
        break;
    }
    case Opcodes.DUP2_X1: {
        InferredType top = pop();
        InferredType next = pop();
        InferredType bottom = pop();
        push(next);
        push(top);
        push(bottom);
        push(next);
        push(top);
        break;
    }
    case Opcodes.DUP2_X2: {
        InferredType t1 = pop();
        InferredType t2 = pop();
        InferredType t3 = pop();
        InferredType t4 = pop();
        push(t2);
        push(t1);
        push(t4);
        push(t3);
        push(t2);
        push(t1);
        break;
    }
    case Opcodes.SWAP: {
        InferredType top = pop();
        InferredType next = pop();
        push(top);
        push(next);
        break;
    }
    case Opcodes.IADD:
    case Opcodes.ISUB:
    case Opcodes.IMUL:
    case Opcodes.IDIV:
    case Opcodes.IREM:
    case Opcodes.ISHL:
    case Opcodes.ISHR:
    case Opcodes.IUSHR:
    case Opcodes.IAND:
    case Opcodes.IOR:
    case Opcodes.IXOR:
    case Opcodes.L2I:
    case Opcodes.D2I:
    case Opcodes.FCMPL:
    case Opcodes.FCMPG:
        pop(2);
        push(InferredType.INT);
        break;

    case Opcodes.LADD:
    case Opcodes.LSUB:
    case Opcodes.LMUL:
    case Opcodes.LDIV:
    case Opcodes.LREM:
    case Opcodes.LAND:
    case Opcodes.LOR:
    case Opcodes.LXOR:
        pop(4);
        push(InferredType.LONG);
        push(InferredType.TOP);
        break;

    case Opcodes.LSHL:
    case Opcodes.LSHR:
    case Opcodes.LUSHR:
        pop(3);
        push(InferredType.LONG);
        push(InferredType.TOP);
        break;
    case Opcodes.I2L:
    case Opcodes.F2L:
        pop();
        push(InferredType.LONG);
        push(InferredType.TOP);
        break;
    case Opcodes.I2F:
        pop();
        push(InferredType.FLOAT);
        break;

    case Opcodes.LCMP:
    case Opcodes.DCMPG:
    case Opcodes.DCMPL:
        pop(4);
        push(InferredType.INT);
        break;

    case Opcodes.I2D:
    case Opcodes.F2D:
        pop();
        push(InferredType.DOUBLE);
        push(InferredType.TOP);
        break;
    case Opcodes.F2I:
    case Opcodes.ARRAYLENGTH:
        pop();
        push(InferredType.INT);
        break;
    case Opcodes.FALOAD:
    case Opcodes.FADD:
    case Opcodes.FSUB:
    case Opcodes.FMUL:
    case Opcodes.FDIV:
    case Opcodes.FREM:
    case Opcodes.L2F:
    case Opcodes.D2F:
        pop(2);
        push(InferredType.FLOAT);
        break;

    case Opcodes.DADD:
    case Opcodes.DSUB:
    case Opcodes.DMUL:
    case Opcodes.DDIV:
    case Opcodes.DREM:
        pop(4);
        push(InferredType.DOUBLE);
        push(InferredType.TOP);
        break;
    default:
        throw new RuntimeException("Unhandled opcode " + opcode);
    }
    super.visitInsn(opcode);
}

From source file:com.google.template.soy.jbcsrc.SoyNodeCompiler.java

License:Apache License

/**
 * Interprets the given expressions as the arguments of a {@code range(...)} expression in a
 * {@code for} loop.//from w  ww  .  jav a2 s. c o  m
 */
private CompiledRangeArgs calculateRangeArgs(ForNode forNode, Scope scope) {
    RangeArgs rangeArgs = forNode.getRangeArgs();

    final ImmutableList.Builder<Statement> initStatements = ImmutableList.builder();
    final Variable currentIndex;
    if (rangeArgs.start().isPresent()) {
        Label startDetachPoint = new Label();
        Expression startIndex = MethodRef.INTS_CHECKED_CAST
                .invoke(exprCompiler.compile(rangeArgs.start().get(), startDetachPoint).unboxAs(long.class));
        currentIndex = scope.create(forNode.getVarName(), startIndex, STORE);
        initStatements.add(currentIndex.initializer().labelStart(startDetachPoint));
    } else {
        currentIndex = scope.create(forNode.getVarName(), constant(0), STORE);
        initStatements.add(currentIndex.initializer());
    }

    final Statement incrementCurrentIndex;
    if (rangeArgs.increment().isPresent()) {
        Label detachPoint = new Label();
        Expression increment = MethodRef.INTS_CHECKED_CAST
                .invoke(exprCompiler.compile(rangeArgs.increment().get(), detachPoint).unboxAs(long.class));
        // If the expression is non-trivial, make sure to save it to a field.
        final Variable incrementVariable = scope.createSynthetic(SyntheticVarName.forLoopIncrement(forNode),
                increment, increment.isCheap() ? DERIVED : STORE);
        initStatements.add(incrementVariable.initializer().labelStart(detachPoint));
        incrementVariable.local();
        incrementCurrentIndex = new Statement() {
            @Override
            void doGen(CodeBuilder adapter) {
                currentIndex.local().gen(adapter);
                incrementVariable.local().gen(adapter);
                adapter.visitInsn(Opcodes.IADD);
                adapter.visitVarInsn(Opcodes.ISTORE, currentIndex.local().index());
            }
        };
    } else {
        incrementCurrentIndex = new Statement() {
            @Override
            void doGen(CodeBuilder adapter) {
                adapter.iinc(currentIndex.local().index(), 1);
            }
        };
    }

    Label detachPoint = new Label();
    Expression limit = MethodRef.INTS_CHECKED_CAST
            .invoke(exprCompiler.compile(rangeArgs.limit(), detachPoint).unboxAs(long.class));
    // If the expression is non-trivial we should cache it in a local variable
    Variable variable = scope.createSynthetic(SyntheticVarName.forLoopLimit(forNode), limit,
            limit.isCheap() ? DERIVED : STORE);
    initStatements.add(variable.initializer().labelStart(detachPoint));
    limit = variable.local();

    return new AutoValue_SoyNodeCompiler_CompiledRangeArgs(currentIndex.local(), limit, incrementCurrentIndex,
            initStatements.build());
}