Java JavaConstant.isNull方法代码示例

import jdk.vm.ci.meta.JavaConstant; //导入方法依赖的package包/类
public static boolean canMoveConst2Stack(JavaConstant input) {
    switch (input.getJavaKind().getStackKind()) {
        case Int:
            break;
        case Long:
            break;
        case Float:
            break;
        case Double:
            break;
        case Object:
            if (input.isNull()) {
                return true;
            } else {
                return false;
            }
        default:
            return false;
    }
    return true;
}
 

import jdk.vm.ci.meta.JavaConstant; //导入方法依赖的package包/类
@Test
public void isInstanceTest() {
    for (ConstantValue cv : constants()) {
        JavaConstant c = cv.value;
        if (c.getJavaKind() == JavaKind.Object && !c.isNull()) {
            ResolvedJavaType cType = metaAccess.lookupJavaType(c);
            for (ResolvedJavaType t : javaTypes) {
                if (t.isAssignableFrom(cType)) {
                    assertTrue(t.isInstance(c));
                } else {
                    assertFalse(t.isInstance(c));
                }
            }
        }
    }
}
 

import jdk.vm.ci.meta.JavaConstant; //导入方法依赖的package包/类
@Override
public boolean canInlineConstant(Constant con) {
    if (con instanceof JavaConstant) {
        JavaConstant c = (JavaConstant) con;
        switch (c.getJavaKind()) {
            case Boolean:
            case Byte:
            case Char:
            case Short:
            case Int:
                return SPARCAssembler.isSimm13(c.asInt());
            case Long:
                return SPARCAssembler.isSimm13(c.asLong());
            case Object:
                return c.isNull();
            default:
                return false;
        }
    }
    return false;
}
 

import jdk.vm.ci.meta.JavaConstant; //导入方法依赖的package包/类
public static boolean isSimm13(JavaConstant constant) {
    long bits;
    switch (constant.getJavaKind()) {
        case Double:
            bits = Double.doubleToRawLongBits(constant.asDouble());
            break;
        case Float:
            bits = Float.floatToRawIntBits(constant.asFloat());
            break;
        case Object:
            return constant.isNull();
        default:
            bits = constant.asLong();
            break;
    }
    return constant.isNull() || isSimm13(bits);
}
 

import jdk.vm.ci.meta.JavaConstant; //导入方法依赖的package包/类
protected boolean emitCompareMemoryConOp(OperandSize size, ConstantValue a, AMD64AddressValue b, LIRFrameState state) {
    if (JavaConstant.isNull(a.getConstant())) {
        append(new AMD64BinaryConsumer.MemoryConstOp(CMP, size, b, 0, state));
        return true;
    } else if (a.getConstant() instanceof VMConstant && size == DWORD) {
        VMConstant vc = (VMConstant) a.getConstant();
        append(new AMD64BinaryConsumer.MemoryVMConstOp(CMP.getMIOpcode(size, false), b, vc, state));
        return true;
    } else {
        long value = a.getJavaConstant().asLong();
        if (NumUtil.is32bit(value)) {
            append(new AMD64BinaryConsumer.MemoryConstOp(CMP, size, b, (int) value, state));
            return true;
        } else {
            return emitCompareRegMemoryOp(size, asAllocatable(a), b, state);
        }
    }
}
 

import jdk.vm.ci.meta.JavaConstant; //导入方法依赖的package包/类
private static void const2stack(CompilationResultBuilder crb, AArch64MacroAssembler masm, Value result, JavaConstant constant) {
    try (ScratchRegister addrReg = masm.getScratchRegister()) {
        StackSlot slot = (StackSlot) result;
        AArch64Address resultAddress = loadStackSlotAddress(crb, masm, slot, addrReg.getRegister());
        if (constant.isDefaultForKind() || constant.isNull()) {
            emitStore(crb, masm, (AArch64Kind) result.getPlatformKind(), resultAddress, zr.asValue(LIRKind.combine(result)));
        } else {
            try (ScratchRegister sc = masm.getScratchRegister()) {
                Value scratchRegisterValue = sc.getRegister().asValue(LIRKind.combine(result));
                const2reg(crb, masm, scratchRegisterValue, constant);
                emitStore(crb, masm, (AArch64Kind) result.getPlatformKind(), resultAddress, scratchRegisterValue);
            }
        }
    }
}
 

import jdk.vm.ci.meta.JavaConstant; //导入方法依赖的package包/类
@Override
public <T> T asObject(Class<T> type, JavaConstant constant) {
    if (constant.isNull()) {
        return null;
    }
    HotSpotObjectConstant hsConstant = (HotSpotObjectConstant) constant;
    return hsConstant.asObject(type);
}
 

import jdk.vm.ci.meta.JavaConstant; //导入方法依赖的package包/类
public Value loadSimm13(Value value) {
    if (isJavaConstant(value)) {
        JavaConstant c = asJavaConstant(value);
        if (c.isNull() || SPARCAssembler.isSimm13(c)) {
            return value;
        }
    }
    return load(value);
}
 

import jdk.vm.ci.meta.JavaConstant; //导入方法依赖的package包/类
public static Stamp forConstant(JavaConstant value) {
    JavaKind kind = value.getJavaKind();
    switch (kind) {
        case Boolean:
        case Byte:
        case Char:
        case Short:
        case Int:
        case Long:
            long mask = value.asLong() & CodeUtil.mask(kind.getBitCount());
            return forInteger(kind.getStackKind(), value.asLong(), value.asLong(), mask, mask);
        case Float:
            return forFloat(kind, value.asFloat(), value.asFloat(), !Float.isNaN(value.asFloat()));
        case Double:
            return forFloat(kind, value.asDouble(), value.asDouble(), !Double.isNaN(value.asDouble()));
        case Illegal:
            return forKind(JavaKind.Illegal);
        case Object:
            if (value.isNull()) {
                return alwaysNull();
            } else {
                return objectNonNull();
            }
        default:
            throw new GraalError("unexpected kind: %s", kind);
    }
}
 

import jdk.vm.ci.meta.JavaConstant; //导入方法依赖的package包/类
protected static boolean isArithmeticConstant(JavaConstant constValue) {
    switch (constValue.getJavaKind()) {
        case Int:
        case Long:
            return AArch64MacroAssembler.isArithmeticImmediate(constValue.asLong());
        case Object:
            return constValue.isNull();
        default:
            return false;
    }
}
 

import jdk.vm.ci.meta.JavaConstant; //导入方法依赖的package包/类
@Override
public JavaConstant unboxPrimitive(JavaConstant source) {
    if (source == null || !source.getJavaKind().isObject()) {
        return null;
    }
    if (source.isNull()) {
        return null;
    }
    return JavaConstant.forBoxedPrimitive(((HotSpotObjectConstantImpl) source).object());
}
 

import jdk.vm.ci.meta.JavaConstant; //导入方法依赖的package包/类
static Object asBoxedValue(Constant constant) {
    if (JavaConstant.isNull(constant)) {
        return null;
    } else if (constant instanceof HotSpotObjectConstantImpl) {
        return ((HotSpotObjectConstantImpl) constant).object;
    } else {
        return ((JavaConstant) constant).asBoxedPrimitive();
    }
}
 

import jdk.vm.ci.meta.JavaConstant; //导入方法依赖的package包/类
/**
 * Checks whether the supplied constant can be used without loading it into a register for store
 * operations, i.e., on the right hand side of a memory access.
 *
 * @param c The constant to check.
 * @return True if the constant can be used directly, false if the constant needs to be in a
 *         register.
 */
protected static final boolean canStoreConstant(JavaConstant c) {
    // there is no immediate move of 64-bit constants on Intel
    switch (c.getJavaKind()) {
        case Long:
            return NumUtil.isInt(c.asLong());
        case Double:
            return false;
        case Object:
            return c.isNull();
        default:
            return true;
    }
}
 

import jdk.vm.ci.meta.JavaConstant; //导入方法依赖的package包/类
@Test
public void lookupJavaTypeConstantTest() {
    for (ConstantValue cv : constants()) {
        JavaConstant c = cv.value;
        if (c.getJavaKind() == JavaKind.Object && !c.isNull()) {
            Object o = cv.boxed;
            ResolvedJavaType type = metaAccess.lookupJavaType(c);
            assertNotNull(type);
            assertTrue(type.equals(metaAccess.lookupJavaType(o.getClass())));
        } else {
            assertEquals(metaAccess.lookupJavaType(c), null);
        }
    }
}
 

import jdk.vm.ci.meta.JavaConstant; //导入方法依赖的package包/类
private static void const2reg(CompilationResultBuilder crb, AArch64MacroAssembler masm, Value result, JavaConstant input) {
    Register dst = asRegister(result);
    switch (input.getJavaKind().getStackKind()) {
        case Int:
            final int value = input.asInt();
            int maskedValue;
            switch (input.getJavaKind()) {
                case Boolean:
                case Byte:
                    maskedValue = value & 0xFF;
                    break;
                case Char:
                case Short:
                    maskedValue = value & 0xFFFF;
                    break;
                case Int:
                    maskedValue = value;
                    break;
                default:
                    throw GraalError.shouldNotReachHere();
            }
            masm.mov(dst, maskedValue);
            break;
        case Long:
            masm.mov(dst, input.asLong());
            break;
        case Float:
            if (AArch64MacroAssembler.isFloatImmediate(input.asFloat())) {
                masm.fmov(32, dst, input.asFloat());
            } else {
                masm.fldr(32, dst, (AArch64Address) crb.asFloatConstRef(input));
            }
            break;
        case Double:
            if (AArch64MacroAssembler.isDoubleImmediate(input.asDouble())) {
                masm.fmov(64, dst, input.asDouble());
            } else {
                masm.fldr(64, dst, (AArch64Address) crb.asDoubleConstRef(input));
            }
            break;
        case Object:
            if (input.isNull()) {
                masm.mov(dst, 0);
            } else if (crb.target.inlineObjects) {
                crb.recordInlineDataInCode(input);
                masm.movNativeAddress(dst, 0xDEADDEADDEADDEADL);
            } else {
                masm.ldr(64, dst, (AArch64Address) crb.recordDataReferenceInCode(input, 8));
            }
            break;
        default:
            throw GraalError.shouldNotReachHere("kind=" + input.getJavaKind().getStackKind());
    }
}