|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
References
examples/Fibonacci/fibonacci.cpp 141 Args[0].IntVal = APInt(32, n);
examples/ParallelJIT/ParallelJIT.cpp 249 Args[0].IntVal = APInt(32, p->value);
include/llvm/ADT/APSInt.h 65 APInt::operator=(std::move(RHS));
include/llvm/ADT/DenseMap.h 379 DestBucket->getFirst() = std::move(B->getFirst());
include/llvm/ADT/Optional.h 129 value = std::move(other.value);
include/llvm/Analysis/PtrUseVisitor.h 227 Offset = APInt(IntPtrTy->getBitWidth(), 0);
239 Offset = std::move(ToVisit.Offset);
274 Offset = APInt();
include/llvm/Analysis/ScalarEvolutionExpressions.h 70 Size = Size.uadd_sat(APInt(16, Arg->getExpressionSize()));
include/llvm/Support/type_traits.h 130 static auto get(F*) -> decltype(std::declval<F &>() = std::declval<F &&>(), std::true_type{});
lib/Analysis/BasicAliasAnalysis.cpp 396 Offset = Offset.trunc(SmallWidth).sext(NewWidth).zextOrSelf(OldWidth);
624 Scale = adjustToPointerSize(Scale, PointerSize);
634 Decomposed.StructOffset =
636 Decomposed.OtherOffset =
1316 DecompGEP1.StructOffset = DecompGEP1.OtherOffset = APInt(MaxPointerSize, 0);
1317 DecompGEP2.StructOffset = DecompGEP2.OtherOffset = APInt(MaxPointerSize, 0);
1503 Modulo = Modulo ^ (Modulo & (Modulo - 1));
lib/Analysis/BlockFrequencyInfo.cpp 247 BBFreq = BBFreq.udiv(OldFreq);
lib/Analysis/BlockFrequencyInfoImpl.cpp 580 BlockCount = (BlockCount + EntryFreq.lshr(1)).udiv(EntryFreq);
lib/Analysis/CmpInstAnalysis.cpp 82 Mask = APInt::getSignMask(C->getBitWidth());
89 Mask = APInt::getSignMask(C->getBitWidth());
96 Mask = APInt::getSignMask(C->getBitWidth());
103 Mask = APInt::getSignMask(C->getBitWidth());
110 Mask = -*C;
117 Mask = ~*C;
124 Mask = ~*C;
131 Mask = -*C;
137 Mask = Mask.zext(X->getType()->getScalarSizeInBits());
lib/Analysis/ConstantFolding.cpp 293 Offset = APInt(BitWidth, 0);
666 StrVal = (StrVal << 8) | SingleChar;
671 StrVal = (StrVal << 8) | SingleChar;
675 StrVal = (StrVal << 8) | SingleChar;
903 BasePtr = Base->getValue().zextOrTrunc(BitWidth);
2159 Res = C0->sadd_ov(*C1, Overflow);
2162 Res = C0->uadd_ov(*C1, Overflow);
2165 Res = C0->ssub_ov(*C1, Overflow);
2168 Res = C0->usub_ov(*C1, Overflow);
2171 Res = C0->smul_ov(*C1, Overflow);
2174 Res = C0->umul_ov(*C1, Overflow);
lib/Analysis/DemandedBits.cpp 123 AB = AOut.byteSwap();
128 AB = AOut.reverseBits();
136 AB = APInt::getHighBitsSet(BitWidth,
146 AB = APInt::getLowBitsSet(BitWidth,
166 AB = AOut.lshr(ShiftAmt);
168 AB = AOut.shl(BitWidth - ShiftAmt);
180 AB = APInt::getLowBitsSet(BitWidth, AOut.getActiveBits());
187 AB = AOut.lshr(ShiftAmt);
204 AB = AOut.shl(ShiftAmt);
218 AB = AOut.shl(ShiftAmt);
264 AB = AOut.zext(BitWidth);
267 AB = AOut.trunc(BitWidth);
270 AB = AOut.trunc(BitWidth);
341 AliveBits[J] = APInt::getAllOnesValue(T->getScalarSizeInBits());
388 AB = APInt(BitWidth, 0);
408 Res.first->second = std::move(AB);
lib/Analysis/DependenceAnalysis.cpp 1388 Remainder = Distance.srem(Two);
1426 X = AM.slt(0) ? -A1 : A1;
1427 Y = BM.slt(0) ? B1 : -B1;
1430 R = Delta.srem(G);
1433 Q = Delta.sdiv(G);
1548 TL = maxAPInt(TL, ceilingOfQuotient(-X, TMUL));
1551 TU = minAPInt(TU, floorOfQuotient(UM - X, TMUL));
1556 TU = minAPInt(TU, floorOfQuotient(-X, TMUL));
1559 TL = maxAPInt(TL, ceilingOfQuotient(UM - X, TMUL));
1565 TMUL = AM.sdiv(G);
1567 TL = maxAPInt(TL, ceilingOfQuotient(-Y, TMUL));
1570 TU = minAPInt(TU, floorOfQuotient(UM - Y, TMUL));
1575 TU = minAPInt(TU, floorOfQuotient(-Y, TMUL));
1578 TL = maxAPInt(TL, ceilingOfQuotient(UM - Y, TMUL));
1595 TMUL = AM - BM;
1597 TL = maxAPInt(TL, ceilingOfQuotient(X - Y + 1, TMUL));
1601 TU = minAPInt(TU, floorOfQuotient(X - Y + 1, TMUL));
1614 TL = maxAPInt(TL, ceilingOfQuotient(X - Y, TMUL));
1618 TU = minAPInt(TU, floorOfQuotient(X - Y, TMUL));
1621 TMUL = BM - AM;
1623 TL = maxAPInt(TL, ceilingOfQuotient(Y - X, TMUL));
1627 TU = minAPInt(TU, floorOfQuotient(Y - X, TMUL));
1640 TL = maxAPInt(TL, ceilingOfQuotient(Y - X + 1, TMUL));
1644 TU = minAPInt(TU, floorOfQuotient(Y - X + 1, TMUL));
1956 TL = maxAPInt(TL, ceilingOfQuotient(-X, TMUL));
1959 TU = minAPInt(TU, floorOfQuotient(SrcUM - X, TMUL));
1964 TU = minAPInt(TU, floorOfQuotient(-X, TMUL));
1967 TL = maxAPInt(TL, ceilingOfQuotient(SrcUM - X, TMUL));
1973 TMUL = AM.sdiv(G);
1975 TL = maxAPInt(TL, ceilingOfQuotient(-Y, TMUL));
1978 TU = minAPInt(TU, floorOfQuotient(DstUM - Y, TMUL));
1983 TU = minAPInt(TU, floorOfQuotient(-Y, TMUL));
1986 TL = maxAPInt(TL, ceilingOfQuotient(DstUM - Y, TMUL));
2350 RunningGCD = APIntOps::GreatestCommonDivisor(RunningGCD, ConstCoeff.abs());
2369 RunningGCD = APIntOps::GreatestCommonDivisor(RunningGCD, ConstCoeff.abs());
2393 ExtraGCD = APIntOps::GreatestCommonDivisor(ExtraGCD,
2406 RunningGCD = APIntOps::GreatestCommonDivisor(RunningGCD, ExtraGCD);
2450 RunningGCD = APIntOps::GreatestCommonDivisor(RunningGCD, ConstCoeff.abs());
2467 RunningGCD = APIntOps::GreatestCommonDivisor(RunningGCD, ConstCoeff.abs());
2480 RunningGCD = APIntOps::GreatestCommonDivisor(RunningGCD, ConstCoeff.abs());
2483 Remainder = ConstDelta.srem(RunningGCD);
lib/Analysis/InstructionSimplify.cpp 666 Offset = Offset.sextOrTrunc(IntPtrTy->getIntegerBitWidth());
lib/Analysis/LoopAccessAnalysis.cpp 1206 OffsetA = OffsetA.sextOrTrunc(IdxWidth);
1207 OffsetB = OffsetB.sextOrTrunc(IdxWidth);
lib/Analysis/MemoryBuiltins.cpp 580 Zero = APInt::getNullValue(IntTyBits);
627 I = I.zextOrTrunc(IntTyBits);
646 Size = Size.umul_ov(NumElems, Overflow);
684 Size = MaxSize + 1;
710 Size = Size.umul_ov(NumElems, Overflow);
lib/Analysis/ScalarEvolution.cpp 959 DenominatorVal = DenominatorVal.sext(NumeratorBW);
961 NumeratorVal = NumeratorVal.sext(DenominatorBW);
1204 MultiplyFactor = MultiplyFactor.multiplicativeInverse(Mod);
1205 MultiplyFactor = MultiplyFactor.trunc(W);
3326 B = B.zext(ABW);
3328 A = A.zext(BBW);
5782 Step = Step.abs();
5909 TrueValue = TrueValue.trunc(BitWidth);
5910 FalseValue = FalseValue.trunc(BitWidth);
5913 TrueValue = TrueValue.zext(BitWidth);
5914 FalseValue = FalseValue.zext(BitWidth);
5917 TrueValue = TrueValue.sext(BitWidth);
5918 FalseValue = FalseValue.sext(BitWidth);
8467 N = N.sext(NewWidth);
8468 M = M.sext(NewWidth);
8469 L = L.sext(NewWidth);
9992 FoundRHSLimit = -(*RDiff);
9995 FoundRHSLimit = APInt::getSignedMinValue(getTypeSizeInBits(RHS->getType())) - *RDiff;
lib/Analysis/ValueTracking.cpp 902 Known.Zero = KZF(Known.Zero, ShiftAmt);
903 Known.One = KOF(Known.One, ShiftAmt);
1031 Known.One = (Known.Zero & Known2.One) | (Known.One & Known2.Zero);
1032 Known.Zero = std::move(KnownZeroOut);
1241 Known.Zero = Known2.Zero & LowBits;
1242 Known.One = Known2.One & LowBits;
1336 LocalKnown.Zero = LocalKnown.One = APInt(GEPOpiBits, 0);
1531 Known.Zero =
1533 Known.One =
1655 Known.Zero = ~Known.One;
5432 Lower = APInt::getSignedMinValue(Width);
5433 Upper = APInt::getSignedMaxValue(Width) + *C + 1;
5436 Lower = APInt::getSignedMinValue(Width) + *C;
5437 Upper = APInt::getSignedMaxValue(Width) + 1;
5446 Upper = *C + 1;
5458 Lower = APInt::getSignedMinValue(Width).ashr(*C);
5459 Upper = APInt::getSignedMaxValue(Width).ashr(*C) + 1;
5467 Upper = C->ashr(ShiftAmount) + 1;
5470 Lower = C->ashr(ShiftAmount);
5471 Upper = *C + 1;
5479 Upper = APInt::getAllOnesValue(Width).lshr(*C) + 1;
5485 Lower = C->lshr(ShiftAmount);
5486 Upper = *C + 1;
5495 Upper = Lower.shl(Lower.countLeadingZeros()) + 1;
5500 Lower = C->shl(ShiftAmount);
5501 Upper = *C + 1;
5506 Upper = C->shl(ShiftAmount) + 1;
5519 Lower = IntMin + 1;
5520 Upper = IntMax + 1;
5524 Lower = IntMin.sdiv(*C);
5525 Upper = IntMax.sdiv(*C);
5528 Upper = Upper + 1;
5535 Upper = Lower.lshr(1) + 1;
5538 Upper = C->abs() + 1;
5539 Lower = (-Upper) + 1;
5547 Upper = APInt::getMaxValue(Width).udiv(*C) + 1;
5550 Upper = *C + 1;
5557 Upper = C->abs();
5558 Lower = (-Upper) + 1;
5589 Lower = APInt::getSignedMinValue(Width);
5590 Upper = APInt::getSignedMaxValue(Width) + *C + 1;
5593 Lower = APInt::getSignedMinValue(Width) + *C;
5594 Upper = APInt::getSignedMaxValue(Width) + 1;
5601 Upper = *C + 1;
5604 Upper = APInt::getMaxValue(Width) - *C + 1;
5610 Lower = APInt::getSignedMinValue(Width);
5611 Upper = *C - APInt::getSignedMinValue(Width) + 1;
5614 Lower = *C - APInt::getSignedMaxValue(Width);
5615 Upper = APInt::getSignedMaxValue(Width) + 1;
5620 Lower = APInt::getSignedMinValue(Width) - *C;
5621 Upper = APInt::getSignedMaxValue(Width) + 1;
5624 Lower = APInt::getSignedMinValue(Width);
5625 Upper = APInt::getSignedMaxValue(Width) - *C + 1;
5647 Lower = APInt::getNullValue(BitWidth);
5650 Upper = APInt::getSignedMaxValue(BitWidth) + 1;
5652 Upper = APInt::getSignedMinValue(BitWidth) + 1;
5658 Lower = APInt::getSignedMinValue(BitWidth);
5659 Upper = APInt(BitWidth, 1);
5669 Upper = *C + 1;
5675 Lower = APInt::getSignedMinValue(BitWidth);
5676 Upper = *C + 1;
5680 Upper = APInt::getSignedMaxValue(BitWidth) + 1;
lib/AsmParser/LLLexer.cpp 958 Tmp = Tmp.trunc(activeBits);
lib/Bitcode/Reader/BitcodeReader.cpp 4389 Low = readWideAPInt(makeArrayRef(&Record[CurIdx], ActiveWords),
lib/CodeGen/GlobalISel/GISelKnownBits.cpp 147 Known.Zero = ~Known.One;
178 Known.One = (Known.Zero & Known2.One) | (Known.One & Known2.Zero);
328 Known.Zero = Known.Zero.ashr(Shift);
329 Known.One = Known.One.ashr(Shift);
332 Known.Zero = Known.Zero.lshr(Shift);
333 Known.One = Known.One.lshr(Shift);
337 Known.Zero = Known.Zero.shl(Shift);
338 Known.One = Known.One.shl(Shift);
lib/CodeGen/GlobalISel/Utils.cpp 278 Val = Val.trunc(OpcodeAndSize.second);
281 Val = Val.sext(OpcodeAndSize.second);
284 Val = Val.zext(OpcodeAndSize.second);
lib/CodeGen/InterleavedLoadCombinePass.cpp 191 A = APInt(Ty->getBitWidth(), 0);
485 A = A.lshr(shiftAmt);
496 A = A.trunc(n);
503 A = A.sext(n);
lib/CodeGen/MIRParser/MIParser.cpp 2663 Result = APInt(NumBits, ArrayRef<uint64_t>(A.getRawData(), A.getNumWords()));
lib/CodeGen/SelectionDAG/DAGCombiner.cpp 798 LHS = LHS.zextOrSelf(Bits);
799 RHS = RHS.zextOrSelf(Bits);
5106 Mask = Mask.trunc(N0Op0.getScalarValueSizeInBits());
5163 for (SplatValue = SplatValue.zextOrTrunc(EltBitWidth);
5170 Constant = APInt::getAllOnesValue(EltBitWidth);
5187 Constant = Constant.zextOrTrunc(Load->getMemoryVT().getScalarSizeInBits());
6094 Width = PosC->getAPIntValue() + NegC->getAPIntValue();
6985 Ones = N0Opcode == ISD::SHL ? Ones.shl(ShiftAmt) : Ones.lshr(ShiftAmt);
9211 Mask = Mask.zext(VT.getSizeInBits());
9514 Mask = Mask.sext(VT.getSizeInBits());
9783 Mask = Mask.zext(VT.getSizeInBits());
9838 Mask = Mask.zext(VT.getSizeInBits());
9999 Mask = Mask.zext(VT.getSizeInBits());
10917 SignMask = ~APInt::getSignMask(SourceVT.getScalarSizeInBits());
10921 SignMask = APInt::getSignMask(SourceVT.getScalarSizeInBits());
10925 SignMask = APInt::getSignMask(SourceVT.getScalarSizeInBits());
13181 SignMask = APInt::getSignMask(N0.getScalarValueSizeInBits());
13182 SignMask = APInt::getSplat(IntVT.getSizeInBits(), SignMask);
13185 SignMask = APInt::getSignMask(IntVT.getSizeInBits());
13279 SignMask = ~APInt::getSignMask(N0.getScalarValueSizeInBits());
13280 SignMask = APInt::getSplat(IntVT.getSizeInBits(), SignMask);
13283 SignMask = ~APInt::getSignMask(IntVT.getSizeInBits());
13703 if (X0 < 0) CNV = -CNV;
13704 if (X1 * Y0 * Y1 < 0) CNV = CNV + Offset1;
13705 else CNV = CNV - Offset1;
14281 UsedBits = UsedBits.zext(BitWidth);
14475 NarrowedUsedBits = NarrowedUsedBits.trunc(NarrowedUsedBits.getActiveBits());
19485 Bits = cast<ConstantFPSDNode>(Elt)->getValueAPF().bitcastToAPInt();
19497 Bits = Bits.trunc(NumSubBits);
lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp 443 DestLOI.Known.Zero = ~Val;
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp 1447 State.SignMask = APInt::getSignMask(NumBits);
1483 State.SignMask = APInt::getOneBitSet(LoadTy.getSizeInBits(), 7);
lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp 4005 FF = APInt(32, F32TwoE32);
4007 FF = APInt(32, F32TwoE64);
4009 FF = APInt(32, F32TwoE128);
lib/CodeGen/SelectionDAG/SelectionDAG.cpp 2252 UndefElts = APInt::getNullValue(NumElts);
2300 UndefElts = UndefSrcElts.extractBits(NumElts, Idx);
2314 UndefElts = UndefLHS | UndefRHS;
2441 Known.Zero = ~Known.One;
2446 Known.One = C->getValueAPF().bitcastToAPInt();
2447 Known.Zero = ~Known.One;
2543 DemandedSub = DemandedSub.trunc(NumSubVectorElts);
2600 DemandedSrc = DemandedElts.zextOrSelf(NumSrcElts).shl(Idx);
2713 Known.One = (Known.Zero & Known2.One) | (Known.One & Known2.Zero);
2872 InSignMask = InSignMask.zext(BitWidth);
2964 Known.Zero = ~Value;
2968 Known.Zero = ~Value;
3097 Known.Zero = Known2.Zero & LowBits;
3098 Known.One = Known2.One & LowBits;
3121 Known.Zero = Known2.Zero | ~LowBits;
3122 Known.One = Known2.One & LowBits;
3144 Known.Zero = Known.Zero.getHiBits(Known.getBitWidth() - Index * EltBitWidth);
3145 Known.One = Known.One.getHiBits(Known.getBitWidth() - Index * EltBitWidth);
3184 Known.Zero = Known.One = APInt::getAllOnesValue(BitWidth);
3213 Known.Zero = Known2.Zero.reverseBits();
3214 Known.One = Known2.One.reverseBits();
3219 Known.Zero = Known2.Zero.byteSwap();
3220 Known.One = Known2.One.byteSwap();
3237 Known.Zero = APInt::getSignMask(BitWidth);
3815 DemandedSrcElts =
3830 DemandedSrc = DemandedElts.zextOrSelf(NumSrcElts).shl(Idx);
3843 DemandedSub = DemandedSub.trunc(NumSubVectorElts);
3961 Mask = ~Mask;
9373 SplatValue = APInt(VecWidth, 0);
9374 SplatUndef = APInt(VecWidth, 0);
9416 SplatValue = HighValue | LowValue;
9417 SplatUndef = HighUndef & LowUndef;
lib/CodeGen/SelectionDAG/TargetLowering.cpp 781 Known.Zero = ~Known.One;
796 DemandedBits = APInt::getAllOnesValue(BitWidth);
797 DemandedElts = APInt::getAllOnesValue(NumElts);
888 SubElts = DemandedElts.extractBits(NumSubElts, SubIdx);
922 SrcElts = DemandedElts.zextOrSelf(NumSrcElts).shl(Idx);
1175 KnownOut.Zero = (Known.Zero & Known2.Zero) | (Known.One & Known2.One);
1177 KnownOut.One = (Known.Zero & Known2.One) | (Known.One & Known2.Zero);
1537 Known.One = Known2.One.reverseBits();
1538 Known.Zero = Known2.Zero.reverseBits();
1613 Known.Zero = KnownLo.Zero.zext(BitWidth) |
1616 Known.One = KnownLo.One.zext(BitWidth) |
1769 HighBits = HighBits.trunc(BitWidth);
1809 DemandedSrcElts = APInt::getOneBitSet(NumSrcElts, CIdx->getZExtValue());
1815 DemandedSrcBits = DemandedSrcBits.trunc(EltBitWidth);
2094 KnownUndef = KnownZero = APInt::getNullValue(NumElts);
2305 KnownUndef = SrcUndef.extractBits(NumElts, Idx);
2306 KnownZero = SrcZero.extractBits(NumElts, Idx);
2369 KnownUndef = UndefLHS & UndefRHS;
2370 KnownZero = ZeroLHS & ZeroRHS;
2456 KnownZero = SrcZero.zextOrTrunc(NumElts);
2457 KnownUndef = SrcUndef.zextOrTrunc(NumElts);
2495 KnownZero = ZeroLHS & ZeroRHS;
2496 KnownUndef = getKnownUndefForVectorBinop(Op, TLO.DAG, UndefLHS, UndefRHS);
2514 KnownUndef = UndefLHS & UndefRHS; // TODO: use getKnownUndefForVectorBinop?
2718 CVal = CVal.trunc(BVEltWidth);
3263 bestMask = Mask.lshr(offset * (width/8) * 8);
3492 MinVal = APInt::getSignedMinValue(OperandBitSize);
3493 MaxVal = APInt::getSignedMaxValue(OperandBitSize);
3495 MinVal = APInt::getMinValue(OperandBitSize);
3496 MaxVal = APInt::getMaxValue(OperandBitSize);
3675 NewC = NewC + 1;
4587 while ((t = Divisor * Factor) != 1)
lib/CodeGen/SwitchLoweringUtils.cpp 403 LowBound = APInt::getNullValue(Low.getBitWidth());
408 CmpRange = High - Low;
lib/ExecutionEngine/ExecutionEngine.cpp 431 GVArgc.IntVal = APInt(32, argv.size());
607 Result.IntVal = APInt(C->getType()->getPrimitiveSizeInBits(), 0);
617 Result.AggregateVal[i].IntVal =
635 Result.AggregateVal[i].IntVal =
659 GV.IntVal = GV.IntVal.trunc(BitWidth);
665 GV.IntVal = GV.IntVal.zext(BitWidth);
671 GV.IntVal = GV.IntVal.sext(BitWidth);
697 GV.IntVal = apf.bitcastToAPInt();
712 GV.IntVal = apf.bitcastToAPInt();
721 GV.IntVal = APIntOps::RoundFloatToAPInt(GV.FloatVal, BitWidth);
723 GV.IntVal = APIntOps::RoundDoubleToAPInt(GV.DoubleVal, BitWidth);
739 GV.IntVal = APInt(PtrWidth, uintptr_t(GV.PointerVal));
741 GV.IntVal = GV.IntVal.zextOrTrunc(IntWidth);
747 GV.IntVal = GV.IntVal.zextOrTrunc(PtrWidth);
766 GV.IntVal = APInt::floatToBits(GV.FloatVal);
770 GV.IntVal = APInt::doubleToBits(GV.DoubleVal);
799 case Instruction::Add: GV.IntVal = LHS.IntVal + RHS.IntVal; break;
800 case Instruction::Sub: GV.IntVal = LHS.IntVal - RHS.IntVal; break;
801 case Instruction::Mul: GV.IntVal = LHS.IntVal * RHS.IntVal; break;
802 case Instruction::UDiv:GV.IntVal = LHS.IntVal.udiv(RHS.IntVal); break;
803 case Instruction::SDiv:GV.IntVal = LHS.IntVal.sdiv(RHS.IntVal); break;
804 case Instruction::URem:GV.IntVal = LHS.IntVal.urem(RHS.IntVal); break;
805 case Instruction::SRem:GV.IntVal = LHS.IntVal.srem(RHS.IntVal); break;
806 case Instruction::And: GV.IntVal = LHS.IntVal & RHS.IntVal; break;
807 case Instruction::Or: GV.IntVal = LHS.IntVal | RHS.IntVal; break;
808 case Instruction::Xor: GV.IntVal = LHS.IntVal ^ RHS.IntVal; break;
850 GV.IntVal = apfLHS.bitcastToAPInt();
855 GV.IntVal = apfLHS.bitcastToAPInt();
860 GV.IntVal = apfLHS.bitcastToAPInt();
865 GV.IntVal = apfLHS.bitcastToAPInt();
869 GV.IntVal = apfLHS.bitcastToAPInt();
899 Result.IntVal = cast <ConstantFP>(C)->getValueAPF().bitcastToAPInt();
984 intZero.IntVal = APInt(ElemTy->getScalarSizeInBits(), 0ull);
995 Result.AggregateVal[i].IntVal =
1002 Result.AggregateVal[i].IntVal = APInt(
1079 Result.IntVal = APInt(cast<IntegerType>(Ty)->getBitWidth(), 0);
1096 Result.IntVal = APInt(80, y);
1116 intZero.IntVal = APInt(elemBitWidth, 0);
lib/ExecutionEngine/ExecutionEngineBindings.cpp 44 GenVal->IntVal = APInt(unwrap<IntegerType>(Ty)->getBitWidth(), N, IsSigned);
lib/ExecutionEngine/Interpreter/Execution.cpp 195 IMPLEMENT_INTEGER_ICMP(eq,Ty);
197 IMPLEMENT_POINTER_ICMP(==);
209 IMPLEMENT_INTEGER_ICMP(ne,Ty);
211 IMPLEMENT_POINTER_ICMP(!=);
223 IMPLEMENT_INTEGER_ICMP(ult,Ty);
225 IMPLEMENT_POINTER_ICMP(<);
237 IMPLEMENT_INTEGER_ICMP(slt,Ty);
239 IMPLEMENT_POINTER_ICMP(<);
251 IMPLEMENT_INTEGER_ICMP(ugt,Ty);
253 IMPLEMENT_POINTER_ICMP(>);
265 IMPLEMENT_INTEGER_ICMP(sgt,Ty);
267 IMPLEMENT_POINTER_ICMP(>);
279 IMPLEMENT_INTEGER_ICMP(ule,Ty);
281 IMPLEMENT_POINTER_ICMP(<=);
293 IMPLEMENT_INTEGER_ICMP(sle,Ty);
295 IMPLEMENT_POINTER_ICMP(<=);
307 IMPLEMENT_INTEGER_ICMP(uge,Ty);
309 IMPLEMENT_POINTER_ICMP(>=);
321 IMPLEMENT_INTEGER_ICMP(sge,Ty);
323 IMPLEMENT_POINTER_ICMP(>=);
382 IMPLEMENT_FCMP(==, Float);
383 IMPLEMENT_FCMP(==, Double);
433 IMPLEMENT_SCALAR_NANS(Ty, Src1, Src2)
438 IMPLEMENT_FCMP(!=, Float);
439 IMPLEMENT_FCMP(!=, Double);
449 Dest.AggregateVal[_i].IntVal = APInt(1,false);
458 IMPLEMENT_FCMP(<=, Float);
459 IMPLEMENT_FCMP(<=, Double);
472 IMPLEMENT_FCMP(>=, Float);
473 IMPLEMENT_FCMP(>=, Double);
486 IMPLEMENT_FCMP(<, Float);
487 IMPLEMENT_FCMP(<, Double);
500 IMPLEMENT_FCMP(>, Float);
501 IMPLEMENT_FCMP(>, Double);
534 IMPLEMENT_UNORDERED(Ty, Src1, Src2)
544 IMPLEMENT_UNORDERED(Ty, Src1, Src2)
553 IMPLEMENT_UNORDERED(Ty, Src1, Src2)
562 IMPLEMENT_UNORDERED(Ty, Src1, Src2)
571 IMPLEMENT_UNORDERED(Ty, Src1, Src2)
580 IMPLEMENT_UNORDERED(Ty, Src1, Src2)
594 Dest.AggregateVal[_i].IntVal = APInt(1,
601 Dest.AggregateVal[_i].IntVal = APInt(1,
608 Dest.IntVal = APInt(1,(Src1.FloatVal == Src1.FloatVal &&
611 Dest.IntVal = APInt(1,(Src1.DoubleVal == Src1.DoubleVal &&
625 Dest.AggregateVal[_i].IntVal = APInt(1,
632 Dest.AggregateVal[_i].IntVal = APInt(1,
639 Dest.IntVal = APInt(1,(Src1.FloatVal != Src1.FloatVal ||
642 Dest.IntVal = APInt(1,(Src1.DoubleVal != Src1.DoubleVal ||
655 Dest.AggregateVal[_i].IntVal = APInt(1,val);
657 Dest.IntVal = APInt(1, val);
823 case Instruction::Add: R.IntVal = Src1.IntVal + Src2.IntVal; break;
824 case Instruction::Sub: R.IntVal = Src1.IntVal - Src2.IntVal; break;
825 case Instruction::Mul: R.IntVal = Src1.IntVal * Src2.IntVal; break;
831 case Instruction::UDiv: R.IntVal = Src1.IntVal.udiv(Src2.IntVal); break;
832 case Instruction::SDiv: R.IntVal = Src1.IntVal.sdiv(Src2.IntVal); break;
833 case Instruction::URem: R.IntVal = Src1.IntVal.urem(Src2.IntVal); break;
834 case Instruction::SRem: R.IntVal = Src1.IntVal.srem(Src2.IntVal); break;
835 case Instruction::And: R.IntVal = Src1.IntVal & Src2.IntVal; break;
836 case Instruction::Or: R.IntVal = Src1.IntVal | Src2.IntVal; break;
837 case Instruction::Xor: R.IntVal = Src1.IntVal ^ Src2.IntVal; break;
1203 Result.IntVal = valueToShift.shl(getShiftAmount(shiftAmount, valueToShift));
1210 Dest.IntVal = valueToShift.shl(getShiftAmount(shiftAmount, valueToShift));
1230 Result.IntVal = valueToShift.lshr(getShiftAmount(shiftAmount, valueToShift));
1237 Dest.IntVal = valueToShift.lshr(getShiftAmount(shiftAmount, valueToShift));
1257 Result.IntVal = valueToShift.ashr(getShiftAmount(shiftAmount, valueToShift));
1264 Dest.IntVal = valueToShift.ashr(getShiftAmount(shiftAmount, valueToShift));
1281 Dest.AggregateVal[i].IntVal = Src.AggregateVal[i].IntVal.trunc(DBitWidth);
1285 Dest.IntVal = Src.IntVal.trunc(DBitWidth);
1301 Dest.AggregateVal[i].IntVal = Src.AggregateVal[i].IntVal.sext(DBitWidth);
1305 Dest.IntVal = Src.IntVal.sext(DBitWidth);
1322 Dest.AggregateVal[i].IntVal = Src.AggregateVal[i].IntVal.zext(DBitWidth);
1326 Dest.IntVal = Src.IntVal.zext(DBitWidth);
1392 Dest.AggregateVal[i].IntVal = APIntOps::RoundFloatToAPInt(
1396 Dest.AggregateVal[i].IntVal = APIntOps::RoundDoubleToAPInt(
1405 Dest.IntVal = APIntOps::RoundFloatToAPInt(Src.FloatVal, DBitWidth);
1407 Dest.IntVal = APIntOps::RoundDoubleToAPInt(Src.DoubleVal, DBitWidth);
1430 Dest.AggregateVal[i].IntVal = APIntOps::RoundFloatToAPInt(
1434 Dest.AggregateVal[i].IntVal = APIntOps::RoundDoubleToAPInt(
1443 Dest.IntVal = APIntOps::RoundFloatToAPInt(Src.FloatVal, DBitWidth);
1445 Dest.IntVal = APIntOps::RoundDoubleToAPInt(Src.DoubleVal, DBitWidth);
1523 Dest.IntVal = APInt(DBitWidth, (intptr_t) Src.PointerVal);
1534 Src.IntVal = Src.IntVal.zextOrTrunc(PtrSize);
1591 TempSrc.AggregateVal[i].IntVal =
1596 TempSrc.AggregateVal[i].IntVal =
1614 Elt.IntVal = Elt.IntVal.zext(DstBitSize);
1618 Tmp = Tmp.zext(SrcBitSize);
1620 Tmp = Tmp.zext(DstBitSize);
1634 Elt.IntVal = Elt.IntVal.zext(SrcBitSize);
1639 Elt.IntVal = Elt.IntVal.trunc(DstBitSize);
1679 Dest.IntVal = APInt::floatToBits(Src.FloatVal);
1681 Dest.IntVal = APInt::doubleToBits(Src.DoubleVal);
2073 case Instruction::Add: Dest.IntVal = Op0.IntVal + Op1.IntVal; break;
2074 case Instruction::Sub: Dest.IntVal = Op0.IntVal - Op1.IntVal; break;
2075 case Instruction::Mul: Dest.IntVal = Op0.IntVal * Op1.IntVal; break;
2081 case Instruction::SDiv: Dest.IntVal = Op0.IntVal.sdiv(Op1.IntVal); break;
2082 case Instruction::UDiv: Dest.IntVal = Op0.IntVal.udiv(Op1.IntVal); break;
2083 case Instruction::URem: Dest.IntVal = Op0.IntVal.urem(Op1.IntVal); break;
2084 case Instruction::SRem: Dest.IntVal = Op0.IntVal.srem(Op1.IntVal); break;
2085 case Instruction::And: Dest.IntVal = Op0.IntVal & Op1.IntVal; break;
2086 case Instruction::Or: Dest.IntVal = Op0.IntVal | Op1.IntVal; break;
2087 case Instruction::Xor: Dest.IntVal = Op0.IntVal ^ Op1.IntVal; break;
2089 Dest.IntVal = Op0.IntVal.shl(Op1.IntVal.getZExtValue());
2092 Dest.IntVal = Op0.IntVal.lshr(Op1.IntVal.getZExtValue());
2095 Dest.IntVal = Op0.IntVal.ashr(Op1.IntVal.getZExtValue());
lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp 344 GV.IntVal = APInt(32, strlen(FmtStr));
438 GV.IntVal = APInt(32, sscanf(Args[0], Args[1], Args[2], Args[3], Args[4],
452 GV.IntVal = APInt(32, scanf( Args[0], Args[1], Args[2], Args[3], Args[4],
lib/ExecutionEngine/MCJIT/MCJIT.cpp 535 rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(),
548 rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(),
558 rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue()));
573 rv.IntVal = APInt(BitWidth, ((bool(*)())(intptr_t)FPtr)());
575 rv.IntVal = APInt(BitWidth, ((char(*)())(intptr_t)FPtr)());
577 rv.IntVal = APInt(BitWidth, ((short(*)())(intptr_t)FPtr)());
579 rv.IntVal = APInt(BitWidth, ((int(*)())(intptr_t)FPtr)());
581 rv.IntVal = APInt(BitWidth, ((int64_t(*)())(intptr_t)FPtr)());
587 rv.IntVal = APInt(32, ((int(*)())(intptr_t)FPtr)());
lib/ExecutionEngine/Orc/OrcMCJITReplacement.cpp 54 rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(),
67 rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue(),
76 rv.IntVal = APInt(32, PF(ArgValues[0].IntVal.getZExtValue()));
92 rv.IntVal = APInt(BitWidth, ((bool (*)())(intptr_t)FPtr)());
94 rv.IntVal = APInt(BitWidth, ((char (*)())(intptr_t)FPtr)());
96 rv.IntVal = APInt(BitWidth, ((short (*)())(intptr_t)FPtr)());
98 rv.IntVal = APInt(BitWidth, ((int (*)())(intptr_t)FPtr)());
100 rv.IntVal = APInt(BitWidth, ((int64_t (*)())(intptr_t)FPtr)());
106 rv.IntVal = APInt(32, ((int (*)())(intptr_t)FPtr)());
lib/IR/ConstantFold.cpp 227 V = V.trunc(ByteSize*8);
lib/IR/ConstantRange.cpp 155 RHS = APInt(getBitWidth(), 0);
212 Lower = APIntOps::RoundingSDiv(MaxValue, V, APInt::Rounding::UP);
213 Upper = APIntOps::RoundingSDiv(MinValue, V, APInt::Rounding::DOWN);
215 Lower = APIntOps::RoundingSDiv(MinValue, V, APInt::Rounding::UP);
216 Upper = APIntOps::RoundingSDiv(MaxValue, V, APInt::Rounding::DOWN);
678 LowerExt = Lower.zext(DstTySize);
965 this_min = getSignedMin().sext(getBitWidth() * 2);
966 this_max = getSignedMax().sext(getBitWidth() * 2);
967 Other_min = Other.getSignedMin().sext(getBitWidth() * 2);
968 Other_max = Other.getSignedMax().sext(getBitWidth() * 2);
1081 AdjNegRUpper = NegR.Upper - 1;
1096 AdjNegLLower = NegL.Lower + 1;
1344 Lo = APInt::getNullValue(getBitWidth());
lib/MC/MCParser/AsmParser.cpp 3150 Res = Value.bitcastToAPInt();
lib/ProfileData/ProfileSummaryBuilder.cpp 78 Temp = Temp.sdiv(D);
lib/Support/APFloat.cpp 2254 api = -api;
2299 api = -api;
3381 significand = significand.udiv(divisor);
3384 significand = significand.trunc(significand.getActiveBits());
3498 significand = significand.zext(semantics->precision + exp);
3517 significand = significand.zext(precision);
lib/Support/APInt.cpp 257 *this = *this * RHS;
1039 rot = rotateAmt.zext(BitWidth);
1041 rot = rot.urem(APInt(rot.getBitWidth(), BitWidth));
1116 for (;; i += 2, testy = testy.shl(2))
1118 x_old = x_old.shl(i / 2);
1124 x_new = (this->udiv(x_old) + x_old).udiv(two);
1208 ad = d.abs();
1209 t = signedMin + (d.lshr(d.getBitWidth() - 1));
1210 anc = t - 1 - t.urem(ad); // absolute value of nc
1212 q1 = signedMin.udiv(anc); // initialize q1 = 2p/abs(nc)
1213 r1 = signedMin - q1*anc; // initialize r1 = rem(2p,abs(nc))
1214 q2 = signedMin.udiv(ad); // initialize q2 = 2p/abs(d)
1215 r2 = signedMin - q2*ad; // initialize r2 = rem(2p,abs(d))
1218 q1 = q1<<1; // update q1 = 2p/abs(nc)
1219 r1 = r1<<1; // update r1 = rem(2p/abs(nc))
1221 q1 = q1 + 1;
1222 r1 = r1 - anc;
1224 q2 = q2<<1; // update q2 = 2p/abs(d)
1225 r2 = r2<<1; // update r2 = rem(2p/abs(d))
1227 q2 = q2 + 1;
1228 r2 = r2 - ad;
1230 delta = ad - r2;
1233 mag.m = q2 + 1;
1234 if (d.isNegative()) mag.m = -mag.m; // resulting magic number
1255 nc = allOnes - (allOnes - d).urem(d);
1257 q1 = signedMin.udiv(nc); // initialize q1 = 2p/nc
1258 r1 = signedMin - q1*nc; // initialize r1 = rem(2p,nc)
1259 q2 = signedMax.udiv(d); // initialize q2 = (2p-1)/d
1260 r2 = signedMax - q2*d; // initialize r2 = rem((2p-1),d)
1264 q1 = q1 + q1 + 1; // update q1
1265 r1 = r1 + r1 - nc; // update r1
1268 q1 = q1+q1; // update q1
1269 r1 = r1+r1; // update r1
1273 q2 = q2+q2 + 1; // update q2
1274 r2 = r2+r2 + 1 - d; // update r2
1278 q2 = q2+q2; // update q2
1279 r2 = r2+r2 + 1; // update r2
1281 delta = d - 1 - r2;
1284 magu.m = q2 + 1; // resulting magic number
1771 Quotient = APInt(BitWidth, QuotVal);
1772 Remainder = APInt(BitWidth, RemVal);
1784 Quotient = APInt(BitWidth, 0); // 0 / Y ===> 0
1785 Remainder = APInt(BitWidth, 0); // 0 % Y ===> 0
1791 Remainder = APInt(BitWidth, 0); // X % 1 ===> 0
1796 Quotient = APInt(BitWidth, 0); // X / Y ===> 0, iff X < Y
1801 Quotient = APInt(BitWidth, 1); // X / X ===> 1
1802 Remainder = APInt(BitWidth, 0); // X % X ===> 0;
1841 Quotient = APInt(BitWidth, QuotVal);
1850 Quotient = APInt(BitWidth, 0); // 0 / Y ===> 0
1863 Quotient = APInt(BitWidth, 0); // X / Y ===> 0, iff X < Y
1868 Quotient = APInt(BitWidth, 1); // X / X ===> 1
2873 A = A.sext(CoeffWidth);
2874 B = B.sext(CoeffWidth);
2875 C = C.sext(CoeffWidth);
2927 C = C.srem(R);
2939 LowkR = RoundUp(LowkR, R);
lib/Support/APSInt.cpp 29 Tmp = Tmp.trunc(MinBits);
35 Tmp = Tmp.trunc(ActiveBits);
lib/Support/KnownBits.cpp 42 KnownOut.Zero = ~std::move(PossibleSumZero) & Known;
43 KnownOut.One = std::move(PossibleSumOne) & Known;
lib/Support/StringRef.cpp 527 Result = APInt(64, 0);
540 Result = Result.zext(BitWidth);
545 RadixAP = APInt(BitWidth, Radix);
546 CharAP = APInt(BitWidth, 0);
lib/Target/AArch64/AArch64ISelDAGToDAG.cpp 1999 Mask = ResultUsefulBits & OpUsefulBits;
2017 Mask = ResultUsefulBits & OpUsefulBits;
2083 UsefulBits = APInt(Bitwidth, 0);
lib/Target/AArch64/AArch64ISelLowering.cpp 1071 Known.Zero = APInt::getHighBitsSet(64, 32);
7516 DefBits = ~DefBits;
7531 DefBits = ~UndefBits;
9855 DefBits = ~DefBits;
9862 UndefBits = ~UndefBits;
lib/Target/AArch64/AArch64TargetTransformInfo.cpp 69 ImmVal = Imm.sext((BitSize + 63) & ~0x3fU);
lib/Target/AMDGPU/AMDGPUISelLowering.cpp 4406 Known.Zero = APInt::getHighBitsSet(32, 31);
4419 Known.Zero = APInt::getHighBitsSet(32, 32 - Width);
4428 Known.Zero = APInt::getHighBitsSet(BitWidth, BitWidth - 16);
lib/Target/AMDGPU/SIFoldOperands.cpp 854 Imm = Imm.getLoBits(32);
857 Imm = Imm.getHiBits(32);
lib/Target/ARM/ARMISelLowering.cpp12444 ToMask = ~cast<ConstantSDNode>(N->getOperand(2))->getAPIntValue();
12445 FromMask = APInt::getLowBitsSet(ToMask.getBitWidth(), ToMask.countPopulation());
lib/Target/Hexagon/HexagonConstPropagation.cpp 1424 Result = A1 & A2;
1491 Result = A1 | A2;
1553 Result = A1 ^ A2;
1584 Result = A1.zextOrTrunc(Width) & Mask;
1617 Result = APInt(Width, 0);
1642 Result = APInt(Width, V, true);
1647 Result = A1.trunc(Bits).sext(Width);
1649 Result = A1.sext(Width);
1684 Result = APInt(BW, static_cast<uint64_t>(Count), false);
1719 Result = APInt(BW, static_cast<uint64_t>(Count), false);
1761 Result = APInt(BW, 0);
1771 Result = APInt(BW, V, Signed);
1775 Result = A1.shl(BW-Bits-Offset).ashr(BW-Bits);
1777 Result = A1.shl(BW-Bits-Offset).lshr(BW-Bits);
1809 LoBits = LoBits.zext(SW);
lib/Target/PowerPC/PPCInstrInfo.cpp 2890 InVal = InVal.rotl(SH);
2914 InVal = InVal.rotl(SH);
lib/Target/SystemZ/SystemZISelDAGToDAG.cpp 1380 OperandV = -OperandV;
lib/Target/SystemZ/SystemZISelLowering.cpp 744 IntBits = FPImm.bitcastToAPInt().zextOrSelf(128);
748 SplatBits = FPImm.bitcastToAPInt();
6210 SrcDemE = SrcDemE.trunc(NumElts / 2);
6219 SrcDemE = APInt(NumElts * 2, 0);
6228 SrcDemE = APInt(NumElts * 2, 0);
6233 SrcDemE = APInt(NumElts, 0);
6248 SrcDemE = APInt(NumElts, 0);
6259 SrcDemE = APInt(NumElts, 1);
6269 SrcDemE = APInt(1, 1);
6292 Known.Zero = LHSKnown.Zero & RHSKnown.Zero;
6293 Known.One = LHSKnown.One & RHSKnown.One;
lib/Target/X86/X86ISelDAGToDAG.cpp 3912 MaskVal = MaskVal.trunc(32);
3927 NegMaskVal = NegMaskVal.zext(64);
3928 HighZeros = HighZeros.zext(64);
lib/Target/X86/X86ISelLowering.cpp 5999 UndefElts = APInt(NumElts, 0);
6019 EltBits[i] = MaskBits.extractBits(EltSizeInBits, BitOffset);
6038 Mask = CFP->getValueAPF().bitcastToAPInt();
6078 SrcEltBits[i] = Cst->getAPIntValue().zextOrTrunc(SrcEltSizeInBits);
6096 SrcEltBits[i] = RawBits.zextOrTrunc(SrcEltSizeInBits);
6176 UndefElts = APInt::getSplat(NumElts, UndefElts);
6235 UndefElts = UndefElts.extractBits(NumSubElts, BaseIdx);
6268 UndefElts = APInt::getNullValue(NumElts);
6363 DemandedLHS = APInt::getNullValue(NumInnerElts);
6364 DemandedRHS = APInt::getNullValue(NumInnerElts);
6387 DemandedLHS = APInt::getNullValue(NumElts);
6388 DemandedRHS = APInt::getNullValue(NumElts);
6739 KnownUndef = KnownZero = APInt::getNullValue(Size);
6831 KnownUndef = KnownZero = APInt::getNullValue(NumElts);
10474 Val = Val.getLoBits(ScalarSizeInBits);
10480 Val = Val.getLoBits(ScalarSizeInBits);
31551 Known.One = APInt::getAllOnesValue(BitWidth * 2);
31552 Known.Zero = APInt::getAllOnesValue(BitWidth * 2);
34276 KnownZero = LHSZero | RHSZero;
34465 KnownZero = SrcZero.zextOrTrunc(NumElts);
34466 KnownUndef = SrcUndef.zextOrTrunc(NumElts);
34486 KnownZero = LHSZero & RHSZero;
34487 KnownUndef = LHSUndef & RHSUndef;
34922 Known.One = KnownVec.One & KnownScl.One;
34923 Known.Zero = KnownVec.Zero & KnownScl.Zero;
34971 Known.Zero = KnownZero.zextOrSelf(BitWidth);
37290 Addend = -Addend;
38351 SarConst = SarConst - (Size - ShiftSize);
38463 Val = Val.trunc(DstBitsPerElt);
38465 Val = APInt::getSignedMinValue(DstBitsPerElt);
38467 Val = APInt::getSignedMaxValue(DstBitsPerElt);
38473 Val = Val.trunc(DstBitsPerElt);
38475 Val = APInt::getNullValue(DstBitsPerElt);
38477 Val = APInt::getAllOnesValue(DstBitsPerElt);
39943 SignedMax = APInt::getAllOnesValue(NumDstBits).zext(NumSrcBits);
39944 SignedMin = APInt(NumSrcBits, 0);
39946 SignedMax = APInt::getSignedMaxValue(NumDstBits).sext(NumSrcBits);
39947 SignedMin = APInt::getSignedMinValue(NumDstBits).sext(NumSrcBits);
lib/Target/X86/X86ShuffleDecodeConstantPool.cpp 53 UndefElts = APInt(NumMaskElts, 0);
lib/Target/X86/X86TargetTransformInfo.cpp 2946 ImmVal = Imm.sext(alignTo(BitSize, 64));
lib/Target/XCore/XCoreISelLowering.cpp 1827 Known.Zero = APInt::getHighBitsSet(Known.getBitWidth(),
1837 Known.Zero = APInt::getHighBitsSet(Known.getBitWidth(),
1843 Known.Zero = APInt::getHighBitsSet(Known.getBitWidth(),
1848 Known.Zero = APInt::getHighBitsSet(Known.getBitWidth(),
1853 Known.Zero = APInt::getHighBitsSet(Known.getBitWidth(),
lib/Transforms/InstCombine/InstCombineAddSub.cpp 958 C = APInt(AI->getBitWidth(), 1);
982 C = *AI + 1;
1003 C = APInt(AI->getBitWidth(), 1);
lib/Transforms/InstCombine/InstCombineAndOrXor.cpp 995 UnsetBitsMask = UnsetBitsMask.zext(X1->getType()->getScalarSizeInBits());
lib/Transforms/InstCombine/InstCombineCalls.cpp 401 Count = APInt(64, BitWidth - 1);
577 MinValue =
579 MaxValue =
585 MinValue = APInt::getNullValue(SrcScalarSizeInBits);
586 MaxValue = APInt::getLowBitsSet(SrcScalarSizeInBits, DstScalarSizeInBits);
798 Elt = Elt.zextOrTrunc(Length);
825 APIndex = APIndex.zextOrTrunc(6);
826 APLength = APLength.zextOrTrunc(6);
889 V00 = V00 & ~Mask;
890 V10 = V10.zextOrTrunc(Length).zextOrTrunc(64).shl(Index);
990 Index = Index.zextOrTrunc(32).getLoBits(2);
2132 NewVal = Val->uadd_sat(*Val2);
2135 NewVal = Val->sadd_ov(*Val2, Overflow);
lib/Transforms/InstCombine/InstCombineCompares.cpp 43 Result = In1.sadd_ov(In2, Overflow);
45 Result = In1.uadd_ov(In2, Overflow);
56 Result = In1.ssub_ov(In2, Overflow);
58 Result = In1.usub_ov(In2, Overflow);
112 Max = Known.One|UnknownBits;
134 Max = Known.One|UnknownBits;
2396 LoBound = -(RangeSize - 1);
2405 HiBound = Prod + 1;
2417 LoBound = RangeSize + 1;
2418 HiBound = -RangeSize;
2421 HiBound = APInt(); // e.g. X/INTMIN = 0 --> X > INTMIN
2425 HiBound = Prod + 1;
4631 MaxVal = MaxVal.zext(CI->getBitWidth());
4654 MaxVal = MaxVal.zext(CI->getBitWidth());
lib/Transforms/InstCombine/InstCombineMulDivRem.cpp 650 Product = IsSigned ? C1.smul_ov(C2, Overflow) : C1.umul_ov(C2, Overflow);
lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp 195 Known.Zero = std::move(IKnownZero);
196 Known.One = std::move(IKnownOne);
229 Known.Zero = std::move(IKnownZero);
230 Known.One = std::move(IKnownOne);
311 Known.Zero = std::move(IKnownZero);
313 Known.One = std::move(IKnownOne);
356 Known.One = RHSKnown.One & LHSKnown.One;
357 Known.Zero = RHSKnown.Zero & LHSKnown.Zero;
617 Known.Zero = LHSKnown.Zero & LowBits;
618 Known.One = LHSKnown.One & LowBits;
652 Known.Zero = APInt::getHighBitsSet(BitWidth, Leaders) & DemandedMask;
709 Known.Zero = LHSKnown.Zero.shl(ShiftAmt) |
711 Known.One = LHSKnown.One.shl(ShiftAmt) |
802 Known.Zero = std::move(IKnownZero);
803 Known.One = std::move(IKnownOne);
833 Known.Zero = std::move(IKnownZero);
834 Known.One = std::move(IKnownOne);
865 Known.Zero = std::move(IKnownZero);
867 Known.One = std::move(IKnownOne);
928 BitMask1 = isLshr ? (BitMask1.lshr(ShrAmt) << ShlAmt) :
934 BitMask2 = isLshr ? BitMask2.lshr(ShrAmt - ShlAmt):
1392 UndefElts = UndefElts2 & UndefElts3;
1401 UndefElts2 = APInt(InVWidth, 0);
1485 UndefElts = UndefElts2 & UndefElts3;
1651 OpUndefElts = OpUndefElts.zext(VWidth);
1654 LaneElts = LaneElts.getLoBits(InnerVWidthPerLane);
lib/Transforms/InstCombine/InstCombineVectorOps.cpp 269 UsedElts = APInt::getOneBitSet(VWidth, EEIIndexC->getZExtValue());
277 UsedElts = APInt(VWidth, 0);
308 UnionUsedElts = APInt::getAllOnesValue(VWidth);
lib/Transforms/InstCombine/InstructionCombining.cpp 1331 Scale = Scale.sext(LargeSize);
lib/Transforms/Scalar/DeadStoreElimination.cpp 1236 LaterValue = LaterValue.zext(EarlierValue.getBitWidth());
lib/Transforms/Scalar/LowerExpectIntrinsic.cpp 152 Result = Result.zext(Op->getType()->getIntegerBitWidth());
155 Result = Result.sext(Op->getType()->getIntegerBitWidth());
lib/Transforms/Scalar/MergeICmps.cpp 95 Offset = std::move(that.Offset);
lib/Transforms/Scalar/Reassociate.cpp 141 ConstPart = APInt::getNullValue(V->getType()->getScalarSizeInBits());
lib/Transforms/Scalar/SROA.cpp 1225 MaxSize = MaxSize.ult(Size) ? APInt(APWidth, Size) : MaxSize;
lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp 561 ConstantOffset = find(BO->getOperand(1), SignExtended, ZeroExtended,
566 ConstantOffset = -ConstantOffset;
588 ConstantOffset = findInEitherOperand(BO, SignExtended, ZeroExtended);
590 ConstantOffset =
594 ConstantOffset = find(U->getOperand(0), /* SignExtended */ true,
601 ConstantOffset =
lib/Transforms/Scalar/StraightLineStrengthReduce.cpp 565 A = A.sext(B.getBitWidth());
567 B = B.sext(A.getBitWidth());
lib/Transforms/Vectorize/LoadStoreVectorizer.cpp 358 OffsetA = OffsetA.sextOrTrunc(NewPtrBitWidth);
359 OffsetB = OffsetB.sextOrTrunc(NewPtrBitWidth);
360 PtrDelta = PtrDelta.sextOrTrunc(NewPtrBitWidth);
tools/clang/lib/AST/ASTContext.cpp 3183 ArySize = ArySize.zextOrTrunc(Target->getMaxPointerWidth());
tools/clang/lib/AST/ExprConstant.cpp 2420 Res = SVal.getFloat().bitcastToAPInt();
2429 Res = llvm::APInt::getNullValue(VecSize);
2436 EltAsInt = Elt.getFloat().bitcastToAPInt();
7727 Result = std::move(SizeOfElem);
7741 Result = std::move(BytesAvailable);
9305 Elt = SValInt.rotl(i*EltSize+FloatEltSize).trunc(FloatEltSize);
9307 Elt = SValInt.rotr(i*EltSize).trunc(FloatEltSize);
9314 Elt = SValInt.rotl(i*EltSize+EltSize).zextOrTrunc(EltSize);
9316 Elt = SValInt.rotr(i*EltSize).zextOrTrunc(EltSize);
12422 fill = llvm::APInt(32, 0);
tools/clang/lib/Basic/FixedPoint.cpp 199 FractPart = (FractPart * RadixInt) & FractPartMask;
tools/clang/lib/CodeGen/CGExpr.cpp 1554 Min = llvm::APInt(CGF.getContext().getTypeSize(Ty), 0);
1555 End = llvm::APInt(CGF.getContext().getTypeSize(Ty), 2);
1566 End = llvm::APInt(Bitwidth, 1) << (NumBits - 1);
1567 Min = -End;
1570 End = llvm::APInt(Bitwidth, 1) << NumPositiveBits;
1571 Min = llvm::APInt(Bitwidth, 0);
tools/clang/lib/CodeGen/CGExprCXX.cpp 775 allocationSize = allocationSize.uadd_ov(cookieSize, overflow);
tools/clang/lib/CodeGen/CGExprConstant.cpp 201 BitsThisChar = BitsThisChar.zext(CharWidth);
209 BitsThisChar = BitsThisChar.shl(-Shift);
211 BitsThisChar = BitsThisChar.shl(OffsetWithinChar);
214 BitsThisChar = BitsThisChar.trunc(CharWidth);
273 Bits = Bits.trunc(Bits.getBitWidth() - WantedBits);
599 FieldValue = FieldValue.zext(FieldSize);
603 FieldValue = FieldValue.trunc(FieldSize);
tools/clang/lib/CodeGen/CGExprScalar.cpp 64 Result = LHSAP.sadd_ov(RHSAP, Overflow);
66 Result = LHSAP.uadd_ov(RHSAP, Overflow);
69 Result = LHSAP.ssub_ov(RHSAP, Overflow);
71 Result = LHSAP.usub_ov(RHSAP, Overflow);
74 Result = LHSAP.smul_ov(RHSAP, Overflow);
76 Result = LHSAP.umul_ov(RHSAP, Overflow);
79 Result = LHSAP.sdiv_ov(RHSAP, Overflow);
tools/clang/lib/CodeGen/PatternInit.cpp 61 Payload = llvm::APInt::getSplat(BitWidth, Payload);
tools/clang/lib/Lex/LiteralSupport.cpp 1159 Val = Val.udiv(Base);
1166 StoreVal = Val.trunc(StoreVal.getBitWidth());
1169 StoreVal = Val.zext(StoreVal.getBitWidth());
1376 LitVal = LitVal + (codepoint_buffer[i] & 0xFF);
tools/clang/lib/Sema/SemaChecking.cpp13302 size = size.zext(index.getBitWidth());
tools/clang/lib/Sema/SemaDecl.cpp17331 FlagBits = FlagBits.zextOrSelf(EVal.getBitWidth()) | EVal;
tools/clang/lib/Sema/SemaExpr.cpp 3713 ResultVal = ResultVal.trunc(Width);
11223 RightSideValue = -RightSideValue;
tools/clang/lib/StaticAnalyzer/Core/LoopUnrolling.cpp 218 InitNum = InitNum.zextOrSelf(BoundNum.getBitWidth());
219 BoundNum = BoundNum.zextOrSelf(InitNum.getBitWidth());
tools/clang/utils/TableGen/MveEmitter.cpp 786 typelo = llvm::APInt::getSignedMinValue(IA.ArgType->sizeInBits());
787 typehi = llvm::APInt::getSignedMaxValue(IA.ArgType->sizeInBits());
789 typelo = llvm::APInt::getMinValue(IA.ArgType->sizeInBits());
790 typehi = llvm::APInt::getMaxValue(IA.ArgType->sizeInBits());
792 typelo = typelo.sext(128);
793 typehi = typehi.sext(128);
tools/lldb/include/lldb/Utility/Scalar.h 64 m_integer = llvm::APInt(sizeof(int) * 8, v, true);
67 m_integer = llvm::APInt(sizeof(int) * 8, v);
70 m_integer = llvm::APInt(sizeof(long) * 8, v, true);
73 m_integer = llvm::APInt(sizeof(long) * 8, v);
76 m_integer = llvm::APInt(sizeof(long long) * 8, v, true);
80 m_integer = llvm::APInt(sizeof(long long) * 8, v);
101 m_integer = llvm::APInt(v);
tools/lldb/source/Expression/IRInterpreter.cpp 240 value = APInt(m_target_data.getPointerSizeInBits(), addr);
252 value = constant_fp->getValueAPF().bitcastToAPInt();
300 value = APInt(m_target_data.getPointerSizeInBits(), 0);
tools/lldb/source/Plugins/Instruction/MIPS/EmulateInstructionMIPS.cpp 2962 wr_val = reg_value.GetAsUInt128(fail_value);
tools/lldb/source/Plugins/Instruction/MIPS64/EmulateInstructionMIPS64.cpp 2273 wr_val = reg_value.GetAsUInt128(fail_value);
tools/lldb/source/Utility/Scalar.cpp 311 m_integer = llvm::APInt(rhs.m_integer);
319 m_integer = llvm::APInt(sizeof(int) * 8, v, true);
325 m_integer = llvm::APInt(sizeof(int) * 8, v);
331 m_integer = llvm::APInt(sizeof(long) * 8, v, true);
337 m_integer = llvm::APInt(sizeof(long) * 8, v);
343 m_integer = llvm::APInt(sizeof(long) * 8, v, true);
349 m_integer = llvm::APInt(sizeof(long long) * 8, v);
379 m_integer = llvm::APInt(rhs);
447 m_integer = m_integer.sextOrTrunc(bits);
455 m_integer = m_integer.zextOrTrunc(bits);
478 m_integer = m_integer.sextOrTrunc(sizeof(uint_t) * 8);
483 m_integer = m_integer.sextOrTrunc(sizeof(slong_t) * 8);
488 m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
493 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
498 m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
504 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
510 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
516 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
553 m_integer = m_integer.zextOrTrunc(sizeof(slong_t) * 8);
558 m_integer = m_integer.zextOrTrunc(sizeof(ulong_t) * 8);
563 m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
568 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
574 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
580 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
586 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
624 m_integer = m_integer.sextOrTrunc(sizeof(ulong_t) * 8);
629 m_integer = m_integer.sextOrTrunc(sizeof(slonglong_t) * 8);
634 m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
640 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
646 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
652 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
691 m_integer = m_integer.zextOrTrunc(sizeof(slonglong_t) * 8);
696 m_integer = m_integer.zextOrTrunc(sizeof(ulonglong_t) * 8);
702 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
708 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
714 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
754 m_integer = m_integer.sextOrTrunc(sizeof(ulonglong_t) * 8);
760 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
766 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
772 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
814 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT128);
820 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
826 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
868 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT128);
874 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
880 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT512);
924 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT256);
930 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
974 m_integer = m_integer.sextOrTrunc(BITWIDTH_INT256);
980 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
1027 m_integer = m_integer.zextOrTrunc(BITWIDTH_INT512);
1811 m_integer = a->m_integer + b->m_integer;
1864 m_integer = m_integer << rhs.m_integer;
1912 m_integer = m_integer.lshr(rhs.m_integer);
1960 m_integer = m_integer.ashr(rhs.m_integer);
2028 m_integer = -m_integer;
2063 m_integer = -m_integer;
2088 m_integer = ~m_integer;
2122 result.m_integer = a->m_integer + b->m_integer;
2156 result.m_integer = a->m_integer - b->m_integer;
2185 result.m_integer = a->m_integer.sdiv(b->m_integer);
2196 result.m_integer = a->m_integer.udiv(b->m_integer);
2238 result.m_integer = a->m_integer * b->m_integer;
2270 result.m_integer = a->m_integer & b->m_integer;
2304 result.m_integer = a->m_integer | b->m_integer;
2338 result.m_integer = a->m_integer.srem(b->m_integer);
2349 result.m_integer = a->m_integer.urem(b->m_integer);
2379 result.m_integer = a->m_integer ^ b->m_integer;
2433 m_integer = llvm::APInt(sizeof(uint_t) * 8, uval64, false);
2436 m_integer = llvm::APInt(sizeof(ulong_t) * 8, uval64, false);
2439 m_integer = llvm::APInt(sizeof(ulonglong_t) * 8, uval64, false);
2471 m_integer = llvm::APInt(sizeof(sint_t) * 8, sval64, true);
2474 m_integer = llvm::APInt(sizeof(slong_t) * 8, sval64, true);
2477 m_integer = llvm::APInt(sizeof(slonglong_t) * 8, sval64, true);
2747 m_integer = m_integer.ashr(bit_offset)
2758 m_integer = m_integer.lshr(bit_offset)
tools/lli/lli.cpp 626 ResultGV.IntVal = APInt(32, Result);
tools/llvm-exegesis/lib/BenchmarkResult.cpp 271 RV.Value = APInt(BitsNeeded, Pieces[1], kRadix);
tools/llvm-exegesis/lib/SnippetFile.cpp 66 RegVal.Value = APInt(
tools/polly/lib/CodeGen/IslExprBuilder.cpp 755 APValue = APIntFromVal(Val);
763 APValue = APValue.sextOrSelf(T->getBitWidth());
tools/polly/lib/Support/GICHelper.cpp 36 Abs = Int.sext(Int.getBitWidth() + 1).abs();
70 A = A.zext(A.getBitWidth() + 1);
71 A = -A;
78 A = A.trunc(A.getMinSignedBits());
tools/polly/unittests/Isl/IslTest.cpp 153 APLarge = APLarge.shl(70);
unittests/ADT/APIntTest.cpp 923 q = p.sdiv(a);
924 r = p.srem(a);
932 q = p.udiv(b);
933 r = p.urem(b);
939 q = p.sdiv(b);
940 r = p.srem(b);
1012 q = p.udiv(b);
1020 q = p.sdiv(b);
1445 ValC = ValA * ValB;
2388 i72 = APInt::getHighBitsSet(72, 1);
unittests/ADT/APSIntTest.cpp 36 Wide = APInt(128, 1);
unittests/Support/KnownBitsTest.cpp 96 Res = N1.sadd_ov(N2, Overflow);
98 Res = N1.ssub_ov(N2, Overflow);
usr/include/c++/7.4.0/bits/move.h 199 __a = _GLIBCXX_MOVE(__b);
200 __b = _GLIBCXX_MOVE(__tmp);
usr/include/c++/7.4.0/bits/stl_algobase.h 343 *__result = std::move(*__first);
usr/include/c++/7.4.0/bits/stl_pair.h 396 first = std::forward<first_type>(__p.first);
397 second = std::forward<second_type>(__p.second);
usr/include/c++/7.4.0/tuple 1253 this->_M_tail(*this)._M_head(*this) = std::forward<_U2>(__in.second);
utils/TableGen/CodeGenSchedule.cpp 276 OperandMask = OperandMask.zext(MaxIndex + 1);