Java Constant类代码示例

import jdk.vm.ci.meta.Constant; //导入依赖的package包/类
protected void emitComparison(Constant c) {
    JavaConstant jc = (JavaConstant) c;
    switch (jc.getJavaKind()) {
        case Int:
            long lc = jc.asLong();
            assert NumUtil.isInt(lc);
            masm.cmpl(keyRegister, (int) lc);
            break;
        case Long:
            masm.cmpq(keyRegister, (AMD64Address) crb.asLongConstRef(jc));
            break;
        case Object:
            AMD64Move.const2reg(crb, masm, asRegister(scratch), jc);
            masm.cmpptr(keyRegister, asRegister(scratch));
            break;
        default:
            throw new GraalError("switch only supported for int, long and object");
    }
}
 

import jdk.vm.ci.meta.Constant; //导入依赖的package包/类
@Override
public Stamp constant(Constant c, MetaAccessProvider meta) {
    if (isCompressed()) {
        if (HotSpotCompressedNullConstant.COMPRESSED_NULL.equals(c)) {
            return new KlassPointerStamp(false, true, encoding);
        }
    } else {
        if (JavaConstant.NULL_POINTER.equals(c)) {
            return KLASS_ALWAYS_NULL;
        }
    }

    assert c instanceof HotSpotMetaspaceConstant;
    assert ((HotSpotMetaspaceConstant) c).isCompressed() == isCompressed();
    if (nonNull()) {
        return this;
    }
    if (isCompressed()) {
        return new KlassPointerStamp(true, false, encoding);
    } else {
        return KLASS_NON_NULL;
    }
}
 

import jdk.vm.ci.meta.Constant; //导入依赖的package包/类
private void processFixedGuardAndMerge(FixedGuardNode fixedGuard, PhaseContext context, CompareNode compare, ValueNode x, ValuePhiNode xPhi, ValueNode y, ValuePhiNode yPhi,
                AbstractMergeNode merge) {
    List<EndNode> mergePredecessors = merge.cfgPredecessors().snapshot();
    for (int i = 0; i < mergePredecessors.size(); ++i) {
        AbstractEndNode mergePredecessor = mergePredecessors.get(i);
        if (!mergePredecessor.isAlive()) {
            break;
        }
        Constant xs;
        if (xPhi == null) {
            xs = x.asConstant();
        } else {
            xs = xPhi.valueAt(mergePredecessor).asConstant();
        }
        Constant ys;
        if (yPhi == null) {
            ys = y.asConstant();
        } else {
            ys = yPhi.valueAt(mergePredecessor).asConstant();
        }
        if (xs != null && ys != null && compare.condition().foldCondition(xs, ys, context.getConstantReflection(), compare.unorderedIsTrue()) == fixedGuard.isNegated()) {
            visitDeoptBegin(AbstractBeginNode.prevBegin(mergePredecessor), fixedGuard.getAction(), fixedGuard.getReason(), fixedGuard.getSpeculation(), fixedGuard.graph(), context.getLowerer());
        }
    }
}
 

import jdk.vm.ci.meta.Constant; //导入依赖的package包/类
public SequentialStrategy(final double[] keyProbabilities, Constant[] keyConstants) {
    super(keyProbabilities);
    assert keyProbabilities.length == keyConstants.length;

    this.keyConstants = keyConstants;
    int keyCount = keyConstants.length;
    indexes = new Integer[keyCount];
    for (int i = 0; i < keyCount; i++) {
        indexes[i] = i;
    }
    Arrays.sort(indexes, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return keyProbabilities[o1] < keyProbabilities[o2] ? 1 : keyProbabilities[o1] > keyProbabilities[o2] ? -1 : 0;
        }
    });
}
 

import jdk.vm.ci.meta.Constant; //导入依赖的package包/类
@Override
public LIRInstruction createLoad(AllocatableValue dst, Constant src) {
    if (src instanceof JavaConstant) {
        JavaConstant javaConstant = (JavaConstant) src;
        if (canInlineConstant(javaConstant)) {
            return new AArch64Move.LoadInlineConstant(javaConstant, dst);
        } else {
            // return new AArch64Move.LoadConstantFromTable(javaConstant,
            // constantTableBaseProvider.getConstantTableBase(), dst);
            return new AArch64Move.LoadInlineConstant(javaConstant, dst);
        }
    } else if (src instanceof DataPointerConstant) {
        return new AArch64Move.LoadDataOp(dst, (DataPointerConstant) src);
    } else {
        // throw GraalError.shouldNotReachHere(src.getClass().toString());
        throw GraalError.unimplemented();
    }
}
 

import jdk.vm.ci.meta.Constant; //导入依赖的package包/类
private static ValueNode canonical(XorNode self, BinaryOp<Xor> op, Stamp stamp, ValueNode forX, ValueNode forY) {
    if (GraphUtil.unproxify(forX) == GraphUtil.unproxify(forY)) {
        return ConstantNode.forPrimitive(stamp, op.getZero(forX.stamp()));
    }
    if (forX.isConstant() && !forY.isConstant()) {
        return new XorNode(forY, forX);
    }
    if (forY.isConstant()) {
        Constant c = forY.asConstant();
        if (op.isNeutral(c)) {
            return forX;
        }

        if (c instanceof PrimitiveConstant && ((PrimitiveConstant) c).getJavaKind().isNumericInteger()) {
            long rawY = ((PrimitiveConstant) c).asLong();
            long mask = CodeUtil.mask(PrimitiveStamp.getBits(stamp));
            if ((rawY & mask) == mask) {
                return new NotNode(forX);
            }
        }
        return reassociate(self != null ? self : (XorNode) new XorNode(forX, forY).maybeCommuteInputs(), ValueNode.isConstantPredicate(), forX, forY);
    }
    return self != null ? self : new XorNode(forX, forY).maybeCommuteInputs();
}
 

import jdk.vm.ci.meta.Constant; //导入依赖的package包/类
/**
 * This method creates a load from the constant section. It automatically respects the different
 * patterns used for small constant sections (<8k) and large constant sections (>=8k). The
 * generated patterns by this method must be understood by
 * CodeInstaller::pd_patch_DataSectionReference (jvmciCodeInstaller_sparc.cpp).
 */
public static void loadFromConstantTable(CompilationResultBuilder crb, SPARCMacroAssembler masm, int byteCount, Register constantTableBase, Constant input, Register dest,
                SPARCDelayedControlTransfer delaySlotInstruction) {
    SPARCAddress address;
    ScratchRegister scratch = null;
    try {
        if (masm.isImmediateConstantLoad()) {
            address = new SPARCAddress(constantTableBase, 0);
            // Make delayed only, when using immediate constant load.
            delaySlotInstruction.emitControlTransfer(crb, masm);
            crb.recordDataReferenceInCode(input, byteCount);
        } else {
            scratch = masm.getScratchRegister();
            Register sr = scratch.getRegister();
            crb.recordDataReferenceInCode(input, byteCount);
            masm.sethix(0, sr, true);
            address = new SPARCAddress(sr, 0);
        }
        masm.ld(address, dest, byteCount, false);
    } finally {
        if (scratch != null) {
            scratch.close();
        }
    }
}
 

import jdk.vm.ci.meta.Constant; //导入依赖的package包/类
@Override
public boolean isCompatible(Constant constant) {
    if (constant instanceof HotSpotMetaspaceConstant) {
        return ((HotSpotMetaspaceConstant) constant).asResolvedJavaMethod() != null;
    } else {
        return super.isCompatible(constant);
    }
}
 

import jdk.vm.ci.meta.Constant; //导入依赖的package包/类
private static ValueNode canonical(UnsignedMulHighNode self, ValueNode forY) {
    if (forY.isConstant()) {
        Constant c = forY.asConstant();
        if (c instanceof PrimitiveConstant && ((PrimitiveConstant) c).getJavaKind().isNumericInteger()) {
            long i = ((PrimitiveConstant) c).asLong();
            if (i == 0 || i == 1) {
                return ConstantNode.forIntegerStamp(self.stamp(), 0);
            }
        }
    }
    return self;
}
 

import jdk.vm.ci.meta.Constant; //导入依赖的package包/类
private static ValueNode canonical(IntegerMulHighNode self, ValueNode forY) {
    if (forY.isConstant()) {
        Constant c = forY.asConstant();
        if (c instanceof PrimitiveConstant && ((PrimitiveConstant) c).getJavaKind().isNumericInteger()) {
            long i = ((PrimitiveConstant) c).asLong();
            if (i == 0 || i == 1) {
                return ConstantNode.forIntegerStamp(self.stamp(), 0);
            }
        }
    }
    return self;
}
 

import jdk.vm.ci.meta.Constant; //导入依赖的package包/类
public DataOp(AMD64RMOp opcode, OperandSize size, AllocatableValue x, Constant y, int alignment) {
    super(TYPE);
    this.opcode = opcode;
    this.size = size;

    this.x = x;
    this.y = y;

    this.alignment = alignment;
}
 

import jdk.vm.ci.meta.Constant; //导入依赖的package包/类
@Override
protected void emitComparison(Constant c) {
    if (c instanceof HotSpotMetaspaceConstant) {
        HotSpotMetaspaceConstant meta = (HotSpotMetaspaceConstant) c;
        if (meta.isCompressed()) {
            crb.recordInlineDataInCode(meta);
            masm.cmpl(keyRegister, 0xDEADDEAD);
        } else {
            AMD64Address addr = (AMD64Address) crb.recordDataReferenceInCode(meta, 8);
            masm.cmpq(keyRegister, addr);
        }
    } else {
        super.emitComparison(c);
    }
}
 

import jdk.vm.ci.meta.Constant; //导入依赖的package包/类
@Override
protected Constant compress(Constant c) {
    if (JavaConstant.NULL_POINTER.equals(c)) {
        return HotSpotCompressedNullConstant.COMPRESSED_NULL;
    } else if (c instanceof HotSpotConstant) {
        return ((HotSpotConstant) c).compress();
    } else {
        throw GraalError.shouldNotReachHere("invalid constant input for compress op: " + c);
    }
}
 

import jdk.vm.ci.meta.Constant; //导入依赖的package包/类
@Override
public Value emitLoadObjectAddress(Constant constant) {
    HotSpotObjectConstant objectConstant = (HotSpotObjectConstant) constant;
    LIRKind kind = objectConstant.isCompressed() ? getLIRKindTool().getNarrowOopKind() : getLIRKindTool().getObjectKind();
    Variable result = newVariable(kind);
    append(new AMD64HotSpotLoadAddressOp(result, constant, HotSpotConstantLoadAction.RESOLVE));
    return result;
}
 

import jdk.vm.ci.meta.Constant; //导入依赖的package包/类
@Override
public Value emitConstant(LIRKind kind, Constant constant) {
    if (moveFactory.canInlineConstant(constant)) {
        return new ConstantValue(toRegisterKind(kind), constant);
    } else {
        return emitLoadConstant(kind, constant);
    }
}