int ReplicationFactor, VF;
if (Shuffle->isReplicationMask(ReplicationFactor, VF)) {
APInt DemandedDstElts =
- APInt::getNullValue(Shuffle->getShuffleMask().size());
+ APInt::getZero(Shuffle->getShuffleMask().size());
for (auto I : enumerate(Shuffle->getShuffleMask())) {
if (I.value() != UndefMaskElem)
DemandedDstElts.setBit(I.index());
bool IsInLaneMask = true;
ArrayRef<int> Mask = SVN->getMask();
SmallVector<int, 16> ClearMask(NumElts, -1);
- APInt DemandedLHS = APInt::getNullValue(NumElts);
- APInt DemandedRHS = APInt::getNullValue(NumElts);
+ APInt DemandedLHS = APInt::getZero(NumElts);
+ APInt DemandedRHS = APInt::getZero(NumElts);
for (int I = 0; I != (int)NumElts; ++I) {
int M = Mask[I];
if (M < 0)
unsigned NumElts = VT.getVectorNumElements();
assert(DemandedElts.getBitWidth() == NumElts && "Unexpected demanded mask.");
- APInt KnownZeroElements = APInt::getNullValue(NumElts);
+ APInt KnownZeroElements = APInt::getZero(NumElts);
for (unsigned EltIdx = 0; EltIdx != NumElts; ++EltIdx) {
if (!DemandedElts[EltIdx])
continue; // Don't query elements that are not demanded.
}
case ISD::VECTOR_SHUFFLE: {
// Check if this is a shuffle node doing a splat or a shuffle of a splat.
- APInt DemandedLHS = APInt::getNullValue(NumElts);
- APInt DemandedRHS = APInt::getNullValue(NumElts);
+ APInt DemandedLHS = APInt::getZero(NumElts);
+ APInt DemandedRHS = APInt::getZero(NumElts);
ArrayRef<int> Mask = cast<ShuffleVectorSDNode>(V)->getMask();
for (int i = 0; i != (int)NumElts; ++i) {
int M = Mask[i];
// Extract raw src bits.
SmallVector<APInt> SrcBitElements(NumSrcOps,
- APInt::getNullValue(SrcEltSizeInBits));
+ APInt::getZero(SrcEltSizeInBits));
BitVector SrcUndeElements(NumSrcOps, false);
for (unsigned I = 0; I != NumSrcOps; ++I) {
unsigned NumDstOps = (NumSrcOps * SrcEltSizeInBits) / DstEltSizeInBits;
DstUndefElements.clear();
DstUndefElements.resize(NumDstOps, false);
- DstBitElements.assign(NumDstOps, APInt::getNullValue(DstEltSizeInBits));
+ DstBitElements.assign(NumDstOps, APInt::getZero(DstEltSizeInBits));
// Concatenate src elements constant bits together into dst element.
if (SrcEltSizeInBits <= DstEltSizeInBits) {
const MCExpr *Expr = MO.getExpr();
MCFixupKind Kind = (MCFixupKind)AMDGPU::fixup_si_sopp_br;
Fixups.push_back(MCFixup::create(0, Expr, Kind, MI.getLoc()));
- Op = APInt::getNullValue(96);
+ Op = APInt::getZero(96);
} else {
getMachineOpValue(MI, MO, Op, Fixups, STI);
}
SmallVector<APInt> SrcEltBits;
unsigned SrcEltSizeInBits = VT.getScalarSizeInBits();
if (BV->getConstantRawBits(true, SrcEltSizeInBits, SrcEltBits, Undefs)) {
- APInt UndefSrcElts = APInt::getNullValue(SrcEltBits.size());
+ APInt UndefSrcElts = APInt::getZero(SrcEltBits.size());
for (unsigned I = 0, E = SrcEltBits.size(); I != E; ++I)
if (Undefs[I])
UndefSrcElts.setBit(I);
if (V2 && V2.getValueSizeInBits() != VT.getSizeInBits())
V2 = SDValue();
- APInt ZeroV1 = APInt::getNullValue(Size);
- APInt ZeroV2 = APInt::getNullValue(Size);
+ APInt ZeroV1 = APInt::getZero(Size);
+ APInt ZeroV2 = APInt::getZero(Size);
for (int i = 0; i < Size; ++i) {
int MaskIdx = Mask[i];
OpInputs.assign({SrcVec});
OpMask.assign(NumElts, SM_SentinelUndef);
std::iota(OpMask.begin(), OpMask.end(), ExtractIdx);
- OpZero = OpUndef = APInt::getNullValue(NumElts);
+ OpZero = OpUndef = APInt::getZero(NumElts);
} else {
return SDValue();
}
switch (Opc) {
case X86ISD::VBROADCAST:
case X86ISD::VBROADCAST_LOAD:
- UndefElts = APInt::getNullValue(NumElts);
+ UndefElts = APInt::getZero(NumElts);
return true;
}
// Attempt to fold target constant loads.
if (all_of(Ops, [](SDValue Op) { return getTargetConstantFromNode(Op); })) {
SmallVector<APInt> EltBits;
- APInt UndefElts = APInt::getNullValue(VT.getVectorNumElements());
+ APInt UndefElts = APInt::getZero(VT.getVectorNumElements());
for (unsigned I = 0, E = Ops.size(); I != E; ++I) {
APInt OpUndefElts;
SmallVector<APInt> OpEltBits;
static Domain getDomain(const ConstantRange &CR) {
if (CR.isAllNonNegative())
return Domain::NonNegative;
- if (CR.icmp(ICmpInst::ICMP_SLE, APInt::getNullValue(CR.getBitWidth())))
+ if (CR.icmp(ICmpInst::ICMP_SLE, APInt::getZero(CR.getBitWidth())))
return Domain::NonPositive;
return Domain::Unknown;
}
static Attribute minMaxValueForUnsignedInt(Type type, bool min) {
auto intType = type.cast<IntegerType>();
unsigned bitwidth = intType.getWidth();
- return IntegerAttr::get(type, min ? llvm::APInt::getNullValue(bitwidth)
+ return IntegerAttr::get(type, min ? llvm::APInt::getZero(bitwidth)
: llvm::APInt::getAllOnesValue(bitwidth));
}