sparcjitcodegen.java

java 到c的转换程序的原代码.对喜欢C程序而不懂JAVA程序的人很有帮助

                break;
            case Opcode.INT2BYTE:
                code.ST ("%l0", "%fp", - (overheadSize + SPARC.ALUFPUXFERSIZE));
                code.LDSB ("%fp", 3 - (overheadSize + SPARC.ALUFPUXFERSIZE), "%l0");
                break;
            case Opcode.INT2CHAR:
                code.ST ("%l0", "%fp", - (overheadSize + SPARC.ALUFPUXFERSIZE));
                code.LDUH ("%fp", 2 - (overheadSize + SPARC.ALUFPUXFERSIZE), "%l0");
                break;
            case Opcode.INT2SHORT:
                code.ST ("%l0", "%fp", - (overheadSize + SPARC.ALUFPUXFERSIZE));
                code.LDSH ("%fp", 2 - (overheadSize + SPARC.ALUFPUXFERSIZE), "%l0");
                break;
                
            /* long operands: %l2 -> %l0 */
            case Opcode.LNEG:
                code.SUBcc ("%g0", "%l3", "%l1");
                code.SUBX ("%g0", "%l2", "%l0");
                break;
            case Opcode.L2I:
                code.MOV ("%l3", "%l0");
                break;
            case Opcode.L2F:
            case Opcode.L2D:
                code.MOV ("%l2", "%o0");
                code.MOV ("%l3", "%o1");
                code.reserveCode (CodeBlock.brACALL, i, "noreg",
                                  getFuncAddr ((Opcode.L2F == i.opcode.code) ? FID_long2f : FID_long2d));
                code.NOP ();
                break;

            /* Float operands: %f2 -> %f0 */
            case Opcode.FNEG:
                code.FNEGs ("%f2", "%f0");
                break;
            case Opcode.F2I:
                code.FsTOi ("%f2", "%f0");
                code.FpushES ("%f0");
                donestore = true;
                break;
            case Opcode.F2L:
                code.FsTOd ("%f2", "%f0");
                code.STDF ("%f0", "%fp", - (overheadSize + SPARC.ALUFPUXFERSIZE));
                code.LD ("%fp", - (overheadSize + SPARC.ALUFPUXFERSIZE), "%o0");
                code.LD ("%fp", 4 - (overheadSize + SPARC.ALUFPUXFERSIZE), "%o1");
                code.reserveCode (CodeBlock.brACALL, i, "noreg", getFuncAddr (FID_dtol));
                code.NOP ();
                code.LpushES ("%o0");
                donestore = true;
                break;
            case Opcode.F2D:
                code.FsTOd ("%f2", "%f0");
                break;
                
            /* Double operands: %f2 -> %f0 */
            case Opcode.DNEG:
                code.FNEGs ("%f2", "%f0");
                code.FMOVs ("%f3", "%f1");
                break;
            case Opcode.D2I:
                code.FdTOi ("%f2", "%f0");
                code.FpushES ("%f0");
                donestore = true;
                break;
            case Opcode.D2F:
                code.FdTOs ("%f2", "%f0");
                break;
            case Opcode.D2L:
                code.STDF ("%f2", "%fp", - (overheadSize + SPARC.ALUFPUXFERSIZE));
                code.LD ("%fp", - (overheadSize + SPARC.ALUFPUXFERSIZE), "%o0");
                code.LD ("%fp", 4 - (overheadSize + SPARC.ALUFPUXFERSIZE), "%o1");
                code.reserveCode (CodeBlock.brACALL, i, "noreg", getFuncAddr (FID_dtol));
                code.NOP ();
                code.LpushES ("%o0");
                donestore = true;
                break;
                
            default:
                throw new InternalError ("Unop code " + i.opcode + " not supported in JIT");
        }
        /* Store the result back on the execution stack, unless we did it
         * already (e.g., for float-to-int conversions) */
        if (! donestore) {
            if (opdtype.equals ("i")) {
                /* stack: %l0 -> val */
                code.pushES ("%l0");
            } else if (opdtype.equals ("f")) {
                /* stack: %f0 -> val */
                code.FpushES ("%f0");
            } else if (opdtype.equals ("xl")) {
                /* stack: %l0 -> val.w1 val.w2 */
                code.LpushES ("%l0");
            } else if (opdtype.equals ("xd")) {
                /* stack: %f0 -> val.w1 val.w2 */
                code.DpushES ("%f0");
            } else {
                throw new InternalError ("Bad type in binop.");
            }
        }
        return;
    }

    /** Emit code for a binary operation
      * @param i instruction for codegen
      */
    private void
    EmitBinOp (Instr i)
    {
        String opdtype;         // Type of operands of instruction

        opdtype = i.opcode.push;
        /* Load the operands into their registers.  Fortunately, no
         * binary operators are cast operators, so the output and input
         * types are the same.  Um, except for long shifts. */
        if (opdtype.equals ("i")) {
            /* stack: op1 op2  -> %l0 %l1 */
            code.popES ("%l1");
            code.popES ("%l0");
        } else if (opdtype.equals ("f")) {
            /* stack: op1 op2  -> %f2 %f3 */
            code.FpopES ("%f3");
            code.FpopES ("%f2");
        } else if (opdtype.equals ("xl")) {
            if ((Opcode.LSHL == i.opcode.code) ||
                (Opcode.LSHR == i.opcode.code) ||
                (Opcode.LUSHR == i.opcode.code)) {
                /* stack: op1.w1 op1.w2 op2 -> %o0 %o2 */
                /* We're going to call a function to do these, so pop
                 * right into the outgoing args. */
                code.popES ("%o2");
                code.LpopES ("%o0");
            } else {
                /* stack: op1.w1 op1.w2 op2.w1 op2.w2  -> %l2 %l4 */
                code.LpopES ("%l4");
                code.LpopES ("%l2");
            }
        } else if (opdtype.equals ("xd")) {
            /* stack: op1.w1 op1.w2 op2.w1 op2.w2  -> %f2 %f4 */
            code.DpopES ("%f4");
            code.DpopES ("%f2");
        } else {
            throw new InternalError ("Bad type in binop.");
        }
        /* Emit the code to operate on the results */
        switch (i.opcode.code) {
            /* int operands: %l0 op %l1 -> %l0 */
            case Opcode.IADD:
                code.ADD ("%l0", "%l1", "%l0");
                break;
            case Opcode.ISUB:
                code.SUB ("%l0", "%l1", "%l0");
                break;
            case Opcode.IMUL:
                code.SMUL ("%l0", "%l1", "%l0");
                break;
            case Opcode.IREM:
            case Opcode.IDIV:
                /* We'll have to cheat until we get a v8 sparchitecture manual */
                code.MOV ("%l0", "%o0");
                code.MOV ("%l1", "%o1");
                code.reserveCode (CodeBlock.brACALL, i, "noreg",
                                  getFuncAddr ((Opcode.IREM == i.opcode.code) ? FID_intrem : FID_intdiv));
                code.NOP ();
                code.MOV ("%o0", "%l0");
                break;
            case Opcode.IAND:
                code.AND ("%l0", "%l1", "%l0");
                break;
            case Opcode.IOR:
                code.OR ("%l0", "%l1", "%l0");
                break;
            case Opcode.IXOR:
                code.XOR ("%l0", "%l1", "%l0");
                break;
            case Opcode.ISHL:
                code.SLL ("%l0", "%l1", "%l0");
                break;
            case Opcode.ISHR:
                code.SRA ("%l0", "%l1", "%l0");
                break;
            case Opcode.IUSHR:
                code.SRL ("%l0", "%l1", "%l0");
                break;
                
                /* long operands: %l2 op %l4 -> %l0 */
            case Opcode.LADD:
                code.ADDcc ("%l3", "%l5", "%l1");
                code.ADDX ("%l2", "%l4", "%l0");
                break;
            case Opcode.LSUB:
                code.SUBcc ("%l3", "%l5", "%l1");
                code.SUBX ("%l2", "%l4", "%l0");
                break;
            case Opcode.LMUL:
                /* This is the sequence that gcc -mv8 -O3 uses. */
                code.UMUL ("%l3", "%l5", "%l1");
                code.RDY ("%l0");
                code.SMUL ("%l3", "%l4", "%o7");
                code.ADD ("%l0", "%o7", "%l0");
                code.SMUL ("%l5", "%l2", "%l2");
                code.ADD ("%l0", "%l2", "%l0");
                break;
            case Opcode.LREM:
            case Opcode.LDIV:
                /* Everybody else does this with a function call; let's
                 * do it that way too. */
                code.MOV ("%l2", "%o0");
                code.MOV ("%l3", "%o1");
                code.MOV ("%l4", "%o2");
                code.MOV ("%l5", "%o3");
                code.reserveCode (CodeBlock.brACALL, i, "noreg",
                                  getFuncAddr ((Opcode.LREM == i.opcode.code) ? FID_longrem : FID_longdiv));
                code.NOP ();
                code.MOV ("%o0", "%l0");
                code.MOV ("%o1", "%l1");
                break;
            case Opcode.LAND:
                code.AND ("%l2", "%l4", "%l0");
                code.AND ("%l3", "%l5", "%l1");
                break;
            case Opcode.LOR:
                code.OR ("%l2", "%l4", "%l0");
                code.OR ("%l3", "%l5", "%l1");
                break;
            case Opcode.LXOR:
                code.XOR ("%l2", "%l4", "%l0");
                code.XOR ("%l3", "%l5", "%l1");
                break;
            case Opcode.LSHL:
            case Opcode.LSHR:
            case Opcode.LUSHR:
                /* Already have op1 and op2 into %o0, %o1, %o2, so put in
                 * the operator type, and call the function. */
                code.MOV (i.opcode.code, "%o3");
                code.reserveCode (CodeBlock.brACALL, i, "noreg", getFuncAddr (FID_longshift));
                code.NOP ();
                /* Move result back into local registers */
                code.MOV ("%o0", "%l0");
                code.MOV ("%o1", "%l1");
                break;

                /* Float operands: %f2 op %f3 -> %f0 */
            case Opcode.FADD:
                code.FADDs ("%f2", "%f3", "%f0");
                break;
            case Opcode.FSUB:
                code.FSUBs ("%f2", "%f3", "%f0");
                break;
            case Opcode.FMUL:
                code.FMULs ("%f2", "%f3", "%f0");
                break;
            case Opcode.FDIV:
                /*!! UNFINISHED -- check for divbyzero !!*/
                code.FDIVs ("%f2", "%f3", "%f0");
                break;
            case Opcode.FREM:
                /*!! UNFINISHED -- is this correct? !!*/
                /* Convert from single to double precision, and call
                 * the remdr function in toba */
                code.FsTOd ("%f2", "%f0");
                code.FsTOd ("%f3", "%f2");
                code.STDF ("%f0", "%fp", - (overheadSize + SPARC.ALUFPUXFERSIZE));
                code.LD ("%fp", - (overheadSize + SPARC.ALUFPUXFERSIZE), "%o0");
                code.LD ("%fp", 4 - (overheadSize + SPARC.ALUFPUXFERSIZE), "%o1");
                code.STDF ("%f2", "%fp", - (overheadSize + SPARC.ALUFPUXFERSIZE));
                code.LD ("%fp", - (overheadSize + SPARC.ALUFPUXFERSIZE), "%o2");
                code.LD ("%fp", 4 - (overheadSize + SPARC.ALUFPUXFERSIZE), "%o3");
                code.reserveCode (CodeBlock.brACALL, i, "noreg", getFuncAddr (FID_remdr));
                code.NOP ();
                code.FdTOs ("%f0", "%f0");
                break;

                /* Double operands: %f2 %f4 -> %f0 */
            case Opcode.DADD:
                code.FADDd ("%f2", "%f4", "%f0");
                break;
            case Opcode.DSUB:
                code.FSUBd ("%f2", "%f4", "%f0");
                break;
            case Opcode.DMUL:
                code.FMULd ("%f2", "%f4", "%f0");
                break;
            case Opcode.DDIV:
                /*!! UNFINISHED -- check for divbyzero !!*/
                code.FDIVd ("%f2", "%f4", "%f0");
                break;
            case Opcode.DREM:
                /* Call the remdr function in toba */
                code.STDF ("%f2", "%fp", - (overheadSize + SPARC.ALUFPUXFERSIZE));
                code.LD ("%fp", - (overheadSize + SPARC.ALUFPUXFERSIZE), "%o0");
                code.LD ("%fp", 4 - (overheadSize + SPARC.ALUFPUXFERSIZE), "%o1");
                code.STDF ("%f4", "%fp", - (overheadSize + SPARC.ALUFPUXFERSIZE));
                code.LD ("%fp", - (overheadSize + SPARC.ALUFPUXFERSIZE), "%o2");
                code.LD ("%fp", 4 - (overheadSize + SPARC.ALUFPUXFERSIZE), "%o3");
                code.reserveCode (CodeBlock.brACALL, i, "noreg", getFuncAddr (FID_remdr));
                code.NOP ();
                break;


            default:
                throw new InternalError ("Binop code " + i.opcode + " not supported in JIT");
        }
        /* Store the result back on the execution stack */
        if (opdtype.equals ("i")) {
            /* stack: %l0 -> val */
            code.pushES ("%l0");
        } else if (opdtype.equals ("f")) {
            /* stack: %f0 -> val */
            code.FpushES ("%f0");
        } else if (opdtype.equals ("xl")) {
            /* stack: %l0 -> val.w1 val.w2 */
            code.LpushES ("%l0");
        } else if (opdtype.equals ("xd")) {
            /* stack: %f0 -> val.w1 val.w2 */
            code.DpushES ("%f0");
        } else {
            throw new InternalError ("Bad type in binop.");
        }
        return;