Example usage for org.objectweb.asm Opcodes DUP2

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

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

Introduction

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

Prototype

int DUP2

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

Click Source Link

Usage

From source file:dyco4j.instrumentation.internals.TracingMethodVisitor.java

License:BSD License

private void visitArrayLoadInsn(final int opcode) {
    super.visitInsn(Opcodes.DUP2);

    super.visitInsn(opcode);

    if (opcode == Opcodes.LALOAD || opcode == Opcodes.DALOAD)
        super.visitInsn(Opcodes.DUP2_X2);
    else//w  w w  .  j a  v a  2s  . c  om
        super.visitInsn(Opcodes.DUP_X2);

    switch (opcode) {
    case Opcodes.AALOAD:
        LoggingHelper.emitConvertToString(this.mv, Type.getObjectType("java/lang/Object"));
        break;
    case Opcodes.BALOAD:
        LoggingHelper.emitConvertToString(this.mv, Type.BYTE_TYPE);
        break;
    case Opcodes.CALOAD:
        LoggingHelper.emitConvertToString(this.mv, Type.CHAR_TYPE);
        break;
    case Opcodes.FALOAD:
        LoggingHelper.emitConvertToString(this.mv, Type.FLOAT_TYPE);
        break;
    case Opcodes.IALOAD:
        LoggingHelper.emitConvertToString(this.mv, Type.INT_TYPE);
        break;
    case Opcodes.SALOAD:
        LoggingHelper.emitConvertToString(this.mv, Type.SHORT_TYPE);
        break;
    case Opcodes.DALOAD:
        LoggingHelper.emitConvertToString(this.mv, Type.DOUBLE_TYPE);
        break;
    case Opcodes.LALOAD:
        LoggingHelper.emitConvertToString(this.mv, Type.LONG_TYPE);
        break;
    }

    LoggingHelper.emitLogArray(this.mv, Logger.ArrayAction.GETA);
}

From source file:dyco4j.instrumentation.LoggingHelper.java

License:BSD License

public static void emitLogReturn(final MethodVisitor mv, final Type returnType) {
    final int _retSort = returnType.getSort();
    if (_retSort != Type.VOID) {
        if (_retSort == Type.LONG || _retSort == Type.DOUBLE) {
            mv.visitInsn(Opcodes.DUP2);
        } else {/*from w  w w .  j a v a2  s . co m*/
            mv.visitInsn(Opcodes.DUP);
        }
        emitConvertToString(mv, returnType);
        emitInvokeLog(mv, LOG_RETURN);
    }
}

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;/*ww  w .j  a  va  2s. com*/
    //<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:jpcsp.Allegrex.compiler.CompilerContext.java

License:Open Source License

/**
 * Generate the required Java code to store the return value of
 * the syscall function into the CPU registers.
 *
 * The following code is generated depending on the return type:
 * void:         -//from www  . java2  s . c o  m
 * int:          cpu.gpr[_v0] = intValue
 * boolean:      cpu.gpr[_v0] = booleanValue
 * long:         cpu.gpr[_v0] = (int) (longValue & 0xFFFFFFFFL)
 *               cpu.gpr[_v1] = (int) (longValue >>> 32)
 * float:        cpu.fpr[_f0] = floatValue
 * HLEUidClass:  if (moduleMethodUidGenerator == "") {
 *                   cpu.gpr[_v0] = HLEUidObjectMapping.createUidForObject("<return type>", returnValue);
 *               } else {
 *                   int uid = <module>.<moduleMethodUidGenerator>();
 *                   cpu.gpr[_v0] = HLEUidObjectMapping.addObjectMap("<return type>", uid, returnValue);
 *               }
 *
 * @param func        the syscall function
 * @param returnType  the type of the return value
 */
private void storeReturnValue(HLEModuleFunction func, Class<?> returnType) {
    if (returnType == void.class) {
        // Nothing to do
    } else if (returnType == int.class) {
        // cpu.gpr[_v0] = intValue
        storeRegister(_v0);
    } else if (returnType == boolean.class) {
        // cpu.gpr[_v0] = booleanValue
        storeRegister(_v0);
    } else if (returnType == long.class) {
        // cpu.gpr[_v0] = (int) (longValue & 0xFFFFFFFFL)
        // cpu.gpr[_v1] = (int) (longValue >>> 32)
        mv.visitInsn(Opcodes.DUP2);
        mv.visitLdcInsn(0xFFFFFFFFL);
        mv.visitInsn(Opcodes.LAND);
        mv.visitInsn(Opcodes.L2I);
        storeRegister(_v0);
        loadImm(32);
        mv.visitInsn(Opcodes.LSHR);
        mv.visitInsn(Opcodes.L2I);
        storeRegister(_v1);
    } else if (returnType == float.class) {
        // cpu.fpr[_f0] = floatValue
        storeFRegister(_f0);
    } else {
        HLEUidClass hleUidClass = returnType.getAnnotation(HLEUidClass.class);
        if (hleUidClass != null) {
            // if (moduleMethodUidGenerator == "") {
            //     cpu.gpr[_v0] = HLEUidObjectMapping.createUidForObject("<return type>", returnValue);
            // } else {
            //     int uid = <module>.<moduleMethodUidGenerator>();
            //     cpu.gpr[_v0] = HLEUidObjectMapping.addObjectMap("<return type>", uid, returnValue);
            // }
            if (hleUidClass.moduleMethodUidGenerator().length() <= 0) {
                // No UID generator method, use the default one
                mv.visitLdcInsn(returnType.getName());
                mv.visitInsn(Opcodes.SWAP);
                mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(HLEUidObjectMapping.class),
                        "createUidForObject",
                        "(" + Type.getDescriptor(String.class) + Type.getDescriptor(Object.class) + ")I");
                storeRegister(_v0);
            } else {
                mv.visitLdcInsn(returnType.getName());
                mv.visitInsn(Opcodes.SWAP);
                loadModule(func.getModuleName());
                mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL,
                        Type.getInternalName(func.getHLEModuleMethod().getDeclaringClass()),
                        hleUidClass.moduleMethodUidGenerator(), "()I");
                mv.visitInsn(Opcodes.SWAP);
                mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(HLEUidObjectMapping.class),
                        "addObjectMap",
                        "(" + Type.getDescriptor(String.class) + "I" + Type.getDescriptor(Object.class) + ")I");
                storeRegister(_v0);
            }
        } else {
            log.error(String.format("Unsupported sycall return value type '%s'", returnType.getName()));
        }
    }
}

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

License:Open Source License

private void logSyscallEnd(HLEModuleFunction func, boolean isErrorCode) {
    String loggingLevel = getLoggingLevel(func);
    if (loggingLevel == null) {
        return;//from   w w  w.jav  a2s . co  m
    }
    String logCheckFunction = getLogCheckFunction(loggingLevel);

    // if (Modules.getLogger(func.getModuleName()).isDebugEnabled()) {
    //     Modules.getLogger(func.getModuleName()).debug(String.format("<function name> returning 0x%X", new Object[1] { new Integer(returnValue) }));
    // }
    loadModuleLoggger(func);
    mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, Type.getInternalName(Logger.class), logCheckFunction, "()Z");
    Label notDebug = new Label();
    mv.visitJumpInsn(Opcodes.IFEQ, notDebug);

    boolean isReturningVoid = func.getHLEModuleMethod().getReturnType() == void.class;

    mv.visitInsn(Opcodes.DUP);
    mv.visitTypeInsn(Opcodes.NEW, Type.getInternalName(Integer.class));
    mv.visitInsn(Opcodes.DUP_X1);
    mv.visitInsn(Opcodes.SWAP);
    mv.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(Integer.class), "<init>", "(I)V");
    loadImm(1);
    mv.visitTypeInsn(Opcodes.ANEWARRAY, Type.getInternalName(Object.class));
    mv.visitInsn(Opcodes.DUP_X1);
    mv.visitInsn(Opcodes.SWAP);
    loadImm(0);
    mv.visitInsn(Opcodes.SWAP);
    mv.visitInsn(Opcodes.AASTORE);
    String prefix = func.isUnimplemented() && !codeBlock.isHLEFunction() ? "Unimplemented " : "";
    mv.visitLdcInsn(String.format("%s%s returning %s%s", prefix, func.getFunctionName(),
            isErrorCode ? "errorCode " : "", isReturningVoid ? "void" : "0x%X"));
    mv.visitInsn(Opcodes.SWAP);
    mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(String.class), "format",
            "(" + Type.getDescriptor(String.class) + "[" + Type.getDescriptor(Object.class) + ")"
                    + Type.getDescriptor(String.class));
    loadModuleLoggger(func);
    mv.visitInsn(Opcodes.SWAP);
    mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, Type.getInternalName(Logger.class), loggingLevel,
            "(" + Type.getDescriptor(Object.class) + ")V");

    if (!isErrorCode) {
        ParameterInfo[] parameters = new ClassAnalyzer().getParameters(func.getFunctionName(),
                func.getHLEModuleMethod().getDeclaringClass());
        if (parameters != null) {
            CompilerParameterReader parameterReader;
            if (parametersSavedToLocals) {
                parameterReader = new CompilerLocalVarParameterReader(this, LOCAL_FIRST_SAVED_PARAMETER);
            } else {
                parameterReader = new CompilerParameterReader(this);
            }

            Annotation[][] paramsAnotations = func.getHLEModuleMethod().getParameterAnnotations();
            for (int paramIndex = 0; paramIndex < parameters.length; paramIndex++) {
                ParameterInfo parameter = parameters[paramIndex];
                Class<?> parameterType = parameter.type;

                LengthInfo lengthInfo = BufferInfo.defaultLengthInfo;
                int length = BufferInfo.defaultLength;
                Usage usage = BufferInfo.defaultUsage;
                boolean debugMemory = false;
                for (Annotation parameterAnnotation : paramsAnotations[paramIndex]) {
                    if (parameterAnnotation instanceof BufferInfo) {
                        BufferInfo bufferInfo = (BufferInfo) parameterAnnotation;
                        lengthInfo = bufferInfo.lengthInfo();
                        length = bufferInfo.length();
                        usage = bufferInfo.usage();
                    } else if (parameterAnnotation instanceof DebugMemory) {
                        debugMemory = true;
                    }
                }

                boolean parameterRead = false;
                if ((usage == Usage.out || usage == Usage.inout)
                        && (lengthInfo != LengthInfo.unknown || parameterType == TPointer16.class
                                || parameterType == TPointer32.class || parameterType == TPointer64.class)) {
                    loadModuleLoggger(func);
                    loadImm(1);
                    mv.visitTypeInsn(Opcodes.ANEWARRAY, Type.getInternalName(Object.class));
                    mv.visitInsn(Opcodes.DUP);
                    loadImm(0);

                    Label done = new Label();
                    Label addressNull = new Label();
                    parameterReader.loadNextInt();
                    parameterRead = true;
                    mv.visitInsn(Opcodes.DUP);
                    mv.visitJumpInsn(Opcodes.IFEQ, addressNull);

                    String format = String.format("%s[%s]:%%s", parameter.name, usage);
                    boolean useMemoryDump = true;

                    switch (lengthInfo) {
                    case fixedLength:
                        loadImm(length);
                        break;
                    case nextNextParameter:
                        parameterReader.skipNextInt();
                        paramIndex++;
                        parameterReader.loadNextInt();
                        paramIndex++;
                        break;
                    case nextParameter:
                        parameterReader.loadNextInt();
                        paramIndex++;
                        break;
                    case previousParameter:
                        // Go back to the address parameter
                        parameterReader.rewindPreviousInt();
                        // Go back to the previous parameter
                        parameterReader.rewindPreviousInt();
                        // Load the length from the previous parameter
                        parameterReader.loadNextInt();
                        // Skip again the address parameter
                        // to come back to the above situation
                        parameterReader.skipNextInt();
                        break;
                    case variableLength:
                        mv.visitInsn(Opcodes.DUP);
                        loadMemory();
                        mv.visitInsn(Opcodes.SWAP);
                        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, memoryInternalName, "read32", "(I)I");
                        break;
                    case returnValue:
                        loadRegister(_v0);
                        break;
                    case unknown:
                        useMemoryDump = false;
                        format = String.format("%s[%s]: 0x%%X", parameter.name, usage);
                        loadMemory();
                        mv.visitInsn(Opcodes.SWAP);
                        if (parameterType == TPointer64.class) {
                            if (debugMemory) {
                                mv.visitInsn(Opcodes.DUP);
                                loadImm(8);
                                mv.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeContextInternalName,
                                        "debugMemory", "(II)V");
                            }
                            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, memoryInternalName, "read64", "(I)J");
                            mv.visitTypeInsn(Opcodes.NEW, Type.getInternalName(Long.class));
                            mv.visitInsn(Opcodes.DUP);
                            mv.visitInsn(Opcodes.DUP2_X2);
                            mv.visitInsn(Opcodes.POP2);
                            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(Long.class),
                                    "<init>", "(J)V");
                        } else if (parameterType == TPointer16.class) {
                            if (debugMemory) {
                                mv.visitInsn(Opcodes.DUP);
                                loadImm(2);
                                mv.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeContextInternalName,
                                        "debugMemory", "(II)V");
                            }
                            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, memoryInternalName, "read16", "(I)I");
                            mv.visitTypeInsn(Opcodes.NEW, Type.getInternalName(Integer.class));
                            mv.visitInsn(Opcodes.DUP_X1);
                            mv.visitInsn(Opcodes.SWAP);
                            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(Integer.class),
                                    "<init>", "(I)V");
                        } else {
                            if (debugMemory) {
                                mv.visitInsn(Opcodes.DUP);
                                loadImm(4);
                                mv.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeContextInternalName,
                                        "debugMemory", "(II)V");
                            }
                            mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, memoryInternalName, "read32", "(I)I");
                            mv.visitTypeInsn(Opcodes.NEW, Type.getInternalName(Integer.class));
                            mv.visitInsn(Opcodes.DUP_X1);
                            mv.visitInsn(Opcodes.SWAP);
                            mv.visitMethodInsn(Opcodes.INVOKESPECIAL, Type.getInternalName(Integer.class),
                                    "<init>", "(I)V");
                        }
                        break;
                    default:
                        log.error(String.format("Unimplemented lengthInfo=%s", lengthInfo));
                        break;
                    }

                    if (useMemoryDump) {
                        if (debugMemory) {
                            mv.visitInsn(Opcodes.DUP2);
                            mv.visitMethodInsn(Opcodes.INVOKESTATIC, runtimeContextInternalName, "debugMemory",
                                    "(II)V");
                        }
                        mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(Utilities.class),
                                "getMemoryDump", "(II)" + Type.getDescriptor(String.class));
                    }
                    mv.visitInsn(Opcodes.AASTORE);

                    mv.visitLdcInsn(format);
                    mv.visitInsn(Opcodes.SWAP);
                    mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(String.class), "format",
                            "(" + Type.getDescriptor(String.class) + "[" + Type.getDescriptor(Object.class)
                                    + ")" + Type.getDescriptor(String.class));
                    mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, Type.getInternalName(Logger.class), loggingLevel,
                            "(" + Type.getDescriptor(Object.class) + ")V");
                    mv.visitJumpInsn(Opcodes.GOTO, done);

                    mv.visitLabel(addressNull);
                    mv.visitInsn(Opcodes.POP);
                    mv.visitInsn(Opcodes.POP2);
                    mv.visitInsn(Opcodes.POP2);
                    mv.visitLabel(done);
                }

                if (!parameterRead) {
                    if (parameterType == long.class) {
                        parameterReader.skipNextLong();
                    } else if (parameterType == float.class) {
                        parameterReader.skipNextFloat();
                    } else {
                        parameterReader.skipNextInt();
                    }
                }
            }
        }
    }

    mv.visitLabel(notDebug);
}

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();// w  ww  .  j  a va2 s .  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 memWrite16(int registerIndex, int offset) {
    if (!memWritePrepared) {
        if (useMMIO()) {
            loadMMIO();//from   w ww. j  a v a2 s.  co 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 memWrite8(int registerIndex, int offset) {
    if (!memWritePrepared) {
        if (useMMIO()) {
            loadMMIO();/*from  w  w w .ja v  a  2 s .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, "checkMemoryWrite8",
                        "(II)I");
            }
        }
        mv.visitInsn(Opcodes.SWAP);
    }

    if (useMMIO() || !RuntimeContext.hasMemoryInt()) {
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, memoryInternalName, "write8", "(IB)V");
    } else {
        // tmp2 = value & 0xFF;
        // tmp1 = (address & 3) << 3;
        // memoryInt[address >> 2] = (memoryInt[address >> 2] & ((0xFF << tmp1) ^ 0xFFFFFFFF)) | (tmp2 << tmp1);
        loadImm(0xFF);
        mv.visitInsn(Opcodes.IAND);
        storeTmp2();
        mv.visitInsn(Opcodes.DUP);
        loadImm(3);
        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(0xFF);
        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 memWriteZero8(int registerIndex, int offset) {
    if (useMMIO()) {
        loadMMIO();/*from w ww .  j  a  v a 2s  .c om*/
    } else if (!RuntimeContext.hasMemoryInt()) {
        loadMemory();
    } else {
        loadMemoryInt();
    }

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

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

    if (useMMIO() || !RuntimeContext.hasMemoryInt()) {
        loadImm(0);
        mv.visitMethodInsn(Opcodes.INVOKEVIRTUAL, memoryInternalName, "write8", "(IB)V");
    } else {
        // tmp1 = (address & 3) << 3;
        // memoryInt[address >> 2] = (memoryInt[address >> 2] & ((0xFF << tmp1) ^ 0xFFFFFFFF));
        mv.visitInsn(Opcodes.DUP);
        loadImm(3);
        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(0xFF);
        loadTmp1();
        mv.visitInsn(Opcodes.ISHL);
        loadImm(-1);
        mv.visitInsn(Opcodes.IXOR);
        mv.visitInsn(Opcodes.IAND);
        mv.visitInsn(Opcodes.IASTORE);
    }
}

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

License:Open Source License

@Override
public void compileVFPUInstr(Object cstBefore, int opcode, String mathFunction) {
    int vsize = getVsize();
    boolean useVt = getCodeInstruction().hasFlags(Instruction.FLAG_USES_VFPU_PFXT);

    if (mathFunction == null && opcode == Opcodes.NOP && !useVt && cstBefore == null && canUseVFPUInt(vsize)) {
        // VMOV should use int instead of float
        startPfxCompiled(false);//from ww  w  .j  av  a 2 s.  c  o  m

        for (int n = 0; n < vsize; n++) {
            prepareVdForStoreInt(n);
            loadVsInt(n);
            storeVdInt(n);
        }

        endPfxCompiled(vsize, false);
    } else {
        startPfxCompiled(true);

        for (int n = 0; n < vsize; n++) {
            prepareVdForStore(n);
            if (cstBefore != null) {
                mv.visitLdcInsn(cstBefore);
            }

            loadVs(n);
            if (useVt) {
                loadVt(n);
            }
            if (mathFunction != null) {
                if ("abs".equals(mathFunction)) {
                    mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(Math.class), mathFunction,
                            "(F)F");
                } else if ("max".equals(mathFunction) || "min".equals(mathFunction)) {
                    mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(Math.class), mathFunction,
                            "(FF)F");
                } else {
                    mv.visitInsn(Opcodes.F2D);
                    mv.visitMethodInsn(Opcodes.INVOKESTATIC, Type.getInternalName(Math.class), mathFunction,
                            "(D)D");
                    mv.visitInsn(Opcodes.D2F);
                }
            }

            Label doneStore = null;
            if (opcode != Opcodes.NOP) {
                Label doneOpcode = null;

                if (opcode == Opcodes.FDIV && cstBefore == null) {
                    // if (value1 == 0f && value2 == 0f) {
                    //     result = PSP-NaN | (sign(value1) ^ sign(value2));
                    // } else {
                    //     result = value1 / value2;
                    // }
                    doneOpcode = new Label();
                    doneStore = new Label();
                    Label notZeroByZero = new Label();
                    Label notZeroByZeroPop = new Label();
                    mv.visitInsn(Opcodes.DUP2);
                    mv.visitInsn(Opcodes.FCONST_0);
                    mv.visitInsn(Opcodes.FCMPG);
                    mv.visitJumpInsn(Opcodes.IFNE, notZeroByZeroPop);
                    mv.visitInsn(Opcodes.FCONST_0);
                    mv.visitInsn(Opcodes.FCMPG);
                    mv.visitJumpInsn(Opcodes.IFNE, notZeroByZero);
                    convertVFloatToInt();
                    loadImm(0x80000000);
                    mv.visitInsn(Opcodes.IAND);
                    mv.visitInsn(Opcodes.SWAP);
                    convertVFloatToInt();
                    loadImm(0x80000000);
                    mv.visitInsn(Opcodes.IAND);
                    mv.visitInsn(Opcodes.IXOR);
                    storeTmp1();
                    // Store the NaN value as an "int" to not loose any bit.
                    // Storing as float results in 0x7FC00001 instead of 0x7F800001.
                    mv.visitInsn(Opcodes.DUP2_X2);
                    mv.visitInsn(Opcodes.POP2);
                    loadPspNaNInt();
                    loadTmp1();
                    mv.visitInsn(Opcodes.IOR);
                    int preparedRegister = preparedRegisterForStore;
                    storeVdInt(n);
                    preparedRegisterForStore = preparedRegister;
                    mv.visitJumpInsn(Opcodes.GOTO, doneStore);

                    mv.visitLabel(notZeroByZeroPop);
                    mv.visitInsn(Opcodes.POP);
                    mv.visitLabel(notZeroByZero);
                }

                mv.visitInsn(opcode);

                if (doneOpcode != null) {
                    mv.visitLabel(doneOpcode);
                }
            }

            storeVd(n);

            if (doneStore != null) {
                mv.visitLabel(doneStore);
            }
        }

        endPfxCompiled(vsize, true);
    }
}