Examples with ObjectConstantOperand org.jikesrvm.compilers.opt.ir.operand.ObjectConstantOperand used on opensource projects

Example 6 with ObjectConstantOperand

use of org.jikesrvm.compilers.opt.ir.operand.ObjectConstantOperand in project JikesRVM by JikesRVM.

the class StaticFieldReader method getFieldValueAsConstant.

public static ConstantOperand getFieldValueAsConstant(RVMField field, Object obj) throws NoSuchFieldException {
    if (VM.VerifyAssertions) {
        boolean isFinalField = field.isFinal();
        boolean isInitializedField = field.getDeclaringClass().isInitialized() || field.getDeclaringClass().isInBootImage();
        if (!(isFinalField && isInitializedField)) {
            String msg = "Error reading field " + field;
            VM._assert(VM.NOT_REACHED, msg);
        }
    }
    TypeReference type = field.getType();
    if (VM.runningVM) {
        if (type.isReferenceType() && (!type.isMagicType() || type.isUnboxedArrayType())) {
            Object value = field.getObjectValueUnchecked(obj);
            if (value != null) {
                return new ObjectConstantOperand(value, Offset.zero());
            } else {
                return new NullConstantOperand();
            }
        } else if (type.isWordLikeType()) {
            return new AddressConstantOperand(field.getWordValueUnchecked(obj).toAddress());
        } else if (type.isIntType()) {
            return new IntConstantOperand(field.getIntValueUnchecked(obj));
        } else if (type.isBooleanType()) {
            return new IntConstantOperand(field.getBooleanValueUnchecked(obj) ? 1 : 0);
        } else if (type.isByteType()) {
            return new IntConstantOperand(field.getByteValueUnchecked(obj));
        } else if (type.isCharType()) {
            return new IntConstantOperand(field.getCharValueUnchecked(obj));
        } else if (type.isDoubleType()) {
            return new DoubleConstantOperand(field.getDoubleValueUnchecked(obj));
        } else if (type.isFloatType()) {
            return new FloatConstantOperand(field.getFloatValueUnchecked(obj));
        } else if (type.isLongType()) {
            return new LongConstantOperand(field.getLongValueUnchecked(obj));
        } else if (type.isShortType()) {
            return new IntConstantOperand(field.getShortValueUnchecked(obj));
        } else {
            OptimizingCompilerException.UNREACHABLE("Unknown type " + type);
            return null;
        }
    } else {
        try {
            String cn = field.getDeclaringClass().toString();
            Field f = Class.forName(cn).getDeclaredField(field.getName().toString());
            f.setAccessible(true);
            if (type.isReferenceType() && (!type.isMagicType() || type.isUnboxedArrayType())) {
                Object value = f.get(obj);
                if (value != null) {
                    return new ObjectConstantOperand(value, Offset.zero());
                } else {
                    return new NullConstantOperand();
                }
            } else if (type.isWordLikeType()) {
                Object value = f.get(obj);
                if (type.equals(TypeReference.Word))
                    return new AddressConstantOperand((Word) value);
                else if (type.equals(TypeReference.Address))
                    return new AddressConstantOperand((Address) value);
                else if (type.equals(TypeReference.Offset))
                    return new AddressConstantOperand((Offset) value);
                else if (type.equals(TypeReference.Extent))
                    return new AddressConstantOperand((Extent) value);
                else {
                    OptimizingCompilerException.UNREACHABLE("Unknown word type " + type);
                    return null;
                }
            } else if (type.isIntType()) {
                return new IntConstantOperand(f.getInt(obj));
            } else if (type.isBooleanType()) {
                return new IntConstantOperand(f.getBoolean(obj) ? 1 : 0);
            } else if (type.isByteType()) {
                return new IntConstantOperand(f.getByte(obj));
            } else if (type.isCharType()) {
                return new IntConstantOperand(f.getChar(obj));
            } else if (type.isDoubleType()) {
                return new DoubleConstantOperand(f.getDouble(obj));
            } else if (type.isFloatType()) {
                return new FloatConstantOperand(f.getFloat(obj));
            } else if (type.isLongType()) {
                return new LongConstantOperand(f.getLong(obj));
            } else if (type.isShortType()) {
                return new IntConstantOperand(f.getShort(obj));
            } else {
                OptimizingCompilerException.UNREACHABLE(cn + "." + f.getName() + " has unknown type " + type);
                return null;
            }
        } catch (IllegalArgumentException e) {
            throwNoSuchFieldExceptionWithCause(field, e);
        } catch (IllegalAccessException e) {
            throwNoSuchFieldExceptionWithCause(field, e);
        } catch (NoSuchFieldError e) {
            throwNoSuchFieldExceptionWithCause(field, e);
        } catch (ClassNotFoundException e) {
            throwNoSuchFieldExceptionWithCause(field, e);
        } catch (NoClassDefFoundError e) {
            throwNoSuchFieldExceptionWithCause(field, e);
        } catch (IllegalAccessError e) {
            throwNoSuchFieldExceptionWithCause(field, e);
        }
        assertNotReached();
        return null;
    }
}

Example 7 with ObjectConstantOperand

use of org.jikesrvm.compilers.opt.ir.operand.ObjectConstantOperand in project JikesRVM by JikesRVM.

the class StaticFieldReader method getStaticFieldValue.

/**
 * Returns a constant operand with the current value of a static field.
 *
 * @param field the static field whose current value we want to read
 * @return a constant operand representing the current value of the field.
 * @throws NoSuchFieldException when the field could not be found
 */
public static ConstantOperand getStaticFieldValue(RVMField field) throws NoSuchFieldException {
    if (VM.VerifyAssertions) {
        boolean fieldIsReady = field.getDeclaringClass().isInitialized() || field.getDeclaringClass().isInBootImage();
        boolean isFinalField = field.isFinal();
        boolean isStaticField = field.isStatic();
        if (!(isFinalField && isStaticField && fieldIsReady)) {
            String msg = "Error reading field " + field;
            VM._assert(VM.NOT_REACHED, msg);
        }
    }
    TypeReference fieldType = field.getType();
    Offset off = field.getOffset();
    if ((fieldType == TypeReference.Address) || (fieldType == TypeReference.Word) || (fieldType == TypeReference.Offset) || (fieldType == TypeReference.Extent)) {
        Address val = getAddressStaticFieldValue(field);
        return new AddressConstantOperand(val);
    } else if (fieldType.isIntLikeType()) {
        int val = getIntStaticFieldValue(field);
        return new IntConstantOperand(val);
    } else if (fieldType.isLongType()) {
        long val = getLongStaticFieldValue(field);
        return new LongConstantOperand(val);
    } else if (fieldType.isFloatType()) {
        float val = getFloatStaticFieldValue(field);
        return new FloatConstantOperand(val, off);
    } else if (fieldType.isDoubleType()) {
        double val = getDoubleStaticFieldValue(field);
        return new DoubleConstantOperand(val, off);
    } else {
        // Reference type
        if (VM.VerifyAssertions)
            VM._assert(fieldType.isReferenceType());
        Object val = getObjectStaticFieldValue(field);
        if (val == null) {
            return new NullConstantOperand();
        } else if (fieldType == TypeReference.JavaLangString) {
            return new StringConstantOperand((String) val, off);
        } else if (fieldType == TypeReference.JavaLangClass) {
            Class<?> klass = (Class<?>) getObjectStaticFieldValue(field);
            RVMType type;
            if (VM.runningVM) {
                type = java.lang.JikesRVMSupport.getTypeForClass(klass);
            } else {
                type = TypeReference.findOrCreate(klass).resolve();
            }
            return new ClassConstantOperand(type.getClassForType(), off);
        } else {
            return new ObjectConstantOperand(val, off);
        }
    }
}

Example 8 with ObjectConstantOperand

use of org.jikesrvm.compilers.opt.ir.operand.ObjectConstantOperand in project JikesRVM by JikesRVM.

the class Simplifier method getDoesImplementFromTib.

private static DefUseEffect getDoesImplementFromTib(Instruction s, OptOptions opts) {
    if (opts.SIMPLIFY_TIB_OPS) {
        Operand tibOp = Unary.getVal(s);
        if (tibOp.isTIBConstant()) {
            TIBConstantOperand tib = tibOp.asTIBConstant();
            Move.mutate(s, REF_MOVE, Unary.getClearResult(s), new ObjectConstantOperand(tib.value.getDoesImplement(), Offset.zero()));
            return DefUseEffect.MOVE_FOLDED;
        }
    }
    return DefUseEffect.UNCHANGED;
}

Example 9 with ObjectConstantOperand

use of org.jikesrvm.compilers.opt.ir.operand.ObjectConstantOperand in project JikesRVM by JikesRVM.

the class GenerateMagic method generateMagic.

/**
 * "Semantic inlining" of methods of the Magic class.
 * Based on the methodName, generate a sequence of opt instructions
 * that implement the magic, updating the expression stack as necessary.
 *
 * @param bc2ir the bc2ir object that is generating the
 *              ir containing this magic
 * @param gc must be bc2ir.gc
 * @param meth the RVMMethod that is the magic method
 * @return {@code true} if and only if magic was generated
 */
static boolean generateMagic(BC2IR bc2ir, GenerationContext gc, MethodReference meth) throws MagicNotImplementedException {
    if (gc.getMethod().hasNoInlinePragma())
        gc.forceFrameAllocation();
    Atom methodName = meth.getName();
    boolean address = (meth.getType() == TypeReference.Address);
    // Address magic
    TypeReference[] types = meth.getParameterTypes();
    TypeReference returnType = meth.getReturnType();
    if (address && isLoad(methodName)) {
        // LOAD
        Operand offset = (types.length == 0) ? AC(Address.zero()) : bc2ir.popAddress();
        Operand base = bc2ir.popAddress();
        RegisterOperand result = gc.getTemps().makeTemp(returnType);
        bc2ir.appendInstruction(Load.create(getOperator(returnType, LOAD_OP), result, base, offset, null));
        bc2ir.push(result.copyD2U(), returnType);
    } else if (address && isPrepare(methodName)) {
        // PREPARE
        Operand offset = (types.length == 0) ? AC(Address.zero()) : bc2ir.popAddress();
        Operand base = bc2ir.popAddress();
        RegisterOperand result = gc.getTemps().makeTemp(returnType);
        bc2ir.appendInstruction(Prepare.create(getOperator(returnType, PREPARE_OP), result, base, offset, null));
        bc2ir.push(result.copyD2U(), returnType);
    } else if (address && methodName == MagicNames.attempt) {
        // ATTEMPT
        TypeReference attemptType = types[0];
        Operand offset = (types.length == 2) ? AC(Address.zero()) : bc2ir.popAddress();
        Operand newVal = bc2ir.pop();
        Operand oldVal = bc2ir.pop();
        Operand base = bc2ir.popAddress();
        RegisterOperand test = gc.getTemps().makeTempInt();
        bc2ir.appendInstruction(Attempt.create(getOperator(attemptType, ATTEMPT_OP), test, base, offset, oldVal, newVal, null));
        bc2ir.push(test.copyD2U(), returnType);
    } else if (address && methodName == MagicNames.store) {
        // STORE
        TypeReference storeType = types[0];
        Operand offset = (types.length == 1) ? AC(Address.zero()) : bc2ir.popAddress();
        Operand val = bc2ir.pop(storeType);
        Operand base = bc2ir.popAddress();
        bc2ir.appendInstruction(Store.create(getOperator(storeType, STORE_OP), val, base, offset, null));
    } else if (methodName == MagicNames.getThreadRegister) {
        RegisterOperand rop = gc.getTemps().makeTROp();
        bc2ir.markGuardlessNonNull(rop);
        bc2ir.push(rop);
    } else if (methodName == MagicNames.setThreadRegister) {
        Operand val = bc2ir.popRef();
        if (val instanceof RegisterOperand) {
            bc2ir.appendInstruction(Move.create(REF_MOVE, gc.getTemps().makeTROp(), val));
        } else {
            String msg = " Unexpected operand Magic.setThreadRegister";
            throw MagicNotImplementedException.UNEXPECTED(msg);
        }
    } else if (methodName == MagicNames.addressArrayCreate) {
        Instruction s = bc2ir.generateAnewarray(null, meth.getType().getArrayElementType());
        bc2ir.appendInstruction(s);
    } else if (methodName == MagicNames.addressArrayLength) {
        Operand op1 = bc2ir.pop();
        bc2ir.clearCurrentGuard();
        if (bc2ir.do_NullCheck(op1)) {
            return true;
        }
        RegisterOperand t = gc.getTemps().makeTempInt();
        Instruction s = GuardedUnary.create(ARRAYLENGTH, t, op1, bc2ir.getCurrentGuard());
        bc2ir.push(t.copyD2U());
        bc2ir.appendInstruction(s);
    } else if (methodName == MagicNames.addressArrayGet) {
        TypeReference elementType = meth.getReturnType();
        Operand index = bc2ir.popInt();
        Operand ref = bc2ir.popRef();
        RegisterOperand offsetI = gc.getTemps().makeTempInt();
        RegisterOperand offset = gc.getTemps().makeTempOffset();
        RegisterOperand result;
        if (meth.getType().isCodeArrayType()) {
            if (VM.BuildForIA32) {
                result = gc.getTemps().makeTemp(TypeReference.Byte);
                bc2ir.appendInstruction(Load.create(BYTE_LOAD, result, ref, index, new LocationOperand(elementType), new TrueGuardOperand()));
            } else if (VM.BuildForPowerPC) {
                result = gc.getTemps().makeTemp(TypeReference.Int);
                bc2ir.appendInstruction(Binary.create(INT_SHL, offsetI, index, new IntConstantOperand(LOG_BYTES_IN_INT)));
                bc2ir.appendInstruction(Unary.create(INT_2ADDRZerExt, offset, offsetI.copy()));
                bc2ir.appendInstruction(Load.create(INT_LOAD, result, ref, offset.copy(), new LocationOperand(elementType), new TrueGuardOperand()));
            }
        } else {
            result = gc.getTemps().makeTemp(elementType);
            bc2ir.appendInstruction(Binary.create(INT_SHL, offsetI, index, new IntConstantOperand(LOG_BYTES_IN_ADDRESS)));
            bc2ir.appendInstruction(Unary.create(INT_2ADDRZerExt, offset, offsetI.copy()));
            bc2ir.appendInstruction(Load.create(REF_LOAD, result, ref, offset.copy(), new LocationOperand(elementType), new TrueGuardOperand()));
        }
        bc2ir.push(result.copyD2U());
    } else if (methodName == MagicNames.addressArraySet) {
        TypeReference elementType = meth.getParameterTypes()[1];
        Operand val = bc2ir.pop();
        Operand index = bc2ir.popInt();
        Operand ref = bc2ir.popRef();
        RegisterOperand offsetI = gc.getTemps().makeTempInt();
        RegisterOperand offset = gc.getTemps().makeTempOffset();
        if (meth.getType().isCodeArrayType()) {
            if (VM.BuildForIA32) {
                bc2ir.appendInstruction(Store.create(BYTE_STORE, val, ref, index, new LocationOperand(elementType), new TrueGuardOperand()));
            } else if (VM.BuildForPowerPC) {
                bc2ir.appendInstruction(Binary.create(INT_SHL, offsetI, index, new IntConstantOperand(LOG_BYTES_IN_INT)));
                bc2ir.appendInstruction(Unary.create(INT_2ADDRZerExt, offset, offsetI.copy()));
                bc2ir.appendInstruction(Store.create(INT_STORE, val, ref, offset.copy(), new LocationOperand(elementType), new TrueGuardOperand()));
            }
        } else {
            bc2ir.appendInstruction(Binary.create(INT_SHL, offsetI, index, new IntConstantOperand(LOG_BYTES_IN_ADDRESS)));
            bc2ir.appendInstruction(Unary.create(INT_2ADDRZerExt, offset, offsetI.copy()));
            bc2ir.appendInstruction(Store.create(REF_STORE, val, ref, offset.copy(), new LocationOperand(elementType), new TrueGuardOperand()));
        }
    } else if (methodName == MagicNames.getIntAtOffset) {
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTempInt();
        bc2ir.appendInstruction(Load.create(INT_LOAD, val, object, offset, null));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.setIntAtOffset) {
        LocationOperand loc = null;
        if (meth.getParameterTypes().length == 4) {
            loc = mapToMetadata(bc2ir.popInt());
        }
        Operand val = bc2ir.popInt();
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        bc2ir.appendInstruction(Store.create(INT_STORE, val, object, offset, loc));
    } else if (methodName == MagicNames.getFloatAtOffset) {
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTempFloat();
        bc2ir.appendInstruction(Load.create(FLOAT_LOAD, val, object, offset, null));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.setFloatAtOffset) {
        LocationOperand loc = null;
        if (meth.getParameterTypes().length == 4) {
            loc = mapToMetadata(bc2ir.popInt());
        }
        Operand val = bc2ir.popFloat();
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        bc2ir.appendInstruction(Store.create(FLOAT_STORE, val, object, offset, loc));
    } else if (methodName == MagicNames.getWordAtOffset) {
        LocationOperand loc = null;
        if (meth.getParameterTypes().length == 3) {
            loc = mapToMetadata(bc2ir.popInt());
        }
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTemp(TypeReference.Word);
        bc2ir.appendInstruction(Load.create(REF_LOAD, val, object, offset, loc));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.getAddressAtOffset) {
        LocationOperand loc = null;
        if (meth.getParameterTypes().length == 3) {
            loc = mapToMetadata(bc2ir.popInt());
        }
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTemp(TypeReference.Address);
        bc2ir.appendInstruction(Load.create(REF_LOAD, val, object, offset, loc));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.getExtentAtOffset) {
        LocationOperand loc = null;
        if (meth.getParameterTypes().length == 3) {
            loc = mapToMetadata(bc2ir.popInt());
        }
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTemp(TypeReference.Extent);
        bc2ir.appendInstruction(Load.create(REF_LOAD, val, object, offset, loc));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.getOffsetAtOffset) {
        LocationOperand loc = null;
        if (meth.getParameterTypes().length == 3) {
            loc = mapToMetadata(bc2ir.popInt());
        }
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTemp(TypeReference.Offset);
        bc2ir.appendInstruction(Load.create(REF_LOAD, val, object, offset, loc));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.setWordAtOffset || methodName == MagicNames.setAddressAtOffset || methodName == MagicNames.setOffsetAtOffset || methodName == MagicNames.setExtentAtOffset) {
        LocationOperand loc = null;
        if (meth.getParameterTypes().length == 4) {
            loc = mapToMetadata(bc2ir.popInt());
        }
        Operand val = bc2ir.popRef();
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        bc2ir.appendInstruction(Store.create(REF_STORE, val, object, offset, loc));
    } else if (methodName == MagicNames.getLongAtOffset) {
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTempLong();
        bc2ir.appendInstruction(Load.create(LONG_LOAD, val, object, offset, null));
        bc2ir.pushDual(val.copyD2U());
    } else if (methodName == MagicNames.setLongAtOffset) {
        LocationOperand loc = null;
        if (meth.getParameterTypes().length == 4) {
            loc = mapToMetadata(bc2ir.popInt());
        }
        Operand val = bc2ir.popLong();
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        bc2ir.appendInstruction(Store.create(LONG_STORE, val, object, offset, loc));
    } else if (methodName == MagicNames.getDoubleAtOffset) {
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTempDouble();
        bc2ir.appendInstruction(Load.create(DOUBLE_LOAD, val, object, offset, null));
        bc2ir.pushDual(val.copyD2U());
    } else if (methodName == MagicNames.setDoubleAtOffset) {
        LocationOperand loc = null;
        if (meth.getParameterTypes().length == 4) {
            loc = mapToMetadata(bc2ir.popInt());
        }
        Operand val = bc2ir.popDouble();
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        bc2ir.appendInstruction(Store.create(DOUBLE_STORE, val, object, offset, loc));
    } else if (methodName == MagicNames.getObjectAtOffset) {
        LocationOperand loc = null;
        if (meth.getParameterTypes().length == 3) {
            loc = mapToMetadata(bc2ir.popInt());
        }
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTemp(TypeReference.JavaLangObject);
        bc2ir.appendInstruction(Load.create(REF_LOAD, val, object, offset, loc));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.getTIBAtOffset) {
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTemp(TypeReference.TIB);
        bc2ir.appendInstruction(Load.create(REF_LOAD, val, object, offset, null));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.setObjectAtOffset) {
        LocationOperand loc = null;
        if (meth.getParameterTypes().length == 4) {
            loc = mapToMetadata(bc2ir.popInt());
        }
        Operand val = bc2ir.popRef();
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        bc2ir.appendInstruction(Store.create(REF_STORE, val, object, offset, loc));
    } else if (methodName == MagicNames.getByteAtOffset) {
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTemp(TypeReference.Byte);
        bc2ir.appendInstruction(Load.create(BYTE_LOAD, val, object, offset, null));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.getUnsignedByteAtOffset) {
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTemp(TypeReference.Byte);
        bc2ir.appendInstruction(Load.create(UBYTE_LOAD, val, object, offset, null));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.setByteAtOffset || methodName == MagicNames.setBooleanAtOffset) {
        LocationOperand loc = null;
        if (meth.getParameterTypes().length == 4) {
            loc = mapToMetadata(bc2ir.popInt());
        }
        Operand val = bc2ir.popInt();
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        bc2ir.appendInstruction(Store.create(BYTE_STORE, val, object, offset, loc));
    } else if (methodName == MagicNames.getShortAtOffset) {
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTemp(TypeReference.Char);
        bc2ir.appendInstruction(Load.create(SHORT_LOAD, val, object, offset, null));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.getCharAtOffset) {
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTemp(TypeReference.Char);
        bc2ir.appendInstruction(Load.create(USHORT_LOAD, val, object, offset, null));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.setCharAtOffset || methodName == MagicNames.setShortAtOffset) {
        LocationOperand loc = null;
        if (meth.getParameterTypes().length == 4) {
            loc = mapToMetadata(bc2ir.popInt());
        }
        Operand val = bc2ir.popInt();
        Operand offset = bc2ir.popAddress();
        Operand object = bc2ir.popRef();
        bc2ir.appendInstruction(Store.create(SHORT_STORE, val, object, offset, loc));
    } else if (methodName == MagicNames.getMemoryInt) {
        Operand memAddr = bc2ir.popAddress();
        RegisterOperand val = gc.getTemps().makeTempInt();
        bc2ir.appendInstruction(Load.create(INT_LOAD, val, memAddr, AC(Offset.zero()), null));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.getMemoryWord) {
        Operand memAddr = bc2ir.popAddress();
        RegisterOperand val = gc.getTemps().makeTemp(TypeReference.Word);
        bc2ir.appendInstruction(Load.create(REF_LOAD, val, memAddr, AC(Offset.zero()), null));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.getMemoryAddress) {
        Operand memAddr = bc2ir.popAddress();
        RegisterOperand val = gc.getTemps().makeTemp(TypeReference.Address);
        bc2ir.appendInstruction(Load.create(REF_LOAD, val, memAddr, AC(Offset.zero()), null));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.setMemoryInt) {
        Operand val = bc2ir.popInt();
        Operand memAddr = bc2ir.popAddress();
        bc2ir.appendInstruction(Store.create(INT_STORE, val, memAddr, AC(Offset.zero()), null));
    } else if (methodName == MagicNames.setMemoryWord) {
        Operand val = bc2ir.popRef();
        Operand memAddr = bc2ir.popAddress();
        bc2ir.appendInstruction(Store.create(REF_STORE, val, memAddr, AC(Offset.zero()), null));
    } else if (meth.isSysCall()) {
        // All methods of SysCall have the following signature:
        // callNAME(Address functionAddress, <var args to pass via native calling convention>)
        // With 64 bit PowerPC ELF ABI, functionAddress points to the function descriptor
        TypeReference[] args = meth.getParameterTypes();
        Instruction call = Call.create(SYSCALL, null, null, null, null, args.length - 1);
        for (int i = args.length - 1; i >= 1; i--) {
            Call.setParam(call, i - 1, bc2ir.pop(args[i]));
        }
        Operand functionAddress = bc2ir.pop(args[0]);
        Call.setAddress(call, functionAddress);
        if (!returnType.isVoidType()) {
            RegisterOperand op0 = gc.getTemps().makeTemp(returnType);
            Call.setResult(call, op0);
            bc2ir.push(op0.copyD2U(), returnType);
        }
        Call.setMethod(call, MethodOperand.STATIC(meth, meth.peekResolvedMethod()));
        bc2ir.appendInstruction(call);
    } else if (meth.isSpecializedInvoke()) {
        // The callsite looks like              RETURN = INVOKE (ID, OBJECT, P0, P1 .. PN)
        // And the actual method will look like RETURN = INVOKE     (OBJECT, P0, P1 .. PN)
        // Create the call instruction
        Instruction call = Call.create(CALL, null, null, null, null, types.length - 1);
        // Plumb all of the normal parameters into the call
        for (int i = types.length - 1; i >= 2; i--) {
            Call.setParam(call, i - 1, bc2ir.pop(types[i]));
        }
        // The object being specialized
        Operand objectOperand = bc2ir.pop(types[1]);
        Call.setParam(call, 0, objectOperand);
        Operand guard = BC2IR.copyGuardFromOperand(objectOperand);
        if (guard == null) {
            // it's magic, so assume that it's OK....
            guard = new TrueGuardOperand();
        }
        Call.setGuard(call, guard);
        // Load the tib of this object
        RegisterOperand tibObject = gc.getTemps().makeTemp(TypeReference.TIB);
        bc2ir.appendInstruction(GuardedUnary.create(GET_OBJ_TIB, tibObject, objectOperand.copy(), guard.copy()));
        // The index of the specialized method
        Operand methodId = bc2ir.popInt();
        // Add the base offset for specialized methods and convert from index to address
        RegisterOperand tibOffset = gc.getTemps().makeTemp(TypeReference.Int);
        bc2ir.appendInstruction(Binary.create(INT_ADD, tibOffset, methodId, new IntConstantOperand(TIB_FIRST_SPECIALIZED_METHOD_INDEX)));
        bc2ir.appendInstruction(Binary.create(INT_SHL, tibOffset.copyRO(), tibOffset.copyD2U(), new IntConstantOperand(LOG_BYTES_IN_ADDRESS)));
        // Load the code address from the TIB
        RegisterOperand codeAddress = gc.getTemps().makeTemp(TypeReference.Address);
        bc2ir.appendInstruction(Load.create(REF_LOAD, codeAddress, tibObject.copyD2U(), tibOffset.copyD2U(), null));
        Call.setAddress(call, codeAddress.copyD2U());
        if (!returnType.isVoidType()) {
            RegisterOperand op0 = gc.getTemps().makeTemp(returnType);
            Call.setResult(call, op0);
            bc2ir.push(op0.copyD2U(), returnType);
        }
        bc2ir.appendInstruction(call);
    } else if (methodName == MagicNames.objectAsType) {
        RegisterOperand reg = gc.getTemps().makeTemp(TypeReference.Type);
        bc2ir.appendInstruction(Move.create(REF_MOVE, reg, bc2ir.popRef()));
        bc2ir.push(reg.copyD2U());
    } else if (methodName == MagicNames.objectAsThread) {
        RegisterOperand reg = gc.getTemps().makeTemp(TypeReference.Thread);
        bc2ir.appendInstruction(Move.create(REF_MOVE, reg, bc2ir.popRef()));
        bc2ir.push(reg.copyD2U());
    } else if (methodName == MagicNames.objectAsAddress) {
        RegisterOperand reg = gc.getTemps().makeTemp(TypeReference.Address);
        bc2ir.appendInstruction(Move.create(REF_MOVE, reg, bc2ir.popRef()));
        bc2ir.push(reg.copyD2U());
    } else if (methodName == MagicNames.addressAsObject) {
        RegisterOperand reg = gc.getTemps().makeTemp(TypeReference.JavaLangObject);
        bc2ir.appendInstruction(Move.create(REF_MOVE, reg, bc2ir.popAddress()));
        bc2ir.push(reg.copyD2U());
    } else if (methodName == MagicNames.addressAsTIB) {
        RegisterOperand reg = gc.getTemps().makeTemp(TypeReference.TIB);
        bc2ir.appendInstruction(Move.create(REF_MOVE, reg, bc2ir.popAddress()));
        bc2ir.push(reg.copyD2U());
    } else if (methodName == MagicNames.addressAsByteArray) {
        RegisterOperand reg = gc.getTemps().makeTemp(TypeReference.ByteArray);
        bc2ir.appendInstruction(Move.create(REF_MOVE, reg, bc2ir.popAddress()));
        bc2ir.push(reg.copyD2U());
    } else if (methodName == MagicNames.objectAsShortArray) {
        RegisterOperand reg = gc.getTemps().makeTemp(TypeReference.ShortArray);
        bc2ir.appendInstruction(Move.create(REF_MOVE, reg, bc2ir.popRef()));
        bc2ir.push(reg.copyD2U());
    } else if (methodName == MagicNames.objectAsIntArray) {
        RegisterOperand reg = gc.getTemps().makeTemp(TypeReference.IntArray);
        bc2ir.appendInstruction(Move.create(REF_MOVE, reg, bc2ir.popRef()));
        bc2ir.push(reg.copyD2U());
    } else if (methodName == MagicNames.floatAsIntBits) {
        Operand val = bc2ir.popFloat();
        RegisterOperand op0 = gc.getTemps().makeTempInt();
        bc2ir.appendInstruction(Unary.create(FLOAT_AS_INT_BITS, op0, val));
        bc2ir.push(op0.copyD2U());
    } else if (methodName == MagicNames.intBitsAsFloat) {
        Operand val = bc2ir.popInt();
        RegisterOperand op0 = gc.getTemps().makeTempFloat();
        bc2ir.appendInstruction(Unary.create(INT_BITS_AS_FLOAT, op0, val));
        bc2ir.push(op0.copyD2U());
    } else if (methodName == MagicNames.doubleAsLongBits) {
        Operand val = bc2ir.popDouble();
        RegisterOperand op0 = gc.getTemps().makeTempLong();
        bc2ir.appendInstruction(Unary.create(DOUBLE_AS_LONG_BITS, op0, val));
        bc2ir.pushDual(op0.copyD2U());
    } else if (methodName == MagicNames.longBitsAsDouble) {
        Operand val = bc2ir.popLong();
        RegisterOperand op0 = gc.getTemps().makeTempDouble();
        bc2ir.appendInstruction(Unary.create(LONG_BITS_AS_DOUBLE, op0, val));
        bc2ir.pushDual(op0.copyD2U());
    } else if (methodName == MagicNames.sqrt) {
        TypeReference[] args = meth.getParameterTypes();
        if (args[0] == TypeReference.Float) {
            Operand val = bc2ir.popFloat();
            RegisterOperand op0 = gc.getTemps().makeTempFloat();
            bc2ir.appendInstruction(Unary.create(FLOAT_SQRT, op0, val));
            bc2ir.push(op0.copyD2U());
        } else if (args[0] == TypeReference.Double) {
            Operand val = bc2ir.popDouble();
            RegisterOperand op0 = gc.getTemps().makeTempDouble();
            bc2ir.appendInstruction(Unary.create(DOUBLE_SQRT, op0, val));
            bc2ir.pushDual(op0.copyD2U());
        } else {
            if (VM.VerifyAssertions)
                VM._assert(VM.NOT_REACHED, "SQRT only handles Double or Float operands");
        }
    } else if (methodName == MagicNames.getObjectType) {
        Operand val = bc2ir.popRef();
        if (val.isObjectConstant()) {
            bc2ir.push(new ObjectConstantOperand(val.getType().peekType(), Offset.zero()));
        } else {
            Operand guard = BC2IR.copyGuardFromOperand(val);
            if (guard == null) {
                // it's magic, so assume that it's OK....
                guard = new TrueGuardOperand();
            }
            RegisterOperand tibPtr = gc.getTemps().makeTemp(TypeReference.TIB);
            bc2ir.appendInstruction(GuardedUnary.create(GET_OBJ_TIB, tibPtr, val, guard));
            RegisterOperand op0;
            TypeReference argType = val.getType();
            if (argType.isArrayType()) {
                op0 = gc.getTemps().makeTemp(TypeReference.RVMArray);
            } else {
                if (argType == TypeReference.JavaLangObject || argType == TypeReference.JavaLangCloneable || argType == TypeReference.JavaIoSerializable) {
                    // could be an array or a class, so make op0 be a RVMType
                    op0 = gc.getTemps().makeTemp(TypeReference.Type);
                } else {
                    op0 = gc.getTemps().makeTemp(TypeReference.Class);
                }
            }
            bc2ir.markGuardlessNonNull(op0);
            bc2ir.appendInstruction(Unary.create(GET_TYPE_FROM_TIB, op0, tibPtr.copyD2U()));
            bc2ir.push(op0.copyD2U());
        }
    } else if (methodName == MagicNames.getArrayLength) {
        Operand val = bc2ir.popRef();
        RegisterOperand op0 = gc.getTemps().makeTempInt();
        bc2ir.appendInstruction(GuardedUnary.create(ARRAYLENGTH, op0, val, new TrueGuardOperand()));
        bc2ir.push(op0.copyD2U());
    } else if (methodName == MagicNames.invokeClassInitializer) {
        Instruction s = Call.create0(CALL, null, bc2ir.popRef(), null);
        bc2ir.appendInstruction(s);
    } else if ((methodName == MagicNames.invokeMethodReturningObject) || (methodName == MagicNames.invokeMethodReturningVoid) || (methodName == MagicNames.invokeMethodReturningLong) || (methodName == MagicNames.invokeMethodReturningDouble) || (methodName == MagicNames.invokeMethodReturningFloat) || (methodName == MagicNames.invokeMethodReturningInt)) {
        Operand spills = bc2ir.popRef();
        Operand fprmeta = bc2ir.popRef();
        Operand fprs = bc2ir.popRef();
        Operand gprs = bc2ir.popRef();
        Operand code = bc2ir.popRef();
        RegisterOperand res = null;
        if (methodName == MagicNames.invokeMethodReturningObject) {
            res = gc.getTemps().makeTemp(TypeReference.JavaLangObject);
            bc2ir.push(res.copyD2U());
        } else if (methodName == MagicNames.invokeMethodReturningLong) {
            res = gc.getTemps().makeTemp(TypeReference.Long);
            bc2ir.push(res.copyD2U(), TypeReference.Long);
        } else if (methodName == MagicNames.invokeMethodReturningDouble) {
            res = gc.getTemps().makeTempDouble();
            bc2ir.push(res.copyD2U(), TypeReference.Double);
        } else if (methodName == MagicNames.invokeMethodReturningFloat) {
            res = gc.getTemps().makeTempFloat();
            bc2ir.push(res.copyD2U(), TypeReference.Float);
        } else if (methodName == MagicNames.invokeMethodReturningInt) {
            res = gc.getTemps().makeTempInt();
            bc2ir.push(res.copyD2U());
        }
        RVMField target = ArchEntrypoints.reflectiveMethodInvokerInstructionsField;
        MethodOperand met = MethodOperand.STATIC(target);
        Instruction s = Call.create5(CALL, res, AC(target.getOffset()), met, code, gprs, fprs, fprmeta, spills);
        bc2ir.appendInstruction(s);
    } else if (methodName == MagicNames.saveThreadState) {
        Operand p1 = bc2ir.popRef();
        RVMField target = ArchEntrypoints.saveThreadStateInstructionsField;
        MethodOperand mo = MethodOperand.STATIC(target);
        bc2ir.appendInstruction(Call.create1(CALL, null, AC(target.getOffset()), mo, p1));
    } else if (methodName == MagicNames.threadSwitch) {
        Operand p2 = bc2ir.popRef();
        Operand p1 = bc2ir.popRef();
        RVMField target = ArchEntrypoints.threadSwitchInstructionsField;
        MethodOperand mo = MethodOperand.STATIC(target);
        bc2ir.appendInstruction(Call.create2(CALL, null, AC(target.getOffset()), mo, p1, p2));
    } else if (methodName == MagicNames.restoreHardwareExceptionState) {
        RVMField target = ArchEntrypoints.restoreHardwareExceptionStateInstructionsField;
        MethodOperand mo = MethodOperand.STATIC(target);
        bc2ir.appendInstruction(Call.create1(CALL, null, AC(target.getOffset()), mo, bc2ir.popRef()));
    } else if (methodName == MagicNames.prepareInt) {
        Operand offset = bc2ir.popAddress();
        Operand base = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTempInt();
        bc2ir.appendInstruction(Prepare.create(PREPARE_INT, val, base, offset, null));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.prepareLong) {
        Operand offset = bc2ir.popAddress();
        Operand base = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTempLong();
        bc2ir.appendInstruction(Prepare.create(PREPARE_LONG, val, base, offset, null));
        bc2ir.pushDual(val.copyD2U());
    } else if (methodName == MagicNames.prepareObject) {
        Operand offset = bc2ir.popAddress();
        Operand base = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTemp(TypeReference.JavaLangObject);
        bc2ir.appendInstruction(Prepare.create(PREPARE_ADDR, val, base, offset, null));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.prepareAddress) {
        Operand offset = bc2ir.popAddress();
        Operand base = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTemp(TypeReference.Address);
        bc2ir.appendInstruction(Prepare.create(PREPARE_ADDR, val, base, offset, null));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.prepareWord) {
        Operand offset = bc2ir.popAddress();
        Operand base = bc2ir.popRef();
        RegisterOperand val = gc.getTemps().makeTemp(TypeReference.Word);
        bc2ir.appendInstruction(Prepare.create(PREPARE_ADDR, val, base, offset, null));
        bc2ir.push(val.copyD2U());
    } else if (methodName == MagicNames.attemptInt) {
        Operand newVal = bc2ir.popInt();
        Operand oldVal = bc2ir.popInt();
        Operand offset = bc2ir.popAddress();
        Operand base = bc2ir.popRef();
        RegisterOperand test = gc.getTemps().makeTempBoolean();
        bc2ir.appendInstruction(Attempt.create(ATTEMPT_INT, test, base, offset, oldVal, newVal, null));
        bc2ir.push(test.copyD2U());
    } else if (methodName == MagicNames.attemptLong) {
        Operand newVal = bc2ir.popLong();
        Operand oldVal = bc2ir.popLong();
        Operand offset = bc2ir.popAddress();
        Operand base = bc2ir.popRef();
        RegisterOperand test = gc.getTemps().makeTempBoolean();
        bc2ir.appendInstruction(Attempt.create(ATTEMPT_LONG, test, base, offset, oldVal, newVal, null));
        bc2ir.push(test.copyD2U());
    } else if (methodName == MagicNames.attemptObject) {
        Operand newVal = bc2ir.popRef();
        Operand oldVal = bc2ir.popRef();
        Operand offset = bc2ir.popAddress();
        Operand base = bc2ir.popRef();
        RegisterOperand test = gc.getTemps().makeTempBoolean();
        bc2ir.appendInstruction(Attempt.create(ATTEMPT_ADDR, test, base, offset, oldVal, newVal, null));
        bc2ir.push(test.copyD2U());
    } else if (methodName == MagicNames.attemptAddress) {
        Operand newVal = bc2ir.popAddress();
        Operand oldVal = bc2ir.popAddress();
        Operand offset = bc2ir.popAddress();
        Operand base = bc2ir.popRef();
        RegisterOperand test = gc.getTemps().makeTempBoolean();
        bc2ir.appendInstruction(Attempt.create(ATTEMPT_ADDR, test, base, offset, oldVal, newVal, null));
        bc2ir.push(test.copyD2U());
    } else if (methodName == MagicNames.attemptWord) {
        Operand newVal = bc2ir.pop();
        Operand oldVal = bc2ir.pop();
        Operand offset = bc2ir.popAddress();
        Operand base = bc2ir.popRef();
        RegisterOperand test = gc.getTemps().makeTempBoolean();
        bc2ir.appendInstruction(Attempt.create(ATTEMPT_ADDR, test, base, offset, oldVal, newVal, null));
        bc2ir.push(test.copyD2U());
    } else if (methodName == MagicNames.fence) {
        bc2ir.appendInstruction(Empty.create(FENCE));
    } else if (methodName == MagicNames.combinedLoadBarrier) {
        bc2ir.appendInstruction(Empty.create(READ_CEILING));
    } else if (methodName == MagicNames.storeStoreBarrier) {
        bc2ir.appendInstruction(Empty.create(WRITE_FLOOR));
    } else if (generatePolymorphicMagic(bc2ir, gc, meth, methodName)) {
        return true;
    } else if (methodName == MagicNames.getTimeBase) {
        RegisterOperand op0 = gc.getTemps().makeTempLong();
        bc2ir.appendInstruction(Nullary.create(GET_TIME_BASE, op0));
        bc2ir.pushDual(op0.copyD2U());
    } else if (methodName == MagicNames.getInlineDepth) {
        bc2ir.push(new IntConstantOperand(gc.getInlineSequence().getInlineDepth()));
    } else if (methodName == MagicNames.getCompilerLevel) {
        bc2ir.push(new IntConstantOperand(gc.getOptions().getOptLevel()));
    } else if (methodName == MagicNames.isConstantParameter) {
        Operand requestedOperand = bc2ir.pop();
        if (!(requestedOperand instanceof IntConstantOperand)) {
            throw new OptimizingCompilerException("Must supply constant to Magic.isConstantParameter");
        }
        int requested = ((IntConstantOperand) (requestedOperand)).value;
        boolean isConstant = gc.getArguments()[requested].isConstant();
        bc2ir.push(new IntConstantOperand(isConstant ? 1 : 0));
    } else if (methodName == MagicNames.getFrameSize) {
        RegisterOperand res = gc.getTemps().makeTempInt();
        gc.forceFrameAllocation();
        bc2ir.appendInstruction(Nullary.create(FRAMESIZE, res));
        bc2ir.push(res.copyD2U());
    } else {
        // Wasn't machine-independent, so try the machine-dependent magics next.
        if (VM.BuildForIA32) {
            return org.jikesrvm.compilers.opt.bc2ir.ia32.GenerateMachineSpecificMagic.generateMagic(bc2ir, gc, meth);
        } else {
            if (VM.VerifyAssertions)
                VM._assert(VM.BuildForPowerPC);
            return org.jikesrvm.compilers.opt.bc2ir.ppc.GenerateMachineSpecificMagic.generateMagic(bc2ir, gc, meth);
        }
    }
    return true;
}

Example 10 with ObjectConstantOperand

use of org.jikesrvm.compilers.opt.ir.operand.ObjectConstantOperand in project JikesRVM by JikesRVM.

the class NormalizeConstants method perform.

/**
 * Only thing we do for IA32 is to restrict the usage of
 * String, Float, and Double constants.  The rules are prepared
 * to deal with everything else.
 *
 * @param ir IR to normalize
 */
public static void perform(IR ir) {
    for (Instruction s = ir.firstInstructionInCodeOrder(); s != null; s = s.nextInstructionInCodeOrder()) {
        // Get 'large' constants into a form the the BURS rules are
        // prepared to deal with.
        // Constants can't appear as defs, so only scan the uses.
        // 
        int numUses = s.getNumberOfUses();
        if (numUses > 0) {
            int numDefs = s.getNumberOfDefs();
            for (int idx = numDefs; idx < numUses + numDefs; idx++) {
                Operand use = s.getOperand(idx);
                if (use != null) {
                    if (use instanceof ObjectConstantOperand) {
                        ObjectConstantOperand oc = (ObjectConstantOperand) use;
                        if (oc.isMovableObjectConstant()) {
                            RegisterOperand rop = ir.regpool.makeTemp(use.getType());
                            Operand jtoc = ir.regpool.makeJTOCOp();
                            Offset offset = oc.offset;
                            if (offset.isZero()) {
                                if (use instanceof StringConstantOperand) {
                                    throw new OptimizingCompilerException("String constant w/o valid JTOC offset");
                                } else if (use instanceof ClassConstantOperand) {
                                    throw new OptimizingCompilerException("Class constant w/o valid JTOC offset");
                                }
                                offset = Offset.fromIntSignExtend(Statics.findOrCreateObjectLiteral(oc.value));
                            }
                            LocationOperand loc = new LocationOperand(offset);
                            s.insertBefore(Load.create(IA32_REF_LOAD, rop, jtoc, wordOperandForReference(offset.toWord()), loc));
                            s.putOperand(idx, rop.copyD2U());
                        } else {
                            // Ensure object is in JTOC to keep it alive
                            Statics.findOrCreateObjectLiteral(oc.value);
                            s.putOperand(idx, wordOperandForReference(Magic.objectAsAddress(oc.value).toWord()));
                        }
                    } else if (use instanceof DoubleConstantOperand) {
                        RegisterOperand rop = ir.regpool.makeTemp(TypeReference.Double);
                        Operand jtoc = ir.regpool.makeJTOCOp();
                        DoubleConstantOperand dc = (DoubleConstantOperand) use.copy();
                        if (dc.offset.isZero()) {
                            dc.offset = Offset.fromIntSignExtend(Statics.findOrCreateLongSizeLiteral(Double.doubleToLongBits(dc.value)));
                        }
                        s.insertBefore(Binary.create(MATERIALIZE_FP_CONSTANT, rop, jtoc, dc));
                        s.putOperand(idx, rop.copyD2U());
                    } else if (use instanceof FloatConstantOperand) {
                        RegisterOperand rop = ir.regpool.makeTemp(TypeReference.Float);
                        Operand jtoc = ir.regpool.makeJTOCOp();
                        FloatConstantOperand fc = (FloatConstantOperand) use.copy();
                        if (fc.offset.isZero()) {
                            fc.offset = Offset.fromIntSignExtend(Statics.findOrCreateIntSizeLiteral(Float.floatToIntBits(fc.value)));
                        }
                        s.insertBefore(Binary.create(MATERIALIZE_FP_CONSTANT, rop, jtoc, fc));
                        s.putOperand(idx, rop.copyD2U());
                    } else if (use instanceof NullConstantOperand) {
                        s.putOperand(idx, wordOperandForReference(Word.zero()));
                    } else if (use instanceof AddressConstantOperand) {
                        s.putOperand(idx, wordOperandForReference(((AddressConstantOperand) use).value.toWord()));
                    } else if (use instanceof TIBConstantOperand) {
                        RegisterOperand rop = ir.regpool.makeTemp(TypeReference.TIB);
                        Operand jtoc = ir.regpool.makeJTOCOp();
                        Offset offset = ((TIBConstantOperand) use).value.getTibOffset();
                        LocationOperand loc = new LocationOperand(offset);
                        s.insertBefore(Load.create(IA32_REF_LOAD, rop, jtoc, wordOperandForReference(offset.toWord()), loc));
                        s.putOperand(idx, rop.copyD2U());
                    } else if (use instanceof CodeConstantOperand) {
                        RegisterOperand rop = ir.regpool.makeTemp(TypeReference.CodeArray);
                        Operand jtoc = ir.regpool.makeJTOCOp();
                        Offset offset = ((CodeConstantOperand) use).value.findOrCreateJtocOffset();
                        LocationOperand loc = new LocationOperand(offset);
                        s.insertBefore(Load.create(IA32_REF_LOAD, rop, jtoc, wordOperandForReference(offset.toWord()), loc));
                        s.putOperand(idx, rop.copyD2U());
                    }
                }
            }
        }
    }
}