Example usage for org.objectweb.asm Opcodes 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:edu.mit.streamjit.util.bytecode.MethodResolver.java

License:Open Source License

private void interpret(InsnNode insn, FrameState frame, BBInfo block) {
    ReturnType returnType = block.block.getParent().getType().getReturnType();
    switch (insn.getOpcode()) {
    case Opcodes.NOP:
        break;//from ww w  .  j  a v a  2 s .c  o m
    //<editor-fold defaultstate="collapsed" desc="Stack manipulation opcodes (pop, dup, swap)">
    case Opcodes.POP:
        assert frame.stack.peek().getType().getCategory() == 1;
        frame.stack.pop();
        break;
    case Opcodes.POP2:
        final int[][][] pop2Permutations = { { { 1, 1 }, {} }, { { 2 }, {} } };
        conditionallyPermute(frame, pop2Permutations);
        break;
    case Opcodes.DUP:
        final int[][][] dupPermutations = { { { 1 }, { 1, 1 } } };
        conditionallyPermute(frame, dupPermutations);
        break;
    case Opcodes.DUP_X1:
        final int[][][] dup_x1Permutations = { { { 1, 1 }, { 1, 2, 1 } } };
        conditionallyPermute(frame, dup_x1Permutations);
        break;
    case Opcodes.DUP_X2:
        final int[][][] dup_x2Permutations = { { { 1, 1, 1 }, { 1, 3, 2, 1 } }, { { 1, 2 }, { 1, 2, 1 } } };
        conditionallyPermute(frame, dup_x2Permutations);
        break;
    case Opcodes.DUP2:
        final int[][][] dup2Permutations = { { { 1, 1 }, { 2, 1, 2, 1 } }, { { 2 }, { 1, 1 } } };
        conditionallyPermute(frame, dup2Permutations);
        break;
    case Opcodes.DUP2_X1:
        final int[][][] dup2_x1Permutations = { { { 1, 1, 1 }, { 2, 1, 3, 2, 1 } }, { { 2, 1 }, { 1, 2, 1 } } };
        conditionallyPermute(frame, dup2_x1Permutations);
        break;
    case Opcodes.DUP2_X2:
        final int[][][] dup2_x2Permutations = { { { 1, 1, 1, 1 }, { 2, 1, 4, 3, 2, 1 } },
                { { 2, 1, 1 }, { 1, 3, 2, 1 } }, { { 3, 2, 1 }, { 2, 1, 3, 2, 1 } },
                { { 2, 2 }, { 1, 2, 1 } } };
        conditionallyPermute(frame, dup2_x2Permutations);
        break;
    case Opcodes.SWAP:
        final int[][][] swapPermutations = { { { 1, 1 }, { 1, 2 } } };
        conditionallyPermute(frame, swapPermutations);
        break;
    //</editor-fold>
    //<editor-fold defaultstate="collapsed" desc="Constant-stacking opcodes (iconst_0, etc.; see also bipush, sipush)">
    case Opcodes.ACONST_NULL:
        frame.stack.push(module.constants().getNullConstant());
        break;
    case Opcodes.ICONST_M1:
        frame.stack.push(module.constants().getSmallestIntConstant(-1));
        break;
    case Opcodes.ICONST_0:
        frame.stack.push(module.constants().getSmallestIntConstant(0));
        break;
    case Opcodes.ICONST_1:
        frame.stack.push(module.constants().getSmallestIntConstant(1));
        break;
    case Opcodes.ICONST_2:
        frame.stack.push(module.constants().getSmallestIntConstant(2));
        break;
    case Opcodes.ICONST_3:
        frame.stack.push(module.constants().getSmallestIntConstant(3));
        break;
    case Opcodes.ICONST_4:
        frame.stack.push(module.constants().getSmallestIntConstant(4));
        break;
    case Opcodes.ICONST_5:
        frame.stack.push(module.constants().getSmallestIntConstant(5));
        break;
    case Opcodes.LCONST_0:
        frame.stack.push(module.constants().getConstant(0L));
        break;
    case Opcodes.LCONST_1:
        frame.stack.push(module.constants().getConstant(1L));
        break;
    case Opcodes.FCONST_0:
        frame.stack.push(module.constants().getConstant(0f));
        break;
    case Opcodes.FCONST_1:
        frame.stack.push(module.constants().getConstant(1f));
        break;
    case Opcodes.FCONST_2:
        frame.stack.push(module.constants().getConstant(2f));
        break;
    case Opcodes.DCONST_0:
        frame.stack.push(module.constants().getConstant(0d));
        break;
    case Opcodes.DCONST_1:
        frame.stack.push(module.constants().getConstant(1d));
        break;
    //</editor-fold>
    //<editor-fold defaultstate="collapsed" desc="Return opcodes">
    case Opcodes.IRETURN:
        assert returnType.isSubtypeOf(typeFactory.getType(int.class));
        assert frame.stack.peek().getType().isSubtypeOf(returnType);
        block.block.instructions().add(new ReturnInst(returnType, frame.stack.pop()));
        break;
    case Opcodes.LRETURN:
        assert returnType.isSubtypeOf(typeFactory.getType(long.class));
        assert frame.stack.peek().getType().isSubtypeOf(returnType);
        block.block.instructions().add(new ReturnInst(returnType, frame.stack.pop()));
        break;
    case Opcodes.FRETURN:
        assert returnType.isSubtypeOf(typeFactory.getType(float.class));
        assert frame.stack.peek().getType().isSubtypeOf(returnType);
        block.block.instructions().add(new ReturnInst(returnType, frame.stack.pop()));
        break;
    case Opcodes.DRETURN:
        assert returnType.isSubtypeOf(typeFactory.getType(double.class));
        assert frame.stack.peek().getType().isSubtypeOf(returnType);
        block.block.instructions().add(new ReturnInst(returnType, frame.stack.pop()));
        break;
    case Opcodes.ARETURN:
        assert returnType.isSubtypeOf(typeFactory.getType(Object.class));
        assert frame.stack.peek().getType().isSubtypeOf(returnType);
        block.block.instructions().add(new ReturnInst(returnType, frame.stack.pop()));
        break;
    case Opcodes.RETURN:
        assert returnType instanceof VoidType || method.isConstructor();
        block.block.instructions().add(new ReturnInst(typeFactory.getVoidType()));
        break;
    //</editor-fold>
    //<editor-fold defaultstate="collapsed" desc="Unary math opcodes (negation)">
    //Unary minus is rendered as a multiplication by -1.  (The obvious
    //other choice, subtraction from 0, is not equivalent for floats and
    //doubles due to negative zero.)
    case Opcodes.INEG:
        frame.stack.push(module.constants().getSmallestIntConstant(-1));
        binary(BinaryInst.Operation.MUL, frame, block);
        break;
    case Opcodes.LNEG:
        frame.stack.push(module.constants().getConstant(-1L));
        binary(BinaryInst.Operation.MUL, frame, block);
        break;
    case Opcodes.FNEG:
        frame.stack.push(module.constants().getConstant(-1f));
        binary(BinaryInst.Operation.MUL, frame, block);
        break;
    case Opcodes.DNEG:
        frame.stack.push(module.constants().getConstant(-1d));
        binary(BinaryInst.Operation.MUL, frame, block);
        break;
    //</editor-fold>
    //<editor-fold defaultstate="collapsed" desc="Binary math opcodes">
    case Opcodes.IADD:
    case Opcodes.LADD:
    case Opcodes.FADD:
    case Opcodes.DADD:
        binary(BinaryInst.Operation.ADD, frame, block);
        break;
    case Opcodes.ISUB:
    case Opcodes.LSUB:
    case Opcodes.FSUB:
    case Opcodes.DSUB:
        binary(BinaryInst.Operation.SUB, frame, block);
        break;
    case Opcodes.IMUL:
    case Opcodes.LMUL:
    case Opcodes.FMUL:
    case Opcodes.DMUL:
        binary(BinaryInst.Operation.MUL, frame, block);
        break;
    case Opcodes.IDIV:
    case Opcodes.LDIV:
    case Opcodes.FDIV:
    case Opcodes.DDIV:
        binary(BinaryInst.Operation.DIV, frame, block);
        break;
    case Opcodes.IREM:
    case Opcodes.LREM:
    case Opcodes.FREM:
    case Opcodes.DREM:
        binary(BinaryInst.Operation.REM, frame, block);
        break;
    case Opcodes.ISHL:
    case Opcodes.LSHL:
        binary(BinaryInst.Operation.SHL, frame, block);
        break;
    case Opcodes.ISHR:
    case Opcodes.LSHR:
        binary(BinaryInst.Operation.SHR, frame, block);
        break;
    case Opcodes.IUSHR:
    case Opcodes.LUSHR:
        binary(BinaryInst.Operation.USHR, frame, block);
        break;
    case Opcodes.IAND:
    case Opcodes.LAND:
        binary(BinaryInst.Operation.AND, frame, block);
        break;
    case Opcodes.IOR:
    case Opcodes.LOR:
        binary(BinaryInst.Operation.OR, frame, block);
        break;
    case Opcodes.IXOR:
    case Opcodes.LXOR:
        binary(BinaryInst.Operation.XOR, frame, block);
        break;
    case Opcodes.LCMP:
    case Opcodes.FCMPL:
    case Opcodes.DCMPL:
        binary(BinaryInst.Operation.CMP, frame, block);
        break;
    case Opcodes.FCMPG:
    case Opcodes.DCMPG:
        binary(BinaryInst.Operation.CMPG, frame, block);
        break;
    //</editor-fold>
    //<editor-fold defaultstate="collapsed" desc="Primitive casts">
    case Opcodes.I2L:
        cast(int.class, long.class, frame, block);
        break;
    case Opcodes.I2F:
        cast(int.class, float.class, frame, block);
        break;
    case Opcodes.I2D:
        cast(int.class, double.class, frame, block);
        break;
    case Opcodes.L2I:
        cast(long.class, int.class, frame, block);
        break;
    case Opcodes.L2F:
        cast(long.class, float.class, frame, block);
        break;
    case Opcodes.L2D:
        cast(long.class, double.class, frame, block);
        break;
    case Opcodes.F2I:
        cast(float.class, int.class, frame, block);
        break;
    case Opcodes.F2L:
        cast(float.class, long.class, frame, block);
        break;
    case Opcodes.F2D:
        cast(float.class, double.class, frame, block);
        break;
    case Opcodes.D2I:
        cast(double.class, int.class, frame, block);
        break;
    case Opcodes.D2L:
        cast(double.class, long.class, frame, block);
        break;
    case Opcodes.D2F:
        cast(double.class, float.class, frame, block);
        break;
    case Opcodes.I2B:
        cast(int.class, byte.class, frame, block);
        break;
    case Opcodes.I2C:
        cast(int.class, char.class, frame, block);
        break;
    case Opcodes.I2S:
        cast(int.class, short.class, frame, block);
        break;
    //</editor-fold>
    //<editor-fold defaultstate="collapsed" desc="Array store opcodes">
    case Opcodes.IASTORE:
    case Opcodes.LASTORE:
    case Opcodes.FASTORE:
    case Opcodes.DASTORE:
    case Opcodes.AASTORE:
    case Opcodes.BASTORE:
    case Opcodes.CASTORE:
    case Opcodes.SASTORE:
        Value data = frame.stack.pop();
        Value index = frame.stack.pop();
        Value array = frame.stack.pop();
        ArrayStoreInst asi = new ArrayStoreInst(array, index, data);
        block.block.instructions().add(asi);
        break;
    //</editor-fold>
    //<editor-fold defaultstate="collapsed" desc="Array load opcodes">
    case Opcodes.IALOAD:
    case Opcodes.LALOAD:
    case Opcodes.FALOAD:
    case Opcodes.DALOAD:
    case Opcodes.AALOAD:
    case Opcodes.BALOAD:
    case Opcodes.CALOAD:
    case Opcodes.SALOAD:
        Value index2 = frame.stack.pop();
        Value array2 = frame.stack.pop();
        ArrayLoadInst ali = new ArrayLoadInst(array2, index2);
        block.block.instructions().add(ali);
        frame.stack.push(ali);
        break;
    //</editor-fold>
    case Opcodes.ARRAYLENGTH:
        ArrayLengthInst lengthInst = new ArrayLengthInst(frame.stack.pop());
        block.block.instructions().add(lengthInst);
        frame.stack.push(lengthInst);
        break;
    case Opcodes.ATHROW:
        block.block.instructions().add(new ThrowInst(frame.stack.pop()));
        break;
    default:
        throw new UnsupportedOperationException("" + insn.getOpcode());
    }
}

---

From source file:edu.mit.streamjit.util.bytecode.MethodUnresolver.java

License:Open Source License

private void emit(BinaryInst i, InsnList insns) {
    load(i.getOperand(0), insns);/*from w w w  .ja v  a2 s  .  co m*/
    load(i.getOperand(1), insns);
    int opcode = 0;
    if (i.getOperand(0).getType().isSubtypeOf(intType)) {
        switch (i.getOperation()) {
        case ADD:
            opcode = Opcodes.IADD;
            break;
        case SUB:
            opcode = Opcodes.ISUB;
            break;
        case MUL:
            opcode = Opcodes.IMUL;
            break;
        case DIV:
            opcode = Opcodes.IDIV;
            break;
        case REM:
            opcode = Opcodes.IREM;
            break;
        case SHL:
            opcode = Opcodes.ISHL;
            break;
        case SHR:
            opcode = Opcodes.ISHR;
            break;
        case USHR:
            opcode = Opcodes.ISHR;
            break;
        case AND:
            opcode = Opcodes.IAND;
            break;
        case OR:
            opcode = Opcodes.IOR;
            break;
        case XOR:
            opcode = Opcodes.IXOR;
            break;
        default:
            throw new AssertionError(i);
        }
    } else if (i.getOperand(0).getType().equals(longType)) {
        switch (i.getOperation()) {
        case ADD:
            opcode = Opcodes.LADD;
            break;
        case SUB:
            opcode = Opcodes.LSUB;
            break;
        case MUL:
            opcode = Opcodes.LMUL;
            break;
        case DIV:
            opcode = Opcodes.LDIV;
            break;
        case REM:
            opcode = Opcodes.LREM;
            break;
        case SHL:
            opcode = Opcodes.LSHL;
            break;
        case SHR:
            opcode = Opcodes.LSHR;
            break;
        case USHR:
            opcode = Opcodes.LSHR;
            break;
        case AND:
            opcode = Opcodes.LAND;
            break;
        case OR:
            opcode = Opcodes.LOR;
            break;
        case XOR:
            opcode = Opcodes.LXOR;
            break;
        case CMP:
            opcode = Opcodes.LCMP;
            break;
        default:
            throw new AssertionError(i);
        }
    } else if (i.getOperand(0).getType().equals(floatType)) {
        switch (i.getOperation()) {
        case ADD:
            opcode = Opcodes.FADD;
            break;
        case SUB:
            opcode = Opcodes.FSUB;
            break;
        case MUL:
            opcode = Opcodes.FMUL;
            break;
        case DIV:
            opcode = Opcodes.FDIV;
            break;
        case REM:
            opcode = Opcodes.FREM;
            break;
        case CMP:
            opcode = Opcodes.FCMPL;
            break;
        case CMPG:
            opcode = Opcodes.FCMPG;
            break;
        default:
            throw new AssertionError(i);
        }
    } else if (i.getOperand(0).getType().equals(doubleType)) {
        switch (i.getOperation()) {
        case ADD:
            opcode = Opcodes.DADD;
            break;
        case SUB:
            opcode = Opcodes.DSUB;
            break;
        case MUL:
            opcode = Opcodes.DMUL;
            break;
        case DIV:
            opcode = Opcodes.DDIV;
            break;
        case REM:
            opcode = Opcodes.DREM;
            break;
        case CMP:
            opcode = Opcodes.DCMPL;
            break;
        case CMPG:
            opcode = Opcodes.DCMPG;
            break;
        default:
            throw new AssertionError(i);
        }
    } else
        throw new AssertionError(i);
    insns.add(new InsnNode(opcode));
    store(i, insns);
}

---

From source file:jpcsp.Allegrex.compiler.CompilerContext.java

License:Open Source License

private void flushInstructionCount(boolean local, boolean last) {
    if (enableIntructionCounting) {
        if (local) {
            if (currentInstructionCount > 0) {
                mv.visitIincInsn(LOCAL_INSTRUCTION_COUNT, currentInstructionCount);
            }//  w  w  w  . j  a va 2  s. com
        } else {
            mv.visitFieldInsn(Opcodes.GETSTATIC, runtimeContextInternalName, "currentThread",
                    sceKernalThreadInfoDescriptor);
            mv.visitInsn(Opcodes.DUP);
            mv.visitFieldInsn(Opcodes.GETFIELD, sceKernalThreadInfoInternalName, "runClocks", "J");
            loadLocalVar(LOCAL_INSTRUCTION_COUNT);
            if (currentInstructionCount > 0) {
                loadImm(currentInstructionCount);
                mv.visitInsn(Opcodes.IADD);
            }
            if (Profiler.isProfilerEnabled()) {
                mv.visitInsn(Opcodes.DUP);
                loadImm(getCodeBlock().getStartAddress());
                mv.visitMethodInsn(Opcodes.INVOKESTATIC, profilerInternalName, "addInstructionCount", "(II)V");
            }
            mv.visitInsn(Opcodes.I2L);
            mv.visitInsn(Opcodes.LADD);
            mv.visitFieldInsn(Opcodes.PUTFIELD, sceKernalThreadInfoInternalName, "runClocks", "J");
            if (!last) {
                mv.visitInsn(Opcodes.ICONST_0);
                storeLocalVar(LOCAL_INSTRUCTION_COUNT);
            }
        }
        currentInstructionCount = 0;
    }
}

---

From source file:jpcsp.Allegrex.compiler.CompilerContext.java

License:Open Source License

@Override
public void memRead16(int registerIndex, int offset) {
    if (useMMIO()) {
        loadMMIO();/* w  w  w .  jav  a 2  s. c o m*/
    } else if (!RuntimeContext.hasMemoryInt()) {
        loadMemory();
    } else {
        loadMemoryInt();
    }

    loadRegister(registerIndex);
    if (offset != 0) {
        loadImm(offset);
        mv.visitInsn(Opcodes.IADD);
    }

    if (RuntimeContext.debugMemoryRead) {
        mv.visitInsn(Opcodes.DUP);
        loadImm(0);
        loadImm(codeInstruction.getAddress());
        loadImm(1);
        loadImm(16);
        mv.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeContextInternalName, "debugMemoryReadWrite",
                "(IIIZI)V");
    }

    if (useMMIO() || !RuntimeContext.hasMemoryInt()) {
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, memoryInternalName, "read16", "(I)I");
    } else {
        if (checkMemoryAccess()) {
            loadImm(codeInstruction.getAddress());
            mv.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeContextInternalName, "checkMemoryRead16", "(II)I");
            loadImm(1);
            mv.visitInsn(Opcodes.IUSHR);
        } else {
            // memoryInt[(address & 0x1FFFFFFF) / 4] == memoryInt[(address << 3) >>> 5]
            loadImm(3);
            mv.visitInsn(Opcodes.ISHL);
            loadImm(4);
            mv.visitInsn(Opcodes.IUSHR);
        }
        mv.visitInsn(Opcodes.DUP);
        loadImm(1);
        mv.visitInsn(Opcodes.IAND);
        loadImm(4);
        mv.visitInsn(Opcodes.ISHL);
        storeTmp1();
        loadImm(1);
        mv.visitInsn(Opcodes.IUSHR);
        mv.visitInsn(Opcodes.IALOAD);
        loadTmp1();
        mv.visitInsn(Opcodes.IUSHR);
        loadImm(0xFFFF);
        mv.visitInsn(Opcodes.IAND);
    }
}

---

From source file:jpcsp.Allegrex.compiler.CompilerContext.java

License:Open Source License

@Override
public void memRead8(int registerIndex, int offset) {
    if (useMMIO()) {
        loadMMIO();/* w  w w . j  ava2  s.c o  m*/
    } else if (!RuntimeContext.hasMemoryInt()) {
        loadMemory();
    } else {
        loadMemoryInt();
    }

    loadRegister(registerIndex);
    if (offset != 0) {
        loadImm(offset);
        mv.visitInsn(Opcodes.IADD);
    }

    if (RuntimeContext.debugMemoryRead) {
        mv.visitInsn(Opcodes.DUP);
        loadImm(0);
        loadImm(codeInstruction.getAddress());
        loadImm(1);
        loadImm(8);
        mv.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeContextInternalName, "debugMemoryReadWrite",
                "(IIIZI)V");
    }

    if (useMMIO() || !RuntimeContext.hasMemoryInt()) {
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, memoryInternalName, "read8", "(I)I");
    } else {
        if (checkMemoryAccess()) {
            loadImm(codeInstruction.getAddress());
            mv.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeContextInternalName, "checkMemoryRead8", "(II)I");
        } else {
            // memoryInt[(address & 0x1FFFFFFF) / 4] == memoryInt[(address << 3) >>> 5]
            loadImm(3);
            mv.visitInsn(Opcodes.ISHL);
            loadImm(3);
            mv.visitInsn(Opcodes.IUSHR);
        }
        mv.visitInsn(Opcodes.DUP);
        loadImm(3);
        mv.visitInsn(Opcodes.IAND);
        loadImm(3);
        mv.visitInsn(Opcodes.ISHL);
        storeTmp1();
        loadImm(2);
        mv.visitInsn(Opcodes.IUSHR);
        mv.visitInsn(Opcodes.IALOAD);
        loadTmp1();
        mv.visitInsn(Opcodes.IUSHR);
        loadImm(0xFF);
        mv.visitInsn(Opcodes.IAND);
    }
}

---

From source file:jpcsp.Allegrex.compiler.CompilerContext.java

License:Open Source License

@SuppressWarnings("unused")
private void prepareMemIndex(int registerIndex, int offset, boolean isRead, int width) {
    loadRegister(registerIndex);//from   w  ww .  j a v a  2 s  . c o  m
    if (offset != 0) {
        loadImm(offset);
        mv.visitInsn(Opcodes.IADD);
    }

    if (RuntimeContext.debugMemoryRead && isRead) {
        if (!RuntimeContext.debugMemoryReadWriteNoSP || registerIndex != _sp) {
            mv.visitInsn(Opcodes.DUP);
            loadImm(0);
            loadImm(codeInstruction.getAddress());
            loadImm(isRead);
            loadImm(width);
            mv.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeContextInternalName, "debugMemoryReadWrite",
                    "(IIIZI)V");
        }
    }

    if (!useMMIO() && RuntimeContext.hasMemoryInt()) {
        if (registerIndex == _sp) {
            if (isCodeInstructionInKernelMemory()) {
                // In kernel memory, the $sp value can have the flag 0x80000000.
                // memoryInt[(address & 0x1FFFFFFF) / 4] == memoryInt[(address << 3) >>> 5]
                loadImm(3);
                mv.visitInsn(Opcodes.ISHL);
                loadImm(5);
                mv.visitInsn(Opcodes.IUSHR);
            } else {
                // No need to check for a valid memory access when referencing the $sp register
                loadImm(2);
                mv.visitInsn(Opcodes.IUSHR);
            }
        } else if (checkMemoryAccess()) {
            loadImm(codeInstruction.getAddress());
            String checkMethodName = String.format("checkMemory%s%d", isRead ? "Read" : "Write", width);
            mv.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeContextInternalName, checkMethodName, "(II)I");
            loadImm(2);
            mv.visitInsn(Opcodes.IUSHR);
        } else {
            // memoryInt[(address & 0x1FFFFFFF) / 4] == memoryInt[(address << 3) >>> 5]
            loadImm(3);
            mv.visitInsn(Opcodes.ISHL);
            loadImm(5);
            mv.visitInsn(Opcodes.IUSHR);
        }
    }
}

---

From source file:jpcsp.Allegrex.compiler.CompilerContext.java

License:Open Source License

@Override
public void memWrite32(int registerIndex, int offset) {
    if (!memWritePrepared) {
        if (useMMIO()) {
            loadMMIO();//from w  w  w .j a  va2s .c  om
        } else if (!RuntimeContext.hasMemoryInt()) {
            loadMemory();
        } else {
            loadMemoryInt();
        }
        mv.visitInsn(Opcodes.SWAP);

        loadRegister(registerIndex);
        if (offset != 0) {
            loadImm(offset);
            mv.visitInsn(Opcodes.IADD);
        }
        if (checkMemoryAccess()) {
            loadImm(codeInstruction.getAddress());
            mv.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeContextInternalName, "checkMemoryWrite32", "(II)I");
        }
        mv.visitInsn(Opcodes.SWAP);
    }

    if (RuntimeContext.debugMemoryWrite) {
        if (!RuntimeContext.debugMemoryReadWriteNoSP || registerIndex != _sp) {
            mv.visitInsn(Opcodes.DUP2);
            mv.visitInsn(Opcodes.SWAP);
            loadImm(2);
            mv.visitInsn(Opcodes.ISHL);
            mv.visitInsn(Opcodes.SWAP);
            loadImm(codeInstruction.getAddress());
            loadImm(0);
            loadImm(32);
            mv.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeContextInternalName, "debugMemoryReadWrite",
                    "(IIIZI)V");
        }
    }

    if (useMMIO() || !RuntimeContext.hasMemoryInt()) {
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, memoryInternalName, "write32", "(II)V");
    } else {
        mv.visitInsn(Opcodes.IASTORE);
    }

    memWritePrepared = false;
}

---

From source file:jpcsp.Allegrex.compiler.CompilerContext.java

License:Open Source License

@Override
public void prepareMemWrite16(int registerIndex, int offset) {
    if (useMMIO()) {
        loadMMIO();/* w w  w.j  a  v  a  2s  .c o  m*/
    } else if (!RuntimeContext.hasMemoryInt()) {
        loadMemory();
    } else {
        loadMemoryInt();
    }

    loadRegister(registerIndex);
    if (offset != 0) {
        loadImm(offset);
        mv.visitInsn(Opcodes.IADD);
    }

    if (!useMMIO() && RuntimeContext.hasMemoryInt()) {
        if (checkMemoryAccess()) {
            loadImm(codeInstruction.getAddress());
            mv.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeContextInternalName, "checkMemoryWrite16", "(II)I");
        }
    }

    memWritePrepared = true;
}

---

From source file:jpcsp.Allegrex.compiler.CompilerContext.java

License:Open Source License

@Override
public void memWrite16(int registerIndex, int offset) {
    if (!memWritePrepared) {
        if (useMMIO()) {
            loadMMIO();//  w w  w .  ja  va 2s  . c  o m
        } else if (!RuntimeContext.hasMemoryInt()) {
            loadMemory();
        } else {
            loadMemoryInt();
        }
        mv.visitInsn(Opcodes.SWAP);

        loadRegister(registerIndex);
        if (offset != 0) {
            loadImm(offset);
            mv.visitInsn(Opcodes.IADD);
        }

        if (RuntimeContext.hasMemoryInt()) {
            if (checkMemoryAccess()) {
                loadImm(codeInstruction.getAddress());
                mv.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeContextInternalName, "checkMemoryWrite16",
                        "(II)I");
            }
        }
        mv.visitInsn(Opcodes.SWAP);
    }

    if (useMMIO() || !RuntimeContext.hasMemoryInt()) {
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, memoryInternalName, "write16", "(IS)V");
    } else {
        // tmp2 = value & 0xFFFF;
        // tmp1 = (address & 2) << 3;
        // memoryInt[address >> 2] = (memoryInt[address >> 2] & ((0xFFFF << tmp1) ^ 0xFFFFFFFF)) | (tmp2 << tmp1);
        loadImm(0xFFFF);
        mv.visitInsn(Opcodes.IAND);
        storeTmp2();
        mv.visitInsn(Opcodes.DUP);
        loadImm(2);
        mv.visitInsn(Opcodes.IAND);
        loadImm(3);
        mv.visitInsn(Opcodes.ISHL);
        storeTmp1();
        if (checkMemoryAccess()) {
            loadImm(2);
            mv.visitInsn(Opcodes.ISHR);
        } else {
            loadImm(3);
            mv.visitInsn(Opcodes.ISHL);
            loadImm(5);
            mv.visitInsn(Opcodes.IUSHR);
        }
        mv.visitInsn(Opcodes.DUP2);
        mv.visitInsn(Opcodes.IALOAD);
        loadImm(0xFFFF);
        loadTmp1();
        mv.visitInsn(Opcodes.ISHL);
        loadImm(-1);
        mv.visitInsn(Opcodes.IXOR);
        mv.visitInsn(Opcodes.IAND);
        loadTmp2();
        loadTmp1();
        mv.visitInsn(Opcodes.ISHL);
        mv.visitInsn(Opcodes.IOR);
        mv.visitInsn(Opcodes.IASTORE);
    }

    memWritePrepared = false;
}

---

From source file:jpcsp.Allegrex.compiler.CompilerContext.java

License:Open Source License

@Override
public void prepareMemWrite8(int registerIndex, int offset) {
    if (useMMIO()) {
        loadMMIO();//from  ww  w .  j a  v a  2s. c o m
    } else if (!RuntimeContext.hasMemoryInt()) {
        loadMemory();
    } else {
        loadMemoryInt();
    }

    loadRegister(registerIndex);
    if (offset != 0) {
        loadImm(offset);
        mv.visitInsn(Opcodes.IADD);
    }

    if (!useMMIO() && RuntimeContext.hasMemoryInt()) {
        if (checkMemoryAccess()) {
            loadImm(codeInstruction.getAddress());
            mv.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeContextInternalName, "checkMemoryWrite8", "(II)I");
        }
    }

    memWritePrepared = true;
}

---

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