|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Declarations
include/llvm/Analysis/MemoryBuiltins.h 34 class ConstantInt;
include/llvm/Analysis/ScalarEvolution.h 58 class ConstantInt;
include/llvm/CodeGen/MachineOperand.h 28 class ConstantInt;
include/llvm/CodeGen/SelectionDAG.h 63 class ConstantInt;
include/llvm/IR/Instructions.h 50 class ConstantInt;
include/llvm/Transforms/Scalar/ConstantHoisting.h 54 class ConstantInt;
include/llvm/Transforms/Utils/LowerMemIntrinsics.h 19 class ConstantInt;
lib/CodeGen/AsmPrinter/DwarfUnit.h 32 class ConstantInt;
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h 58 class ConstantInt;
lib/IR/LLVMContextImpl.h 57 class ConstantInt;
lib/Target/Hexagon/BitTracker.h 27 class ConstantInt;
tools/clang/lib/CodeGen/CGCleanup.h 25 class ConstantInt;
tools/clang/lib/CodeGen/CodeGenModule.h 42 class ConstantInt;
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h 30 class ConstantInt;
References
examples/BrainF/BrainF.cpp 91 ConstantInt *val_mem = ConstantInt::get(C, APInt(32, memtotal));
91 ConstantInt *val_mem = ConstantInt::get(C, APInt(32, memtotal));
105 ConstantInt::get(C, APInt(8, 0)),
107 ConstantInt::get(C, APInt(32, 1)),
108 ConstantInt::get(C, APInt(1, 0))
119 CreateGEP(ptr_arr, ConstantInt::get(C, APInt(32, memtotal)), "arrmax");
124 ConstantInt::get(C, APInt(32, memtotal/2)),
248 CreateGEP(curhead, ConstantInt::get(C, APInt(32, curvalue)),
283 CreateAdd(tape_0, ConstantInt::get(C, APInt(8, curvalue)), tapereg);
447 ConstantInt::get(C, APInt(8, 0)), testreg);
examples/BrainF/BrainFDriver.cpp 103 ConstantInt::get(mod->getContext(), APInt(32, 0)), bb);
examples/Fibonacci/fibonacci.cpp 63 Value *One = ConstantInt::get(Type::getInt32Ty(Context), 1);
64 Value *Two = ConstantInt::get(Type::getInt32Ty(Context), 2);
examples/ModuleMaker/ModuleMaker.cpp 50 Value *Two = ConstantInt::get(Type::getInt32Ty(Context), 2);
51 Value *Three = ConstantInt::get(Type::getInt32Ty(Context), 3);
examples/ParallelJIT/ParallelJIT.cpp 63 Value *One = ConstantInt::get(Type::getInt32Ty(Context), 1);
93 Value *One = ConstantInt::get(Type::getInt32Ty(Context), 1);
94 Value *Two = ConstantInt::get(Type::getInt32Ty(Context), 2);
gen/tools/clang/include/clang/Basic/arm_mve_builtin_cg.inc 171 Value *Val4 = llvm::ConstantInt::get(Int32Ty, 29);
174 Value *Val7 = llvm::ConstantInt::get(Int32Ty, 1);
176 Value *Val9 = llvm::ConstantInt::get(Int32Ty, 29);
218 Value *Val5 = llvm::ConstantInt::get(Int32Ty, 29);
224 Value *Val11 = llvm::ConstantInt::get(Int32Ty, 1);
226 Value *Val13 = llvm::ConstantInt::get(Int32Ty, 29);
237 Value *Val3 = llvm::ConstantInt::get(Int32Ty, 0);
242 Value *Val8 = llvm::ConstantInt::get(Int32Ty, 1);
244 Value *Val10 = llvm::ConstantInt::get(Int32Ty, 29);
255 Value *Val2 = llvm::ConstantInt::get(Int32Ty, 0);
257 Value *Val4 = llvm::ConstantInt::get(Int32Ty, 1);
259 Value *Val6 = llvm::ConstantInt::get(Int32Ty, 29);
279 Value *Val2 = llvm::ConstantInt::get(Int32Ty, Param0);
298 Value *Val2 = llvm::ConstantInt::get(Int32Ty, Param0);
335 Value *Val1 = llvm::ConstantInt::get(Int64Ty, 32);
343 Value *Val9 = llvm::ConstantInt::get(Int64Ty, 32);
include/llvm/ADT/ArrayRef.h 108 const ArrayRef<U *> &A,
110 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
118 const SmallVectorTemplateCommon<U *, DummyT> &Vec,
120 std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
include/llvm/ADT/DenseMapInfo.h 39 static inline T* getEmptyKey() {
41 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
45 static inline T* getTombstoneKey() {
47 Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
51 static unsigned getHashValue(const T *PtrVal) {
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
56 static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/ADT/STLExtras.h 1014 std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;
include/llvm/Analysis/CFGPrinter.h 167 ConstantInt *Weight =
168 mdconst::dyn_extract<ConstantInt>(WeightsNode->getOperand(OpNo));
include/llvm/Analysis/IVDescriptors.h 284 ConstantInt *getConstIntStepValue() const;
include/llvm/Analysis/LoopUnrollAnalyzer.h 44 ConstantInt *Offset = nullptr;
include/llvm/Analysis/ScalarEvolution.h 510 const SCEV *getConstant(ConstantInt *V);
1137 using ValueOffsetPair = std::pair<Value *, ConstantInt *>;
include/llvm/Analysis/ScalarEvolutionExpressions.h 50 ConstantInt *V;
52 SCEVConstant(const FoldingSetNodeIDRef ID, ConstantInt *v) :
56 ConstantInt *getValue() const { return V; }
805 if (InterpretConsts && isa<ConstantInt>(NV))
806 return SE.getConstant(cast<ConstantInt>(NV));
include/llvm/Analysis/SparsePropagation.h 321 if (!C || !isa<ConstantInt>(C)) {
359 if (!C || !isa<ConstantInt>(C)) {
364 SwitchInst::CaseHandle Case = *SI.findCaseValue(cast<ConstantInt>(C));
include/llvm/Analysis/TargetTransformInfoImpl.h 623 if (auto* IntElement =
624 dyn_cast<ConstantInt>(VectorValue->getAggregateElement(i))) {
642 if (const auto* CI = dyn_cast<ConstantInt>(Val)) {
642 if (const auto* CI = dyn_cast<ConstantInt>(Val)) {
757 const ConstantInt *ConstIdx = dyn_cast<ConstantInt>(*I);
757 const ConstantInt *ConstIdx = dyn_cast<ConstantInt>(*I);
760 ConstIdx = dyn_cast<ConstantInt>(Splat);
include/llvm/Analysis/Utils/Local.h 58 Result = Builder->CreateAdd(Result, ConstantInt::get(IntPtrTy, Size),
67 Constant *Scale = ConstantInt::get(IntPtrTy, Size);
85 Op = Builder->CreateMul(Op, ConstantInt::get(IntPtrTy, Size),
include/llvm/Analysis/ValueLattice.h 165 if (isConstant() && isa<ConstantInt>(getConstant())) {
166 return cast<ConstantInt>(getConstant())->getValue();
186 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
186 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
202 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
202 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
284 ConstantInt *getConstantInt() const {
287 return cast<ConstantInt>(getConstant());
309 return ConstantInt::getTrue(Ty);
313 return ConstantInt::getFalse(Ty);
include/llvm/CodeGen/BasicTTIImpl.h 1098 unsigned Alignment = cast<ConstantInt>(Args[2])->getZExtValue();
1106 unsigned Alignment = cast<ConstantInt>(Args[1])->getZExtValue();
include/llvm/CodeGen/GlobalISel/CSEMIRBuilder.h 101 const ConstantInt &Val) override;
include/llvm/CodeGen/GlobalISel/MachineIRBuilder.h 673 const ConstantInt &Val);
include/llvm/CodeGen/MachineInstrBuilder.h 127 const MachineInstrBuilder &addCImm(const ConstantInt *Val) const {
include/llvm/CodeGen/MachineOperand.h 169 const ConstantInt *CI; // For MO_CImmediate. Integers > 64bit.
535 const ConstantInt *getCImm() const {
653 void setCImm(const ConstantInt *CI) {
762 static MachineOperand CreateCImm(const ConstantInt *CI) {
include/llvm/CodeGen/SelectionDAG.h 589 SDValue getConstant(const ConstantInt &Val, const SDLoc &DL, EVT VT,
604 SDValue getTargetConstant(const ConstantInt &Val, const SDLoc &DL, EVT VT,
include/llvm/CodeGen/SelectionDAGNodes.h 1576 const ConstantInt *Value;
1578 ConstantSDNode(bool isTarget, bool isOpaque, const ConstantInt *val, EVT VT)
1586 const ConstantInt *getConstantIntValue() const { return Value; }
include/llvm/CodeGen/SwitchLoweringUtils.h 38 const ConstantInt *Low, *High;
46 static CaseCluster range(const ConstantInt *Low, const ConstantInt *High,
46 static CaseCluster range(const ConstantInt *Low, const ConstantInt *High,
57 static CaseCluster jumpTable(const ConstantInt *Low, const ConstantInt *High,
57 static CaseCluster jumpTable(const ConstantInt *Low, const ConstantInt *High,
68 static CaseCluster bitTests(const ConstantInt *Low, const ConstantInt *High,
68 static CaseCluster bitTests(const ConstantInt *Low, const ConstantInt *High,
237 const ConstantInt *GE;
238 const ConstantInt *LT;
include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h 486 ConstantInt *StubAddrCI =
487 ConstantInt::get(GVsM->getContext(), APInt(PtrBitWidth, StubAddr));
include/llvm/IR/Constants.h 93 ConstantInt(const ConstantInt &) = delete;
95 static ConstantInt *getTrue(LLVMContext &Context);
96 static ConstantInt *getFalse(LLVMContext &Context);
110 static ConstantInt *get(IntegerType *Ty, uint64_t V,
118 static ConstantInt *getSigned(IntegerType *Ty, int64_t V);
123 static ConstantInt *get(LLVMContext &Context, const APInt &V);
127 static ConstantInt *get(IntegerType *Ty, StringRef Str,
459 static typename std::enable_if<are_base_of<Constant, Csts...>::value,
461 get(StructType *T, Csts *... Vs) {
include/llvm/IR/DebugInfoMetadata.h 326 typedef PointerUnion<ConstantInt*, DIVariable*> CountType;
330 return CountType(cast<ConstantInt>(MD->getValue()));
855 if (auto *CI = dyn_cast_or_null<ConstantInt>(CM->getValue()))
855 if (auto *CI = dyn_cast_or_null<ConstantInt>(CM->getValue()))
include/llvm/IR/IRBuilder.h 333 ConstantInt *getInt1(bool V) {
334 return ConstantInt::get(getInt1Ty(), V);
338 ConstantInt *getTrue() {
339 return ConstantInt::getTrue(Context);
343 ConstantInt *getFalse() {
344 return ConstantInt::getFalse(Context);
348 ConstantInt *getInt8(uint8_t C) {
349 return ConstantInt::get(getInt8Ty(), C);
353 ConstantInt *getInt16(uint16_t C) {
354 return ConstantInt::get(getInt16Ty(), C);
358 ConstantInt *getInt32(uint32_t C) {
359 return ConstantInt::get(getInt32Ty(), C);
363 ConstantInt *getInt64(uint64_t C) {
364 return ConstantInt::get(getInt64Ty(), C);
369 ConstantInt *getIntN(unsigned N, uint64_t C) {
370 return ConstantInt::get(getIntNTy(N), C);
374 ConstantInt *getInt(const APInt &AI) {
375 return ConstantInt::get(Context, AI);
625 CallInst *CreateLifetimeStart(Value *Ptr, ConstantInt *Size = nullptr);
630 CallInst *CreateLifetimeEnd(Value *Ptr, ConstantInt *Size = nullptr);
635 CallInst *CreateInvariantStart(Value *Ptr, ConstantInt *Size = nullptr);
1233 return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1239 return CreateShl(LHS, ConstantInt::get(LHS->getType(), RHS), Name,
1255 return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1260 return CreateLShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1275 return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1280 return CreateAShr(LHS, ConstantInt::get(LHS->getType(), RHS), Name,isExact);
1285 if (isa<ConstantInt>(RC) && cast<ConstantInt>(RC)->isMinusOne())
1285 if (isa<ConstantInt>(RC) && cast<ConstantInt>(RC)->isMinusOne())
1294 return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1298 return CreateAnd(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1320 return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1324 return CreateOr(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1341 return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1345 return CreateXor(LHS, ConstantInt::get(LHS->getType(), RHS), Name);
1756 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1766 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1777 ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1778 ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1790 ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1791 ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1802 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1816 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1832 ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1833 ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1850 ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1851 ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1879 Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
2492 V = CreateInsertElement(Undef, V, ConstantInt::get(I32Ty, 0),
2531 Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
2579 Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
2609 if (const auto *CI = dyn_cast<ConstantInt>(OffsetValue))
2609 if (const auto *CI = dyn_cast<ConstantInt>(OffsetValue))
2620 Value *Zero = ConstantInt::get(IntPtrTy, 0);
2649 Value *Mask = ConstantInt::get(IntPtrTy, Alignment - 1);
2679 Value *Mask = CreateSub(Alignment, ConstantInt::get(IntPtrTy, 1), "mask");
include/llvm/IR/Instructions.h 3185 ConstantIntT *getCaseValue() const {
3217 CaseHandleImpl<const SwitchInst, const ConstantInt, const BasicBlock>;
3220 : public CaseHandleImpl<SwitchInst, ConstantInt, BasicBlock> {
3227 void setValue(ConstantInt *V) {
3391 CaseIt findCaseValue(const ConstantInt *C) {
3399 ConstCaseIt findCaseValue(const ConstantInt *C) const {
3411 ConstantInt *findCaseDest(BasicBlock *BB) {
3415 ConstantInt *CI = nullptr;
3433 void addCase(ConstantInt *OnVal, BasicBlock *Dest);
3496 void addCase(ConstantInt *OnVal, BasicBlock *Dest, CaseWeightOpt W);
include/llvm/IR/IntrinsicInst.h 505 ConstantInt *getElementSizeInBytesCst() const {
506 return cast<ConstantInt>(getRawElementSizeInBytes());
594 ConstantInt *getVolatileCst() const {
595 return cast<ConstantInt>(
833 ConstantInt *getHash() const {
834 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
837 ConstantInt *getNumCounters() const {
838 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(2)));
841 ConstantInt *getIndex() const {
842 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
873 ConstantInt *getHash() const {
874 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(1)));
881 ConstantInt *getValueKind() const {
882 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(3)));
886 ConstantInt *getIndex() const {
887 return cast<ConstantInt>(const_cast<Value *>(getArgOperand(4)));
include/llvm/IR/Metadata.h 514 static const bool value = std::is_base_of<Constant, V>::value &&
518 static const bool value = std::is_base_of<Constant, V>::value &&
529 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, bool>::type
533 return isa<X>(V->getValue());
547 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
547 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
549 return cast<X>(cast<ConstantAsMetadata>(MD)->getValue());
563 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
563 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
566 return cast<X>(V->getValue());
576 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
576 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
579 return dyn_cast<X>(V->getValue());
589 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
589 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
592 return dyn_cast<X>(V->getValue());
include/llvm/IR/Operator.h 518 if (ConstantInt *C = dyn_cast<ConstantInt>(I))
518 if (ConstantInt *C = dyn_cast<ConstantInt>(I))
531 if (!isa<ConstantInt>(I))
539 return !isa<ConstantInt>(*use);
include/llvm/IR/PatternMatch.h 66 template <typename ITy> bool match(ITy *V) { return isa<Class>(V); }
81 inline class_match<ConstantInt> m_ConstantInt() {
158 if (auto *CI = dyn_cast<ConstantInt>(V)) {
158 if (auto *CI = dyn_cast<ConstantInt>(V)) {
164 if (auto *CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue())) {
164 if (auto *CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue())) {
202 if (const auto *CI = dyn_cast<ConstantInt>(V)) {
202 if (const auto *CI = dyn_cast<ConstantInt>(V)) {
225 if (const auto *CI = dyn_cast<ConstantInt>(V))
225 if (const auto *CI = dyn_cast<ConstantInt>(V))
229 if (const auto *CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue()))
229 if (const auto *CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue()))
242 auto *CI = dyn_cast<ConstantInt>(Elt);
242 auto *CI = dyn_cast<ConstantInt>(Elt);
262 if (const auto *CI = dyn_cast<ConstantInt>(V))
262 if (const auto *CI = dyn_cast<ConstantInt>(V))
269 if (auto *CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue()))
269 if (auto *CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue()))
540 Class *&VR;
542 bind_ty(Class *&V) : VR(V) {}
545 if (auto *CV = dyn_cast<Class>(V)) {
545 if (auto *CV = dyn_cast<Class>(V)) {
563 inline bind_ty<ConstantInt> m_ConstantInt(ConstantInt *&CI) { return CI; }
563 inline bind_ty<ConstantInt> m_ConstantInt(ConstantInt *&CI) { return CI; }
636 if (const auto *CV = dyn_cast<ConstantInt>(V))
636 if (const auto *CV = dyn_cast<ConstantInt>(V))
653 const auto *CI = dyn_cast<ConstantInt>(V);
653 const auto *CI = dyn_cast<ConstantInt>(V);
656 CI = dyn_cast_or_null<ConstantInt>(C->getSplatValue());
include/llvm/IR/Statepoint.h 113 return cast<ConstantInt>(getCall()->getArgOperand(FlagsPos))
120 return cast<ConstantInt>(IDVal)->getZExtValue();
127 cast<ConstantInt>(NumPatchBytesVal)->getZExtValue();
166 return cast<ConstantInt>(NumCallArgsVal)->getZExtValue();
200 return cast<ConstantInt>(NumGCTransitionArgs)->getZExtValue();
222 return cast<ConstantInt>(NumVMSArgs)->getZExtValue();
374 return cast<ConstantInt>(getArgOperand(1))->getZExtValue();
380 return cast<ConstantInt>(getArgOperand(2))->getZExtValue();
include/llvm/Support/Casting.h 58 return To::classof(&Val);
66 static inline bool doit(const From &) { return true; }
77 return isa_impl<To, From>::doit(Val);
92 return isa_impl<To, From>::doit(*Val);
104 static inline bool doit(const From *Val) {
106 return isa_impl<To, From>::doit(*Val);
106 return isa_impl<To, From>::doit(*Val);
122 return isa_impl_wrap<To, SimpleFrom,
132 return isa_impl_cl<To,FromTy>::doit(Val);
142 return isa_impl_wrap<X, const Y,
172 using ret_type = To *; // Pointer arg case, return Ty*
176 using ret_type = const To *; // Constant pointer arg case, return const Ty*
198 using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
204 using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
210 To, From, typename simplify_type<From>::SimpleType>::ret_type;
218 static typename cast_retty<To, From>::ret_type doit(From &Val) {
219 return cast_convert_val<To, SimpleFrom,
227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
228 typename cast_retty<To, FromTy>::ret_type Res2
248 typename cast_retty<X, const Y>::ret_type>::type
252 X, const Y, typename simplify_type<const Y>::SimpleType>::doit(Val);
256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
258 return cast_convert_val<X, Y,
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
265 return cast_convert_val<X, Y*,
265 return cast_convert_val<X, Y*,
266 typename simplify_type<Y*>::SimpleType>::doit(Val);
331 typename cast_retty<X, const Y>::ret_type>::type
333 return isa<X>(Val) ? cast<X>(Val) : nullptr;
333 return isa<X>(Val) ? cast<X>(Val) : nullptr;
337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
338 return isa<X>(Val) ? cast<X>(Val) : nullptr;
338 return isa<X>(Val) ? cast<X>(Val) : nullptr;
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
343 return isa<X>(Val) ? cast<X>(Val) : nullptr;
366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
368 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
368 return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
include/llvm/Support/PointerLikeTypeTraits.h 56 static inline void *getAsVoidPointer(T *P) { return P; }
57 static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
59 enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
include/llvm/Transforms/Scalar/ConstantHoisting.h 85 ConstantInt *ConstInt;
89 ConstantCandidate(ConstantInt *ConstInt, ConstantExpr *ConstExpr=nullptr) :
117 ConstantInt *BaseInt;
146 using ConstPtrUnionType = PointerUnion<ConstantInt *, ConstantExpr *>;
177 ConstantInt *ConstInt);
include/llvm/Transforms/Utils/LowerMemIntrinsics.h 38 Value *DstAddr, ConstantInt *CopyLen,
lib/Analysis/AssumptionCache.cpp 96 ConstantInt *C;
lib/Analysis/BasicAliasAnalysis.cpp 290 if (const ConstantInt *Const = dyn_cast<ConstantInt>(V)) {
290 if (const ConstantInt *Const = dyn_cast<ConstantInt>(V)) {
302 if (ConstantInt *RHSC = dyn_cast<ConstantInt>(BOp->getOperand(1))) {
302 if (ConstantInt *RHSC = dyn_cast<ConstantInt>(BOp->getOperand(1))) {
545 unsigned FieldNo = cast<ConstantInt>(Index)->getZExtValue();
555 if (const ConstantInt *CIdx = dyn_cast<ConstantInt>(Index)) {
555 if (const ConstantInt *CIdx = dyn_cast<ConstantInt>(Index)) {
1109 ConstantInt *C1 =
1110 dyn_cast<ConstantInt>(GEP1->getOperand(GEP1->getNumOperands() - 1));
1111 ConstantInt *C2 =
1112 dyn_cast<ConstantInt>(GEP2->getOperand(GEP2->getNumOperands() - 1));
1657 isa<ConstantInt>(PV1GEP->idx_begin())) {
1684 isa<ConstantInt>(PV1GEP->idx_begin())) {
lib/Analysis/BranchProbabilityInfo.cpp 281 ConstantInt *Weight =
282 mdconst::dyn_extract<ConstantInt>(WeightsNode->getOperand(i));
672 return dyn_cast<ConstantInt>(I->getOperand(0));
673 return dyn_cast<ConstantInt>(V);
677 ConstantInt *CV = GetConstantInt(RHS);
685 if (ConstantInt *AndRHS = dyn_cast<ConstantInt>(LHS->getOperand(1)))
685 if (ConstantInt *AndRHS = dyn_cast<ConstantInt>(LHS->getOperand(1)))
lib/Analysis/CmpInstAnalysis.cpp 47 return ConstantInt::get(CmpInst::makeCmpResultType(OpTy), 0);
55 return ConstantInt::get(CmpInst::makeCmpResultType(OpTy), 1);
lib/Analysis/ConstantFolding.cpp 81 auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
81 auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
128 return ConstantInt::get(DestTy, Result);
142 if (isa<ConstantFP>(C) || isa<ConstantInt>(C)) {
218 Src = dyn_cast_or_null<ConstantInt>(Src);
227 ConstantInt::get(Src->getType(), ShiftAmt));
255 auto *Src = dyn_cast<ConstantInt>(Element);
255 auto *Src = dyn_cast<ConstantInt>(Element);
264 ConstantInt::get(Src->getType(), ShiftAmt));
388 if (auto *CI = dyn_cast<ConstantInt>(C)) {
388 if (auto *CI = dyn_cast<ConstantInt>(C)) {
601 return ConstantInt::get(IntType->getContext(), ResultVal);
678 Constant *Res = ConstantInt::get(CE->getContext(), StrVal);
738 return ConstantInt::get(Op0->getType(), Known0.getConstant());
754 return ConstantInt::get(Op0->getType(), Offs1.zextOrTrunc(OpSize) -
845 if (!isa<ConstantInt>(Ops[i])) {
884 if (!isa<ConstantInt>(NestedOp)) {
902 if (auto *Base = dyn_cast<ConstantInt>(CE->getOperand(0)))
902 if (auto *Base = dyn_cast<ConstantInt>(CE->getOperand(0)))
910 Constant *C = ConstantInt::get(Ptr->getContext(), Offset + BasePtr);
946 NewIdxs.push_back(ConstantInt::get(IntPtrTy, 0));
955 NewIdxs.push_back(ConstantInt::get(IntPtrTy, NewIdx));
971 NewIdxs.push_back(ConstantInt::get(Type::getInt32Ty(Ty->getContext()),
1323 ConstantInt::get(CE->getContext(),
1641 return ConstantInt::get(Ty, UIntVal, IsSigned);
1673 if (auto *CI = dyn_cast<ConstantInt>(Op)) {
1673 if (auto *CI = dyn_cast<ConstantInt>(Op)) {
1697 return ConstantInt::getTrue(Ty->getContext());
1738 return ConstantInt::get(Ty->getContext(), Val.bitcastToAPInt());
1964 if (auto *Op = dyn_cast<ConstantInt>(Operands[0])) {
1964 if (auto *Op = dyn_cast<ConstantInt>(Operands[0])) {
1967 return ConstantInt::get(Ty->getContext(), Op->getValue().byteSwap());
1969 return ConstantInt::get(Ty, Op->getValue().countPopulation());
1971 return ConstantInt::get(Ty->getContext(), Op->getValue().reverseBits());
2106 } else if (auto *Op2C = dyn_cast<ConstantInt>(Operands[1])) {
2106 } else if (auto *Op2C = dyn_cast<ConstantInt>(Operands[1])) {
2178 ConstantInt::get(Ty->getContext(), Res),
2179 ConstantInt::get(Type::getInt1Ty(Ty->getContext()), Overflow)
2190 return ConstantInt::get(Ty, C0->uadd_sat(*C1));
2192 return ConstantInt::get(Ty, C0->sadd_sat(*C1));
2200 return ConstantInt::get(Ty, C0->usub_sat(*C1));
2202 return ConstantInt::get(Ty, C0->ssub_sat(*C1));
2213 return ConstantInt::get(Ty, C0->countTrailingZeros());
2215 return ConstantInt::get(Ty, C0->countLeadingZeros());
2226 isa<ConstantInt>(Operands[1]) &&
2227 cast<ConstantInt>(Operands[1])->getValue() == 4) {
2301 if (const auto *Op1 = dyn_cast<ConstantInt>(Operands[0])) {
2301 if (const auto *Op1 = dyn_cast<ConstantInt>(Operands[0])) {
2302 if (const auto *Op2 = dyn_cast<ConstantInt>(Operands[1])) {
2302 if (const auto *Op2 = dyn_cast<ConstantInt>(Operands[1])) {
2303 if (const auto *Op3 = dyn_cast<ConstantInt>(Operands[2])) {
2303 if (const auto *Op3 = dyn_cast<ConstantInt>(Operands[2])) {
2330 return ConstantInt::get(Ty->getContext(),
2362 return ConstantInt::get(Ty, C1->lshr(LshrAmt));
2364 return ConstantInt::get(Ty, C0->shl(ShlAmt));
2365 return ConstantInt::get(Ty, C0->shl(ShlAmt) | C1->lshr(LshrAmt));
lib/Analysis/IVDescriptors.cpp 732 return ConstantInt::get(Tp, 0);
735 return ConstantInt::get(Tp, 1);
738 return ConstantInt::get(Tp, -1, true);
815 ConstantInt *ConstStep = getConstIntStepValue();
821 ConstantInt *InductionDescriptor::getConstIntStepValue() const {
823 return dyn_cast<ConstantInt>(cast<SCEVConstant>(Step)->getValue());
1082 ConstantInt *CV = ConstStep->getValue();
lib/Analysis/InlineCost.cpp 213 ConstantInt *stripAndComputeInBoundsConstantOffsets(Value *&V);
394 ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand());
394 ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand());
397 OpC = dyn_cast<ConstantInt>(SimpleOp);
436 if (auto *AllocSize = dyn_cast_or_null<ConstantInt>(Size)) {
436 if (auto *AllocSize = dyn_cast_or_null<ConstantInt>(Size)) {
1003 Constant *CLHS = ConstantInt::get(LHS->getContext(), LHSOffset);
1004 Constant *CRHS = ConstantInt::get(RHS->getContext(), RHSOffset);
1018 SimplifiedValues[&I] = IsNotEqual ? ConstantInt::getTrue(I.getType())
1019 : ConstantInt::getFalse(I.getType());
1049 Constant *CLHS = ConstantInt::get(LHS->getContext(), LHSOffset);
1050 Constant *CRHS = ConstantInt::get(RHS->getContext(), RHSOffset);
1348 return BI.isUnconditional() || isa<ConstantInt>(BI.getCondition()) ||
1349 dyn_cast_or_null<ConstantInt>(
1437 if (isa<ConstantInt>(SI.getCondition()))
1440 if (isa<ConstantInt>(V))
1650 ConstantInt *CallAnalyzer::stripAndComputeInBoundsConstantOffsets(Value *&V) {
1680 return cast<ConstantInt>(ConstantInt::get(IntPtrTy, Offset));
1680 return cast<ConstantInt>(ConstantInt::get(IntPtrTy, Offset));
1795 if (ConstantInt *C = stripAndComputeInBoundsConstantOffsets(PtrArg)) {
1865 if (ConstantInt *SimpleCond =
1866 dyn_cast_or_null<ConstantInt>(SimplifiedValues.lookup(Cond))) {
1876 if (ConstantInt *SimpleCond =
1877 dyn_cast_or_null<ConstantInt>(SimplifiedValues.lookup(Cond))) {
lib/Analysis/InstructionSimplify.cpp 117 return ConstantInt::getFalse(Ty);
123 return ConstantInt::getTrue(Ty);
668 Constant *OffsetIntPtr = ConstantInt::get(IntPtrTy, Offset);
930 return IsDiv ? ConstantInt::get(Ty, 1) : Constant::getNullValue(Ty);
977 Constant *PosDividendC = ConstantInt::get(Ty, C->abs());
978 Constant *NegDividendC = ConstantInt::get(Ty, -C->abs());
993 Constant *PosDivisorC = ConstantInt::get(Ty, C->abs());
994 Constant *NegDivisorC = ConstantInt::get(Ty, -C->abs());
1038 ConstantInt *C1, *C2;
1142 return ConstantInt::getNullValue(Op0->getType());
1146 return ConstantInt::getNullValue(Op0->getType());
1177 if (ConstantInt *CI = dyn_cast<ConstantInt>(C))
1177 if (ConstantInt *CI = dyn_cast<ConstantInt>(C))
1398 return ConstantInt::getTrue(UnsignedICmp->getType());
1403 return ConstantInt::getFalse(UnsignedICmp->getType());
2313 return ConstantInt::get(GetCompareTy(LHS),
2385 ConstantInt *LHSOffsetCI = dyn_cast<ConstantInt>(LHSOffset);
2385 ConstantInt *LHSOffsetCI = dyn_cast<ConstantInt>(LHSOffset);
2386 ConstantInt *RHSOffsetCI = dyn_cast<ConstantInt>(RHSOffset);
2386 ConstantInt *RHSOffsetCI = dyn_cast<ConstantInt>(RHSOffset);
2400 return ConstantInt::get(GetCompareTy(LHS),
2411 return ConstantInt::get(GetCompareTy(LHS),
2462 return ConstantInt::get(GetCompareTy(LHS),
2478 return ConstantInt::get(GetCompareTy(LHS),
2634 return ConstantInt::getFalse(ITy);
2636 return ConstantInt::getTrue(ITy);
2646 return ConstantInt::getFalse(ITy);
2648 return ConstantInt::getTrue(ITy);
2653 return ConstantInt::getTrue(ITy);
2655 return ConstantInt::getFalse(ITy);
2792 if (ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS)) {
2792 if (ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS)) {
2795 return ConstantInt::getTrue(RHSC->getContext());
2797 return ConstantInt::getFalse(RHSC->getContext());
2799 return ConstantInt::getFalse(RHSC->getContext());
2801 return ConstantInt::getTrue(RHSC->getContext());
2805 return ConstantInt::getTrue(RHSC->getContext());
2807 return ConstantInt::getFalse(RHSC->getContext());
2899 if (auto *CI = dyn_cast<ConstantInt>(RHS)) {
2899 if (auto *CI = dyn_cast<ConstantInt>(RHS)) {
2916 return ConstantInt::getFalse(RHS->getContext());
2918 return ConstantInt::getTrue(RHS->getContext());
2923 return ConstantInt::getFalse(RHS->getContext());
2925 return ConstantInt::getTrue(RHS->getContext());
3208 return ConstantInt::get(ITy, CmpInst::isTrueWhenEqual(Pred));
3234 return ConstantInt::getTrue(RHS->getContext());
3239 return ConstantInt::getFalse(RHS->getContext());
3282 else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
3282 else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
3304 return ConstantInt::getFalse(CI->getContext());
3309 return ConstantInt::getTrue(CI->getContext());
3316 ConstantInt::getTrue(CI->getContext()) :
3317 ConstantInt::getFalse(CI->getContext());
3322 ConstantInt::getFalse(CI->getContext()) :
3323 ConstantInt::getTrue(CI->getContext());
3341 else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
3341 else if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
3359 return ConstantInt::getFalse(CI->getContext());
3361 return ConstantInt::getTrue(CI->getContext());
3368 ConstantInt::getTrue(CI->getContext()) :
3369 ConstantInt::getFalse(CI->getContext());
3373 ConstantInt::getFalse(CI->getContext()) :
3374 ConstantInt::getTrue(CI->getContext());
3502 return ConstantInt::get(RetTy, Pred == FCmpInst::FCMP_ORD);
3508 return ConstantInt::get(RetTy, CmpInst::isUnordered(Pred));
3515 return ConstantInt::get(RetTy, CmpInst::isUnordered(Pred));
3606 return ConstantInt::get(RetTy, IsMaxNum);
3613 return ConstantInt::get(RetTy, !IsMaxNum);
4077 auto *CI = ConstantInt::get(GEPTy->getContext(), BasePtrOffset);
4077 auto *CI = ConstantInt::get(GEPTy->getContext(), BasePtrOffset);
4083 auto *CI = ConstantInt::get(GEPTy->getContext(), BasePtrOffset - 1);
4083 auto *CI = ConstantInt::get(GEPTy->getContext(), BasePtrOffset - 1);
4150 if (auto *CI = dyn_cast<ConstantInt>(Idx)) {
4150 if (auto *CI = dyn_cast<ConstantInt>(Idx)) {
4222 if (auto *IdxC = dyn_cast<ConstantInt>(Idx)) {
4222 if (auto *IdxC = dyn_cast<ConstantInt>(Idx)) {
4885 auto *OffsetConstInt = dyn_cast<ConstantInt>(Offset);
4885 auto *OffsetConstInt = dyn_cast<ConstantInt>(Offset);
4895 ConstantInt::get(Int64Ty, OffsetInt / 4));
5077 if (auto *Power = dyn_cast<ConstantInt>(Op1)) {
5077 if (auto *Power = dyn_cast<ConstantInt>(Op1)) {
5394 Result = ConstantInt::get(I->getType(), Known.getConstant());
lib/Analysis/LazyValueInfo.cpp 682 ConstantInt *Len = dyn_cast<ConstantInt>(MI->getLength());
682 ConstantInt *Len = dyn_cast<ConstantInt>(MI->getLength());
958 if (ConstantInt *CIBase = dyn_cast<ConstantInt>(ICI->getOperand(1))) {
958 if (ConstantInt *CIBase = dyn_cast<ConstantInt>(ICI->getOperand(1))) {
961 return ConstantInt::get(A->getType(), A->getValue() + B->getValue());
966 ConstantInt *CIAdded;
1224 ConstantInt *Offset = nullptr;
1232 if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS))
1232 if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS))
1356 if (auto *C = dyn_cast_or_null<ConstantInt>(
1356 if (auto *C = dyn_cast_or_null<ConstantInt>(
1368 if (auto *C = dyn_cast_or_null<ConstantInt>(
1368 if (auto *C = dyn_cast_or_null<ConstantInt>(
1396 Result = ValueLatticeElement::get(ConstantInt::get(
1709 return ConstantInt::get(V->getContext(), *SingleVal);
1746 return ConstantInt::get(V->getContext(), *SingleVal);
1778 if (ConstantInt *ResCI = dyn_cast<ConstantInt>(Res))
1778 if (ConstantInt *ResCI = dyn_cast<ConstantInt>(Res))
1784 ConstantInt *CI = dyn_cast<ConstantInt>(C);
1784 ConstantInt *CI = dyn_cast<ConstantInt>(C);
lib/Analysis/Lint.cpp 337 if (const ConstantInt *Len =
338 dyn_cast<ConstantInt>(findValue(MCI->getLength(),
529 if (ConstantInt *CI = dyn_cast<ConstantInt>(findValue(I.getOperand(1),
529 if (ConstantInt *CI = dyn_cast<ConstantInt>(findValue(I.getOperand(1),
536 if (ConstantInt *CI =
537 dyn_cast<ConstantInt>(findValue(I.getOperand(1), /*OffsetOk=*/false)))
543 if (ConstantInt *CI =
544 dyn_cast<ConstantInt>(findValue(I.getOperand(1), /*OffsetOk=*/false)))
605 if (isa<ConstantInt>(I.getArraySize()))
627 if (ConstantInt *CI = dyn_cast<ConstantInt>(findValue(I.getIndexOperand(),
627 if (ConstantInt *CI = dyn_cast<ConstantInt>(findValue(I.getIndexOperand(),
634 if (ConstantInt *CI = dyn_cast<ConstantInt>(findValue(I.getOperand(2),
634 if (ConstantInt *CI = dyn_cast<ConstantInt>(findValue(I.getOperand(2),
lib/Analysis/LoopAccessAnalysis.cpp 964 if (!isa<ConstantInt>(Index)) {
979 isa<ConstantInt>(OBO->getOperand(1))) {
2267 ConstantInt::getTrue(Ctx));
lib/Analysis/LoopCacheAnalysis.cpp 235 const ConstantInt &CI = *SCEVConst->getValue();
lib/Analysis/LoopInfo.cpp 156 if (ConstantInt *CI =
157 dyn_cast<ConstantInt>(PN->getIncomingValueForBlock(Incoming)))
162 if (ConstantInt *CI = dyn_cast<ConstantInt>(Inc->getOperand(1)))
162 if (ConstantInt *CI = dyn_cast<ConstantInt>(Inc->getOperand(1)))
406 ConstantInt *Init = dyn_cast_or_null<ConstantInt>(IndDesc.getStartValue());
406 ConstantInt *Init = dyn_cast_or_null<ConstantInt>(IndDesc.getStartValue());
413 ConstantInt *Step = IndDesc.getConstIntStepValue();
lib/Analysis/LoopUnrollAnalyzer.cpp 100 ConstantInt *SimplifiedAddrOp = AddressIt->second.Offset;
lib/Analysis/MemoryBuiltins.cpp 509 bool MaxVal = cast<ConstantInt>(ObjectSize->getArgOperand(1))->isZero();
520 cast<ConstantInt>(ObjectSize->getArgOperand(2))->isOne();
523 bool StaticOnly = cast<ConstantInt>(ObjectSize->getArgOperand(3))->isZero();
530 return ConstantInt::get(ResultType, Size);
547 return Builder.CreateSelect(UseZero, ConstantInt::get(ResultType, 0),
555 return ConstantInt::get(ResultType, MaxVal ? -1ULL : 0);
640 if (const ConstantInt *C = dyn_cast<ConstantInt>(ArraySize)) {
640 if (const ConstantInt *C = dyn_cast<ConstantInt>(ArraySize)) {
677 ConstantInt *Arg =
678 dyn_cast<ConstantInt>(CS.getArgument(FnData->FstParam));
689 ConstantInt *Arg = dyn_cast<ConstantInt>(CS.getArgument(FnData->FstParam));
689 ConstantInt *Arg = dyn_cast<ConstantInt>(CS.getArgument(FnData->FstParam));
701 Arg = dyn_cast<ConstantInt>(CS.getArgument(FnData->SndParam));
838 Zero = ConstantInt::get(IntTy, 0);
869 return std::make_pair(ConstantInt::get(Context, Const.first),
870 ConstantInt::get(Context, Const.second));
923 Value *Size = ConstantInt::get(ArraySize->getType(),
lib/Analysis/MemoryLocation.cpp 95 if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength()))
95 if (ConstantInt *C = dyn_cast<ConstantInt>(MTI->getLength()))
116 if (ConstantInt *C = dyn_cast<ConstantInt>(MI->getLength()))
116 if (ConstantInt *C = dyn_cast<ConstantInt>(MI->getLength()))
146 if (ConstantInt *LenCI = dyn_cast<ConstantInt>(II->getArgOperand(2)))
146 if (ConstantInt *LenCI = dyn_cast<ConstantInt>(II->getArgOperand(2)))
158 cast<ConstantInt>(II->getArgOperand(0))->getZExtValue()),
170 cast<ConstantInt>(II->getArgOperand(1))->getZExtValue()),
202 if (const ConstantInt *LenCI =
203 dyn_cast<ConstantInt>(Call->getArgOperand(2)))
lib/Analysis/ModuleSummaryAnalysis.cpp 148 auto *CI = dyn_cast<ConstantInt>(Arg);
148 auto *CI = dyn_cast<ConstantInt>(Arg);
558 cast<ConstantInt>(
644 if (auto *MD = mdconst::extract_or_null<ConstantInt>(
644 if (auto *MD = mdconst::extract_or_null<ConstantInt>(
726 if (auto *MD =
727 mdconst::extract_or_null<ConstantInt>(M.getModuleFlag("ThinLTO")))
lib/Analysis/MustExecute.cpp 127 if (auto *Cond = dyn_cast<ConstantInt>(BI->getCondition()))
127 if (auto *Cond = dyn_cast<ConstantInt>(BI->getCondition()))
lib/Analysis/PHITransAddr.cpp 35 isa<ConstantInt>(Inst->getOperand(1)))
254 isa<ConstantInt>(Inst->getOperand(1))) {
256 Constant *RHS = cast<ConstantInt>(Inst->getOperand(1));
266 if (ConstantInt *CI = dyn_cast<ConstantInt>(BOp->getOperand(1))) {
266 if (ConstantInt *CI = dyn_cast<ConstantInt>(BOp->getOperand(1))) {
lib/Analysis/ScalarEvolution.cpp 420 const SCEV *ScalarEvolution::getConstant(ConstantInt *V) {
432 return getConstant(ConstantInt::get(getContext(), Val));
438 return getConstant(ConstantInt::get(ITy, V, isSigned));
494 if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(1)))
494 if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(1)))
516 if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(2)))
516 if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(2)))
1272 cast<ConstantInt>(ConstantExpr::getTrunc(SC->getValue(), Ty)));
1648 cast<ConstantInt>(ConstantExpr::getZExt(SC->getValue(), Ty)));
1954 cast<ConstantInt>(ConstantExpr::getSExt(SC->getValue(), Ty)));
2953 ConstantInt *Fold =
2954 ConstantInt::get(getContext(), LHSC->getAPInt() * RHSC->getAPInt());
3300 return getConstant(cast<ConstantInt>(ConstantExpr::getUDiv(LHSCV,
3508 ConstantInt *Index = cast<SCEVConstant>(IndexExpr)->getValue();
3590 ConstantInt *Fold = ConstantInt::get(
3590 ConstantInt *Fold = ConstantInt::get(
3824 static std::pair<const SCEV *, ConstantInt *> splitAddExpr(const SCEV *S) {
3869 ConstantInt *Offset;
3916 ConstantInt *Offset = nullptr;
3950 cast<ConstantInt>(ConstantExpr::getNeg(VC->getValue())));
3955 V, getConstant(cast<ConstantInt>(Constant::getAllOnesValue(Ty))), Flags);
3977 cast<ConstantInt>(ConstantExpr::getNot(VC->getValue())));
4000 getConstant(cast<ConstantInt>(Constant::getAllOnesValue(Ty)));
4520 if (auto *RHSC = dyn_cast<ConstantInt>(Op->getOperand(1)))
4520 if (auto *RHSC = dyn_cast<ConstantInt>(Op->getOperand(1)))
4529 if (ConstantInt *SA = dyn_cast<ConstantInt>(Op->getOperand(1))) {
4529 if (ConstantInt *SA = dyn_cast<ConstantInt>(Op->getOperand(1))) {
4538 ConstantInt::get(SA->getContext(),
5332 if (auto *CI = dyn_cast<ConstantInt>(Cond))
5332 if (auto *CI = dyn_cast<ConstantInt>(Cond))
5393 isa<ConstantInt>(RHS) && cast<ConstantInt>(RHS)->isZero()) {
5393 isa<ConstantInt>(RHS) && cast<ConstantInt>(RHS)->isZero()) {
5407 isa<ConstantInt>(RHS) && cast<ConstantInt>(RHS)->isZero()) {
5407 isa<ConstantInt>(RHS) && cast<ConstantInt>(RHS)->isZero()) {
6145 } else if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
6145 } else if (ConstantInt *CI = dyn_cast<ConstantInt>(V))
6249 if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS)) {
6249 if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS)) {
6305 if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS)) {
6305 if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS)) {
6325 if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS)) {
6325 if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS)) {
6335 if (ConstantInt *LCI = dyn_cast<ConstantInt>(LBO->getOperand(1)))
6335 if (ConstantInt *LCI = dyn_cast<ConstantInt>(LBO->getOperand(1)))
6365 if (ConstantInt *SA = dyn_cast<ConstantInt>(BO->RHS)) {
6365 if (ConstantInt *SA = dyn_cast<ConstantInt>(BO->RHS)) {
6385 Constant *X = ConstantInt::get(
6393 ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS);
6393 ConstantInt *CI = dyn_cast<ConstantInt>(BO->RHS);
6425 ConstantInt *ShlAmtCI = dyn_cast<ConstantInt>(L->getOperand(1));
6425 ConstantInt *ShlAmtCI = dyn_cast<ConstantInt>(L->getOperand(1));
6516 ConstantInt *ExitConst = ExitCount->getValue();
6590 ConstantInt *Result = TC->getValue();
7342 if (ConstantInt *CI = dyn_cast<ConstantInt>(ExitCond)) {
7342 if (ConstantInt *CI = dyn_cast<ConstantInt>(ExitCond)) {
7478 static ConstantInt *
7479 EvaluateConstantChrecAtConstant(const SCEVAddRecExpr *AddRec, ConstantInt *C,
7516 if (ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(i))) {
7516 if (ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(i))) {
7518 } else if (!isa<ConstantInt>(GEP->getOperand(i))) {
7544 ConstantInt *ItCst = ConstantInt::get(
7544 ConstantInt *ItCst = ConstantInt::get(
7546 ConstantInt *Val = EvaluateConstantChrecAtConstant(IdxExpr, ItCst, *this);
7557 if (!isa<ConstantInt>(Result)) break; // Couldn't decide for sure
7558 if (cast<ConstantInt>(Result)->getValue().isMinValue()) {
7568 ConstantInt *RHS = dyn_cast<ConstantInt>(RHSV);
7568 ConstantInt *RHS = dyn_cast<ConstantInt>(RHSV);
7587 ConstantInt *ShiftAmt;
7665 ConstantInt *StableValue = nullptr;
7678 StableValue = ConstantInt::get(Ty, 0);
7680 StableValue = ConstantInt::get(Ty, -1, true);
7690 StableValue = ConstantInt::get(cast<IntegerType>(RHS->getType()), 0);
7987 auto *CondVal = dyn_cast_or_null<ConstantInt>(
7987 auto *CondVal = dyn_cast_or_null<ConstantInt>(
8555 ConstantInt *CX = ConstantInt::get(SE.getContext(), *X);
8555 ConstantInt *CX = ConstantInt::get(SE.getContext(), *X);
8556 ConstantInt *V = EvaluateConstantChrecAtConstant(AddRec, CX, SE);
8618 ConstantInt *C0 = ConstantInt::get(SE.getContext(), X);
8618 ConstantInt *C0 = ConstantInt::get(SE.getContext(), X);
8619 ConstantInt *V0 = EvaluateConstantChrecAtConstant(AddRec, C0, SE);
8623 ConstantInt *C1 = ConstantInt::get(SE.getContext(), X-1);
8623 ConstantInt *C1 = ConstantInt::get(SE.getContext(), X-1);
8624 ConstantInt *V1 = EvaluateConstantChrecAtConstant(AddRec, C1, SE);
8901 LHS = RHS = getConstant(ConstantInt::getFalse(getContext()));
10294 if (!isa<ConstantInt>(LR))
10842 ConstantInt *ExitValue = ConstantInt::get(SE.getContext(), ExitVal);
10842 ConstantInt *ExitValue = ConstantInt::get(SE.getContext(), ExitVal);
10847 ConstantInt *Val = EvaluateConstantChrecAtConstant(this, ExitValue, SE);
lib/Analysis/ScalarEvolutionExpander.cpp 263 ConstantInt *CI =
264 ConstantInt::get(SE.getContext(), C->getAPInt().sdiv(FC->getAPInt()));
479 ConstantInt::get(Type::getInt32Ty(Ty->getContext()), ElIdx));
843 ConstantInt::get(Ty, RHS->logBase2()), NWFlags,
863 ConstantInt::get(Ty, RHS.logBase2()),
1061 if (!isa<ConstantInt>(StepV))
1570 Constant *One = ConstantInt::get(Ty, 1);
1792 ConstantInt *Offset = VOPair.second;
1887 ConstantInt *Idx =
1888 ConstantInt::getSigned(VO.second->getType(), -(Offset * 8) / ESize);
1891 ConstantInt *Idx =
1892 ConstantInt::getSigned(VO.second->getType(), -Offset);
2273 ConstantInt *Zero =
2274 ConstantInt::get(Loc->getContext(), APInt::getNullValue(DstBits));
2324 ConstantInt::get(Loc->getContext(), MaxVal));
2357 return ConstantInt::getFalse(IP->getContext());
2363 Value *Check = ConstantInt::getNullValue(BoolType);
lib/Analysis/StackSafetyAnalysis.cpp 134 auto C = dyn_cast<ConstantInt>(AI->getArraySize());
271 const auto *Len = dyn_cast<ConstantInt>(MI->getLength());
271 const auto *Len = dyn_cast<ConstantInt>(MI->getLength());
lib/Analysis/TargetLibraryInfo.cpp 1611 return cast<ConstantInt>(ShortWChar->getValue())->getZExtValue();
lib/Analysis/TargetTransformInfo.cpp 540 if (auto *CI = dyn_cast<ConstantInt>(V)) {
540 if (auto *CI = dyn_cast<ConstantInt>(V)) {
561 if (auto *CI = dyn_cast<ConstantInt>(Splat))
567 if (auto *CI = dyn_cast<ConstantInt>(CDS->getElementAsConstant(I)))
567 if (auto *CI = dyn_cast<ConstantInt>(CDS->getElementAsConstant(I)))
1006 ConstantInt *CI = dyn_cast<ConstantInt>(ReduxRoot->getOperand(1));
1006 ConstantInt *CI = dyn_cast<ConstantInt>(ReduxRoot->getOperand(1));
1071 ConstantInt *CI = dyn_cast<ConstantInt>(ReduxRoot->getOperand(1));
1071 ConstantInt *CI = dyn_cast<ConstantInt>(ReduxRoot->getOperand(1));
1231 ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1));
1231 ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1));
1278 ConstantInt *CI = dyn_cast<ConstantInt>(IE->getOperand(2));
1278 ConstantInt *CI = dyn_cast<ConstantInt>(IE->getOperand(2));
lib/Analysis/TypeBasedAliasAnalysis.cpp 182 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Node->getOperand(2));
182 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Node->getOperand(2));
230 return mdconst::extract<ConstantInt>(Node->getOperand(2))->getZExtValue();
246 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Node->getOperand(OpNo));
246 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Node->getOperand(OpNo));
319 : mdconst::extract<ConstantInt>(Node->getOperand(2))
336 uint64_t Cur = mdconst::extract<ConstantInt>(Node->getOperand(Idx + 1))
348 uint64_t Cur = mdconst::extract<ConstantInt>(Node->getOperand(TheIdx + 1))
549 auto *OffsetNode = ConstantAsMetadata::get(ConstantInt::get(Int64, 0));
556 ConstantAsMetadata::get(ConstantInt::get(Int64, AccessSize));
lib/Analysis/TypeMetadataUtils.cpp 105 auto *Offset = dyn_cast<ConstantInt>(CI->getArgOperand(1));
105 auto *Offset = dyn_cast<ConstantInt>(CI->getArgOperand(1));
lib/Analysis/ValueTracking.cpp 257 if (auto *CI = dyn_cast<ConstantInt>(V))
448 ConstantInt *Lower =
449 mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 0));
450 ConstantInt *Upper =
451 mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 1));
898 if (auto *SA = dyn_cast<ConstantInt>(I->getOperand(1))) {
898 if (auto *SA = dyn_cast<ConstantInt>(I->getOperand(1))) {
1234 if (ConstantInt *Rem = dyn_cast<ConstantInt>(I->getOperand(1))) {
1234 if (ConstantInt *Rem = dyn_cast<ConstantInt>(I->getOperand(1))) {
1268 if (ConstantInt *Rem = dyn_cast<ConstantInt>(I->getOperand(1))) {
1268 if (ConstantInt *Rem = dyn_cast<ConstantInt>(I->getOperand(1))) {
1322 unsigned Idx = cast<ConstantInt>(Index)->getZExtValue();
1488 if (II->getArgOperand(1) == ConstantInt::getTrue(II->getContext()))
1499 if (II->getArgOperand(1) == ConstantInt::getTrue(II->getContext()))
1683 auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
1683 auto *ElementCI = dyn_cast_or_null<ConstantInt>(Element);
1866 ConstantInt *OpC = cast<ConstantInt>(GTI.getOperand());
1866 ConstantInt *OpC = cast<ConstantInt>(GTI.getOperand());
1881 if (ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand())) {
1881 if (ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand())) {
1983 ConstantInt *Lower =
1984 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 0));
1985 ConstantInt *Upper =
1986 mdconst::extract<ConstantInt>(Ranges->getOperand(2 * i + 1));
2004 if (isa<ConstantInt>(C))
2024 if (!isa<UndefValue>(Elt) && !isa<ConstantInt>(Elt))
2153 if (ConstantInt *Shift = dyn_cast<ConstantInt>(Y)) {
2153 if (ConstantInt *Shift = dyn_cast<ConstantInt>(Y)) {
2222 if (isa<ConstantInt>(Induction) && !isa<ConstantInt>(Start))
2222 if (isa<ConstantInt>(Induction) && !isa<ConstantInt>(Start))
2224 if (ConstantInt *C = dyn_cast<ConstantInt>(Start)) {
2224 if (ConstantInt *C = dyn_cast<ConstantInt>(Start)) {
2226 ConstantInt *X;
2237 return isa<ConstantInt>(V) && !cast<ConstantInt>(V)->isZero();
2237 return isa<ConstantInt>(V) && !cast<ConstantInt>(V)->isZero();
2347 auto *Elt = dyn_cast_or_null<ConstantInt>(CV->getAggregateElement(i));
2347 auto *Elt = dyn_cast_or_null<ConstantInt>(CV->getAggregateElement(i));
2675 ConstantInt *CI = dyn_cast<ConstantInt>(V);
2675 ConstantInt *CI = dyn_cast<ConstantInt>(V);
2686 Constant *BaseVal = ConstantInt::get(T, Base);
2689 Multiple = ConstantInt::get(T, 1);
2694 Multiple = ConstantInt::get(T, CI->getZExtValue() / Base);
2718 ConstantInt *Op1CI = dyn_cast<ConstantInt>(Op1);
2718 ConstantInt *Op1CI = dyn_cast<ConstantInt>(Op1);
2725 Op1 = ConstantInt::get(V->getContext(), API);
2744 if (ConstantInt *Mul0CI = dyn_cast<ConstantInt>(Mul0))
2744 if (ConstantInt *Mul0CI = dyn_cast<ConstantInt>(Mul0))
2768 if (ConstantInt *Mul1CI = dyn_cast<ConstantInt>(Mul1))
2768 if (ConstantInt *Mul1CI = dyn_cast<ConstantInt>(Mul1))
3055 if (ConstantInt *Exponent = dyn_cast<ConstantInt>(I->getOperand(1))) {
3055 if (ConstantInt *Exponent = dyn_cast<ConstantInt>(I->getOperand(1))) {
3234 if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
3234 if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
3239 return ConstantInt::get(Ctx, CI->getValue().trunc(8));
3467 const ConstantInt *FirstIdx = dyn_cast<ConstantInt>(GEP->getOperand(1));
3467 const ConstantInt *FirstIdx = dyn_cast<ConstantInt>(GEP->getOperand(1));
3494 if (const ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(2)))
3494 if (const ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(2)))
3821 (!isa<ConstantInt>(U->getOperand(1)) &&
5252 const ConstantInt *C1,
5254 const ConstantInt *C2) {
5298 if (ALHS == BLHS && isa<ConstantInt>(ARHS) && isa<ConstantInt>(BRHS)) {
5298 if (ALHS == BLHS && isa<ConstantInt>(ARHS) && isa<ConstantInt>(BRHS)) {
5300 APred, cast<ConstantInt>(ARHS), BPred, cast<ConstantInt>(BRHS)))
5300 APred, cast<ConstantInt>(ARHS), BPred, cast<ConstantInt>(BRHS)))
5724 ConstantInt *OpC = dyn_cast<ConstantInt>(GEP->getOperand(i));
5724 ConstantInt *OpC = dyn_cast<ConstantInt>(GEP->getOperand(i));
lib/Analysis/VectorUtils.cpp 273 if (!isa<ConstantInt>(III->getOperand(2)))
275 unsigned IIElt = cast<ConstantInt>(III->getOperand(2))->getZExtValue();
lib/AsmParser/LLParser.cpp 3098 ID.ConstantVal = ConstantInt::getTrue(Context);
3102 ID.ConstantVal = ConstantInt::getFalse(Context);
5165 V = ConstantInt::get(Context, ID.APSIntVal);
5968 SmallVector<std::pair<ConstantInt*, BasicBlock*>, 32> Table;
5980 if (!isa<ConstantInt>(Constant))
5983 Table.push_back(std::make_pair(cast<ConstantInt>(Constant), DestBB));
lib/Bitcode/Reader/BitcodeReader.cpp 2387 V = ConstantInt::get(CurTy, decodeSignRotatedValue(Record[0]));
2395 V = ConstantInt::get(Context, VInt);
4380 SmallVector<ConstantInt*, 1> CaseVals;
4406 CaseVals.push_back(ConstantInt::get(Context, Low));
4408 CaseVals.push_back(ConstantInt::get(Context, Low));
4411 for (SmallVector<ConstantInt*, 1>::iterator cvi = CaseVals.begin(),
4432 ConstantInt *CaseVal =
4433 dyn_cast_or_null<ConstantInt>(getFnValueByID(Record[3+i*2], OpTy));
lib/Bitcode/Reader/MetadataLoader.cpp 1742 } else if (auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) {
1742 } else if (auto *CI = dyn_cast<ConstantInt>(CMD->getValue())) {
lib/Bitcode/Writer/BitcodeWriter.cpp 2345 } else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) {
2345 } else if (const ConstantInt *IV = dyn_cast<ConstantInt>(C)) {
3734 if (auto *MD =
3735 mdconst::extract_or_null<ConstantInt>(M.getModuleFlag("ThinLTO")))
lib/CodeGen/AsmPrinter/AsmPrinter.cpp 380 if (mdconst::extract_or_null<ConstantInt>(
2009 ConstantInt *Priority = dyn_cast<ConstantInt>(CS->getOperand(0));
2009 ConstantInt *Priority = dyn_cast<ConstantInt>(CS->getOperand(0));
2171 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV))
2171 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV))
2341 if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
2341 if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
2521 static void emitGlobalConstantLargeInt(const ConstantInt *CI, AsmPrinter &AP) {
2682 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
2682 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
lib/CodeGen/AsmPrinter/AsmPrinterInlineAsm.cpp 64 if (const ConstantInt *CI =
65 mdconst::dyn_extract<ConstantInt>(LocInfo->getOperand(ErrorLine)))
502 if (const ConstantInt *CI =
503 mdconst::dyn_extract<ConstantInt>(LocMD->getOperand(0))) {
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp 169 ConstantInt *GH = mdconst::extract_or_null<ConstantInt>(
169 ConstantInt *GH = mdconst::extract_or_null<ConstantInt>(
1577 if (auto *CI = Subrange->getCount().dyn_cast<ConstantInt*>())
1577 if (auto *CI = Subrange->getCount().dyn_cast<ConstantInt*>())
2380 if (const auto *CI =
2381 dyn_cast_or_null<ConstantInt>(Member->getStorageOffsetInBits())) {
lib/CodeGen/AsmPrinter/DebugLocEntry.h 36 const ConstantInt *CIP;
51 DbgValueLoc(const DIExpression *Expr, const ConstantInt *CIP)
66 const ConstantInt *getConstantInt() const { return Constant.CIP; }
lib/CodeGen/AsmPrinter/DwarfUnit.cpp 537 void DwarfUnit::addConstantValue(DIE &Die, const ConstantInt *CI,
922 if (const ConstantInt *CI =
923 dyn_cast_or_null<ConstantInt>(DDTy->getDiscriminantValue())) {
1053 if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1053 if (ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(Val))
1324 if (auto *CI = SR->getCount().dyn_cast<ConstantInt*>())
1324 if (auto *CI = SR->getCount().dyn_cast<ConstantInt*>())
1369 const auto CI = Subrange->getCount().get<ConstantInt *>();
1592 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
1592 if (const ConstantInt *CI = dyn_cast_or_null<ConstantInt>(DT->getConstant()))
lib/CodeGen/AsmPrinter/DwarfUnit.h 200 void addConstantValue(DIE &Die, const ConstantInt *CI, const DIType *Ty);
lib/CodeGen/AtomicExpandPass.cpp 677 ConstantInt::get(Ret.WordType, (1 << ValueSize * 8) - 1), Ret.ShiftAmt,
1041 StoreSuccess, ConstantInt::get(IntegerType::get(Ctx, 32), 0), "tryagain");
1210 StoreSuccess, ConstantInt::get(Type::getInt32Ty(Ctx), 0), "success");
1253 Success->addIncoming(ConstantInt::getTrue(Ctx), SuccessBB);
1254 Success->addIncoming(ConstantInt::getFalse(Ctx), FailureBB);
1317 auto C = dyn_cast<ConstantInt>(RMWI->getValOperand());
1628 ConstantInt *SizeVal64 = ConstantInt::get(Type::getInt64Ty(Ctx), Size);
1628 ConstantInt *SizeVal64 = ConstantInt::get(Type::getInt64Ty(Ctx), Size);
1631 ConstantInt::get(Type::getInt32Ty(Ctx), (int)toCABI(Ordering));
1636 ConstantInt::get(Type::getInt32Ty(Ctx), (int)toCABI(Ordering2));
1697 Args.push_back(ConstantInt::get(DL.getIntPtrType(Ctx), Size));
lib/CodeGen/CodeGenPrepare.cpp 918 auto Op = dyn_cast<ConstantInt>(GEP->getOperand(i));
1239 B = ConstantInt::get(B->getType(), 1);
1241 B = ConstantInt::get(B->getType(), -1);
1299 B = ConstantInt::get(B->getType(), 1);
1445 if (!isa<ConstantInt>(AndI->getOperand(0)) &&
1446 !isa<ConstantInt>(AndI->getOperand(1)) &&
1457 auto *CmpC = dyn_cast<ConstantInt>(User->getOperand(1));
1457 auto *CmpC = dyn_cast<ConstantInt>(User->getOperand(1));
1509 !isa<ConstantInt>(User->getOperand(1)))
1512 const APInt &Cimm = cast<ConstantInt>(User->getOperand(1))->getValue();
1522 SinkShiftAndTruncate(BinaryOperator *ShiftI, Instruction *User, ConstantInt *CI,
1611 static bool OptimizeExtractBits(BinaryOperator *ShiftI, ConstantInt *CI,
1865 Constant *RetVal = ConstantInt::getTrue(II->getContext());
2157 return ConstantInt::get(IntPtrTy, BaseOffs);
3513 ConstantInt *CI = nullptr; Value *AddLHS = nullptr;
3556 return isa<ConstantInt>(I->getOperand(1));
3751 const ConstantInt *Cst = dyn_cast<ConstantInt>(Inst->getOperand(1));
3751 const ConstantInt *Cst = dyn_cast<ConstantInt>(Inst->getOperand(1));
3775 const auto *Cst = dyn_cast<ConstantInt>(AndInst->getOperand(1));
3775 const auto *Cst = dyn_cast<ConstantInt>(AndInst->getOperand(1));
3956 if (const ConstantInt *Cst = dyn_cast<ConstantInt>(Opnd)) {
3956 if (const ConstantInt *Cst = dyn_cast<ConstantInt>(Opnd)) {
3961 TPT.setOperand(ExtOpnd, OpIdx, ConstantInt::get(Ext->getType(), CstVal));
4117 ConstantInt *RHS = dyn_cast<ConstantInt>(AddrInst->getOperand(1));
4117 ConstantInt *RHS = dyn_cast<ConstantInt>(AddrInst->getOperand(1));
4138 cast<ConstantInt>(AddrInst->getOperand(i))->getZExtValue();
4142 if (ConstantInt *CI = dyn_cast<ConstantInt>(AddrInst->getOperand(i))) {
4142 if (ConstantInt *CI = dyn_cast<ConstantInt>(AddrInst->getOperand(i))) {
4311 if (ConstantInt *CI = dyn_cast<ConstantInt>(Addr)) {
4311 if (ConstantInt *CI = dyn_cast<ConstantInt>(Addr)) {
4874 V = Builder.CreateMul(V, ConstantInt::get(IntPtrTy, AddrMode.Scale),
4884 Value *V = ConstantInt::get(IntPtrTy, AddrMode.BaseOffs);
4970 V = Builder.CreateMul(V, ConstantInt::get(IntPtrTy, AddrMode.Scale),
4989 Value *V = ConstantInt::get(IntPtrTy, AddrMode.BaseOffs);
5361 Value *BaseIndex = ConstantInt::get(IntPtrTy, BaseOffset);
5377 Value *Index = ConstantInt::get(IntPtrTy, Offset - BaseOffset);
5740 auto *AndC = dyn_cast<ConstantInt>(I->getOperand(1));
5740 auto *AndC = dyn_cast<ConstantInt>(I->getOperand(1));
5754 auto *ShlC = dyn_cast<ConstantInt>(I->getOperand(1));
5754 auto *ShlC = dyn_cast<ConstantInt>(I->getOperand(1));
5801 Builder.CreateAnd(Load, ConstantInt::get(Ctx, DemandBits)));
5815 if (cast<ConstantInt>(And->getOperand(1))->getValue() == DemandBits) {
6262 Case.setValue(ConstantInt::get(Context, WideConst));
6356 unsigned Index = isa<ConstantInt>(ValIdx)
6357 ? cast<ConstantInt>(ValIdx)->getZExtValue()
6385 bool IsArg0Constant = isa<UndefValue>(Arg0) || isa<ConstantInt>(Arg0) ||
6418 if (ConstantInt *CstVal = dyn_cast<ConstantInt>(ValExtractIdx))
6418 if (ConstantInt *CstVal = dyn_cast<ConstantInt>(ValExtractIdx))
6492 if (!isa<ConstantInt>(Val) && !isa<UndefValue>(Val) &&
6570 else if (isa<UndefValue>(Val) || isa<ConstantInt>(Val) ||
6744 ConstantInt::get(Type::getInt32Ty(SI.getContext()), 1));
6763 isa<ConstantInt>(GEP->getOperand(1));
6833 ConstantInt *GEPIIdx = cast<ConstantInt>(GEPI->getOperand(1));
6833 ConstantInt *GEPIIdx = cast<ConstantInt>(GEPI->getOperand(1));
6881 cast<ConstantInt>(UGEPI->getOperand(1))->getType())
6883 ConstantInt *UGEPIIdx = cast<ConstantInt>(UGEPI->getOperand(1));
6883 ConstantInt *UGEPIIdx = cast<ConstantInt>(UGEPI->getOperand(1));
6893 ConstantInt *UGEPIIdx = cast<ConstantInt>(UGEPI->getOperand(1));
6893 ConstantInt *UGEPIIdx = cast<ConstantInt>(UGEPI->getOperand(1));
6902 ConstantInt *UGEPIIdx = cast<ConstantInt>(UGEPI->getOperand(1));
6902 ConstantInt *UGEPIIdx = cast<ConstantInt>(UGEPI->getOperand(1));
6904 ConstantInt::get(GEPIIdx->getType(),
7019 ConstantInt *CI = dyn_cast<ConstantInt>(BinOp->getOperand(1));
7019 ConstantInt *CI = dyn_cast<ConstantInt>(BinOp->getOperand(1));
lib/CodeGen/ExpandMemCmp.cpp 269 ConstantInt::get(ByteType, OffsetBytes));
300 ConstantInt::get(Diff->getType(), 0));
398 Cmp = Builder.CreateICmpNE(OrList[0], ConstantInt::get(Diff->getType(), 0));
420 Value *Zero = ConstantInt::get(Type::getInt32Ty(CI->getContext()), 0);
491 Value *Zero = ConstantInt::get(Type::getInt32Ty(CI->getContext()), 0);
505 Value *Res = ConstantInt::get(Type::getInt32Ty(CI->getContext()), 1);
518 Builder.CreateSelect(Cmp, ConstantInt::get(Builder.getInt32Ty(), -1),
519 ConstantInt::get(Builder.getInt32Ty(), 1));
731 ConstantInt *SizeCast = dyn_cast<ConstantInt>(CI->getArgOperand(2));
731 ConstantInt *SizeCast = dyn_cast<ConstantInt>(CI->getArgOperand(2));
lib/CodeGen/GlobalISel/CSEMIRBuilder.cpp 205 const ConstantInt &Val) {
lib/CodeGen/GlobalISel/IRTranslator.cpp 229 ElementSize * cast<ConstantInt>(AI.getArraySize())->getZExtValue();
445 const ConstantInt *CaseVal = I.getCaseValue();
554 *ConstantInt::get(SValue.getType(), JTH.Last - JTH.First));
596 const APInt& Low = cast<ConstantInt>(CB.CmpLHS)->getValue();
597 const APInt& High = cast<ConstantInt>(CB.CmpRHS)->getValue();
600 if (cast<ConstantInt>(CB.CmpLHS)->isMinValue(true)) {
949 Indices.push_back(ConstantInt::get(Int32Ty, 0));
953 Indices.push_back(ConstantInt::get(Int32Ty, Idx));
956 Indices.push_back(ConstantInt::get(Int32Ty, Idx));
1075 if (const auto *CI = dyn_cast<ConstantInt>(Idx)) {
1075 if (const auto *CI = dyn_cast<ConstantInt>(Idx)) {
1133 cast<ConstantInt>(CI.getArgOperand(CI.getNumArgOperands() - 1))
1496 ConstantInt *Cst = cast<ConstantInt>(CI.getArgOperand(1));
1496 ConstantInt *Cst = cast<ConstantInt>(CI.getArgOperand(1));
1634 if (ConstantInt *CI = dyn_cast<ConstantInt>(Arg.value())) {
1634 if (ConstantInt *CI = dyn_cast<ConstantInt>(Arg.value())) {
1819 getOrCreateVReg(*ConstantInt::get(IntPtrIRTy, DL->getTypeAllocSize(Ty)));
1900 if (auto *CI = dyn_cast<ConstantInt>(U.getOperand(1))) {
1900 if (auto *CI = dyn_cast<ConstantInt>(U.getOperand(1))) {
1903 auto *NewIdxCI = ConstantInt::get(CI->getContext(), NewIdx);
1903 auto *NewIdxCI = ConstantInt::get(CI->getContext(), NewIdx);
2110 if (auto CI = dyn_cast<ConstantInt>(&C))
2121 auto *ZeroVal = ConstantInt::get(ZeroTy, 0);
2121 auto *ZeroVal = ConstantInt::get(ZeroTy, 0);
lib/CodeGen/GlobalISel/LegalizerHelper.cpp 1680 SrcMO.setCImm(ConstantInt::get(Ctx, Val));
lib/CodeGen/GlobalISel/MachineIRBuilder.cpp 147 if (auto *CI = dyn_cast<ConstantInt>(&C)) {
287 const ConstantInt &Val) {
310 ConstantInt *CI = ConstantInt::get(IntN, Val, true);
310 ConstantInt *CI = ConstantInt::get(IntN, Val, true);
341 ConstantInt *CI = ConstantInt::get(getMF().getFunction().getContext(), Val);
341 ConstantInt *CI = ConstantInt::get(getMF().getFunction().getContext(), Val);
lib/CodeGen/GlobalMerge.cpp 535 ConstantInt::get(Int32Ty, 0),
536 ConstantInt::get(Int32Ty, StructIdxs[idx]),
lib/CodeGen/HardwareLoops.cpp 222 ConstantInt::get(HWLoopInfo.CountType, LoopDecrement);
302 if (auto *Const = dyn_cast<ConstantInt>(ICmp->getOperand(OpIdx)))
302 if (auto *Const = dyn_cast<ConstantInt>(ICmp->getOperand(OpIdx)))
444 CondBuilder.CreateICmpNE(EltsRem, ConstantInt::get(EltsRem->getType(), 0));
lib/CodeGen/IndirectBrExpandPass.cpp 148 ConstantInt *BBIndexC = ConstantInt::get(ITy, BBIndex);
148 ConstantInt *BBIndexC = ConstantInt::get(ITy, BBIndex);
215 SI->addCase(ConstantInt::get(CommonITy, i + 1), BBs[i]);
lib/CodeGen/InterleavedAccessPass.cpp 294 if (Extract && isa<ConstantInt>(Extract->getIndexOperand())) {
367 auto *IndexOperand = cast<ConstantInt>(Extract->getIndexOperand());
367 auto *IndexOperand = cast<ConstantInt>(Extract->getIndexOperand());
lib/CodeGen/InterleavedLoadCombinePass.cpp 888 ConstantInt::get(Type::getInt32Ty(LI->getContext()), 0),
889 ConstantInt::get(Type::getInt32Ty(LI->getContext()), i),
907 ConstantInt *C = dyn_cast<ConstantInt>(RHS);
907 ConstantInt *C = dyn_cast<ConstantInt>(RHS);
909 C = dyn_cast<ConstantInt>(LHS);
999 ConstantInt *IDX = dyn_cast<ConstantInt>(GEP.getOperand(idxOperand));
999 ConstantInt *IDX = dyn_cast<ConstantInt>(GEP.getOperand(idxOperand));
lib/CodeGen/IntrinsicLowering.cpp 72 Value *Tmp1 = Builder.CreateShl(V, ConstantInt::get(V->getType(), 8),
74 Value *Tmp2 = Builder.CreateLShr(V, ConstantInt::get(V->getType(), 8),
80 Value *Tmp4 = Builder.CreateShl(V, ConstantInt::get(V->getType(), 24),
82 Value *Tmp3 = Builder.CreateShl(V, ConstantInt::get(V->getType(), 8),
84 Value *Tmp2 = Builder.CreateLShr(V, ConstantInt::get(V->getType(), 8),
86 Value *Tmp1 = Builder.CreateLShr(V,ConstantInt::get(V->getType(), 24),
89 ConstantInt::get(V->getType(), 0xFF0000),
92 ConstantInt::get(V->getType(), 0xFF00),
100 Value *Tmp8 = Builder.CreateShl(V, ConstantInt::get(V->getType(), 56),
102 Value *Tmp7 = Builder.CreateShl(V, ConstantInt::get(V->getType(), 40),
104 Value *Tmp6 = Builder.CreateShl(V, ConstantInt::get(V->getType(), 24),
106 Value *Tmp5 = Builder.CreateShl(V, ConstantInt::get(V->getType(), 8),
108 Value* Tmp4 = Builder.CreateLShr(V, ConstantInt::get(V->getType(), 8),
111 ConstantInt::get(V->getType(), 24),
114 ConstantInt::get(V->getType(), 40),
117 ConstantInt::get(V->getType(), 56),
120 ConstantInt::get(V->getType(),
124 ConstantInt::get(V->getType(),
128 ConstantInt::get(V->getType(),
132 ConstantInt::get(V->getType(),
136 ConstantInt::get(V->getType(),
140 ConstantInt::get(V->getType(),
170 Value *Count = ConstantInt::get(V->getType(), 0);
176 Value *MaskCst = ConstantInt::get(V->getType(), MaskValues[ct]);
179 ConstantInt::get(V->getType(), i),
186 V = Builder.CreateLShr(V, ConstantInt::get(V->getType(), 64),
202 Value *ShVal = ConstantInt::get(V->getType(), i);
302 Value *SrcM1 = ConstantInt::get(Src->getType(), 1);
326 CI->replaceAllUsesWith(ConstantInt::get(CI->getType(), 0));
351 CI->replaceAllUsesWith(ConstantInt::get(Type::getInt64Ty(Context), 0));
361 CI->replaceAllUsesWith(ConstantInt::get(CI->getType(), 1));
470 CI->replaceAllUsesWith(ConstantInt::get(CI->getType(), 1));
lib/CodeGen/LiveDebugValues.cpp 219 const ConstantInt *CImm;
lib/CodeGen/LowerEmuTLS.cpp 100 const ConstantInt *InitIntValue = dyn_cast<ConstantInt>(InitValue);
100 const ConstantInt *InitIntValue = dyn_cast<ConstantInt>(InitValue);
151 ConstantInt::get(WordType, DL.getTypeStoreSize(GVType)),
152 ConstantInt::get(WordType, GVAlignment),
lib/CodeGen/MIRParser/MIParser.cpp 1614 Dest = MachineOperand::CreateCImm(cast<ConstantInt>(C));
2314 ShufMask.push_back(ConstantInt::get(I32Ty, Int.getExtValue()));
lib/CodeGen/MachineInstr.cpp 1999 if (const ConstantInt *CI =
2000 mdconst::dyn_extract<ConstantInt>(LocMD->getOperand(0))) {
lib/CodeGen/MachinePipeliner.cpp 297 mdconst::extract<ConstantInt>(MD->getOperand(1))->getZExtValue();
lib/CodeGen/MachineVerifier.cpp 989 const ConstantInt *CI = MI->getOperand(1).getCImm();
lib/CodeGen/SafeStack.cpp 222 auto C = dyn_cast<ConstantInt>(AI->getArraySize());
270 const auto *Len = dyn_cast<ConstantInt>(MI->getLength());
270 const auto *Len = dyn_cast<ConstantInt>(MI->getLength());
545 ConstantInt::get(IntPtrTy, ~uint64_t(FrameAlignment - 1))),
554 ConstantInt::get(Int32Ty, -Offset));
573 ConstantInt::get(Int32Ty, -Offset));
609 ConstantInt::get(Int32Ty, -Offset));
632 IRB.CreateGEP(Int8Ty, BasePointer, ConstantInt::get(Int32Ty, -FrameSize),
653 Value *Size = IRB.CreateMul(ArraySize, ConstantInt::get(IntPtrTy, TySize));
666 IRB.CreateAnd(SP, ConstantInt::get(IntPtrTy, ~uint64_t(Align - 1))),
lib/CodeGen/ScalarizeMaskedMemIntrin.cpp 87 if (!CElt || !isa<ConstantInt>(CElt))
132 unsigned AlignVal = cast<ConstantInt>(Alignment)->getZExtValue();
270 unsigned AlignVal = cast<ConstantInt>(Alignment)->getZExtValue();
402 unsigned AlignVal = cast<ConstantInt>(Alignment)->getZExtValue();
531 unsigned AlignVal = cast<ConstantInt>(Alignment)->getZExtValue();
857 cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
865 cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue();
lib/CodeGen/SelectionDAG/FastISel.cpp 405 if (const auto *CI = dyn_cast<ConstantInt>(V)) {
405 if (const auto *CI = dyn_cast<ConstantInt>(V)) {
432 getRegForValue(ConstantInt::get(V->getContext(), SIntVal));
606 if (const auto *CI = dyn_cast<ConstantInt>(I->getOperand(0)))
606 if (const auto *CI = dyn_cast<ConstantInt>(I->getOperand(0)))
630 if (const auto *CI = dyn_cast<ConstantInt>(I->getOperand(1))) {
630 if (const auto *CI = dyn_cast<ConstantInt>(I->getOperand(1))) {
691 uint64_t Field = cast<ConstantInt>(Idx)->getZExtValue();
707 if (const auto *CI = dyn_cast<ConstantInt>(Idx)) {
707 if (const auto *CI = dyn_cast<ConstantInt>(Idx)) {
765 if (const auto *C = dyn_cast<ConstantInt>(Val)) {
765 if (const auto *C = dyn_cast<ConstantInt>(Val)) {
811 const auto *ID = cast<ConstantInt>(I->getOperand(PatchPointOpers::IDPos));
811 const auto *ID = cast<ConstantInt>(I->getOperand(PatchPointOpers::IDPos));
816 const auto *NumBytes =
817 cast<ConstantInt>(I->getOperand(PatchPointOpers::NBytesPos));
918 const auto *NumArgsVal =
919 cast<ConstantInt>(I->getOperand(PatchPointOpers::NArgPos));
950 const auto *ID = cast<ConstantInt>(I->getOperand(PatchPointOpers::IDPos));
950 const auto *ID = cast<ConstantInt>(I->getOperand(PatchPointOpers::IDPos));
955 const auto *NumBytes =
956 cast<ConstantInt>(I->getOperand(PatchPointOpers::NBytesPos));
962 cast<ConstantInt>(C->getOperand(0))->getZExtValue();
967 cast<ConstantInt>(C->getOperand(0))->getZExtValue();
1416 } else if (const auto *CI = dyn_cast<ConstantInt>(V)) {
1416 } else if (const auto *CI = dyn_cast<ConstantInt>(V)) {
2002 MaterialReg = getRegForValue(ConstantInt::get(ITy, Imm));
2385 return isa<ConstantInt>(cast<AddOperator>(Add)->getOperand(1));
lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp 146 const ConstantInt *CUI = cast<ConstantInt>(AI->getArraySize());
146 const ConstantInt *CUI = cast<ConstantInt>(AI->getArraySize());
440 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
440 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
473 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
473 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
lib/CodeGen/SelectionDAG/InstrEmitter.cpp 732 if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
732 if (const ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp 1951 const ConstantInt *CI = V->getConstantIntValue();
1952 CV.push_back(ConstantInt::get(EltVT.getTypeForEVT(*DAG.getContext()),
2427 Constant *FudgeFactor = ConstantInt::get(
lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp 4024 DAG.getConstantPool(ConstantInt::get(*DAG.getContext(), FF.zext(64)),
lib/CodeGen/SelectionDAG/SelectionDAG.cpp 1194 return getConstant(*ConstantInt::get(*Context, Val), DL, VT, isT, isO);
1197 SDValue SelectionDAG::getConstant(const ConstantInt &Val, const SDLoc &DL,
1202 const ConstantInt *Elt = &Val;
1212 Elt = ConstantInt::get(*getContext(), NewVal);
2943 if (auto *CInt = dyn_cast<ConstantInt>(Elt)) {
2943 if (auto *CInt = dyn_cast<ConstantInt>(Elt)) {
2961 if (auto *CInt = dyn_cast<ConstantInt>(Cst)) {
3912 if (auto *CInt = dyn_cast<ConstantInt>(Elt)) {
3912 if (auto *CInt = dyn_cast<ConstantInt>(Elt)) {
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 1273 if (isa<ConstantInt>(V) || isa<ConstantFP>(V) || isa<UndefValue>(V) ||
1446 if (const ConstantInt *CI = dyn_cast<ConstantInt>(C))
1446 if (const ConstantInt *CI = dyn_cast<ConstantInt>(C))
2064 CaseBlock CB(Opc, Cond, ConstantInt::getTrue(*DAG.getContext()),
2300 CaseBlock CB(ISD::SETEQ, CondVal, ConstantInt::getTrue(*DAG.getContext()),
2334 if (CB.CmpRHS == ConstantInt::getTrue(*DAG.getContext()) &&
2337 else if (CB.CmpRHS == ConstantInt::getFalse(*DAG.getContext()) &&
2356 const APInt& Low = cast<ConstantInt>(CB.CmpLHS)->getValue();
2357 const APInt& High = cast<ConstantInt>(CB.CmpRHS)->getValue();
2362 if (cast<ConstantInt>(CB.CmpLHS)->isMinValue(true)) {
3090 const ConstantInt *Val = dyn_cast<ConstantInt>(U->getOperand(1));
3090 const ConstantInt *Val = dyn_cast<ConstantInt>(U->getOperand(1));
3496 else if(ConstantInt *C = dyn_cast<ConstantInt>(I.getOperand(0)))
3496 else if(ConstantInt *C = dyn_cast<ConstantInt>(I.getOperand(0)))
3885 if (const auto *CI = dyn_cast_or_null<ConstantInt>(C)) {
3885 if (const auto *CI = dyn_cast_or_null<ConstantInt>(C)) {
4274 Alignment = cast<ConstantInt>(I.getArgOperand(2))->getZExtValue();
4358 auto *CI = dyn_cast_or_null<ConstantInt>(C);
4358 auto *CI = dyn_cast_or_null<ConstantInt>(C);
4392 unsigned Alignment = (cast<ConstantInt>(I.getArgOperand(2)))->getZExtValue();
4433 Alignment = cast<ConstantInt>(I.getArgOperand(1))->getZExtValue();
4500 unsigned Alignment = (cast<ConstantInt>(I.getArgOperand(1)))->getZExtValue();
4803 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Arg)) {
4803 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Arg)) {
5947 ConstantInt *CI = dyn_cast<ConstantInt>(I.getArgOperand(0));
5947 ConstantInt *CI = dyn_cast<ConstantInt>(I.getArgOperand(0));
6204 ConstantInt *CI = cast<ConstantInt>(I.getArgOperand(1));
6204 ConstantInt *CI = cast<ConstantInt>(I.getArgOperand(1));
6212 ConstantInt *CI = cast<ConstantInt>(I.getArgOperand(1));
6212 ConstantInt *CI = cast<ConstantInt>(I.getArgOperand(1));
6545 unsigned rw = cast<ConstantInt>(I.getArgOperand(1))->getZExtValue();
6574 cast<ConstantInt>(I.getArgOperand(0))->getSExtValue();
6672 auto *Idx = cast<ConstantInt>(I.getArgOperand(2));
6672 auto *Idx = cast<ConstantInt>(I.getArgOperand(2));
7263 const ConstantInt *CSize = dyn_cast<ConstantInt>(Size);
7263 const ConstantInt *CSize = dyn_cast<ConstantInt>(Size);
7850 if (isa<ConstantFP>(OpVal) || isa<ConstantInt>(OpVal) ||
10374 const ConstantInt *Pivot = PivotCluster->Low;
10501 const ConstantInt *CaseVal = I.getCaseValue();
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp 1212 int Index = cast<ConstantInt>(IndexArg)->getZExtValue();
3238 const ConstantInt *Val=cast<ConstantSDNode>(Imm)->getConstantIntValue();
lib/CodeGen/SelectionDAG/TargetLowering.cpp 4420 if (isa<ConstantInt>(CallOperandVal))
4543 if (isa<BasicBlock>(v) || isa<ConstantInt>(v) || isa<Function>(v)) {
lib/CodeGen/ShadowStackGCLowering.cpp 119 ConstantInt::get(Int32Ty, Roots.size(), false),
120 ConstantInt::get(Int32Ty, NumMeta, false),
150 ConstantInt::get(Type::getInt32Ty(F.getContext()), 0),
151 ConstantInt::get(Type::getInt32Ty(F.getContext()), 0)};
260 Value *Indices[] = {ConstantInt::get(Type::getInt32Ty(Context), 0),
261 ConstantInt::get(Type::getInt32Ty(Context), Idx),
262 ConstantInt::get(Type::getInt32Ty(Context), Idx2)};
273 Value *Indices[] = {ConstantInt::get(Type::getInt32Ty(Context), 0),
274 ConstantInt::get(Type::getInt32Ty(Context), Idx)};
lib/CodeGen/SjLjEHPrepare.cpp 107 Value *Zero = ConstantInt::get(Int32Ty, 0);
108 Value *One = ConstantInt::get(Int32Ty, 1);
114 ConstantInt *CallSiteNoC =
115 ConstantInt::get(Type::getInt32Ty(I->getContext()), Number);
246 Value *TrueValue = ConstantInt::getTrue(F.getContext());
419 ConstantInt *CallSiteNum =
420 ConstantInt::get(Type::getInt32Ty(F.getContext()), I + 1);
lib/CodeGen/StackProtector.cpp 287 if (const auto *CI = dyn_cast<ConstantInt>(AI->getArraySize())) {
287 if (const auto *CI = dyn_cast<ConstantInt>(AI->getArraySize())) {
lib/CodeGen/SwitchLoweringUtils.cpp 474 const ConstantInt *CaseVal = CC.Low;
lib/CodeGen/TargetLoweringObjectFileImpl.cpp 77 Version = mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
83 Flags |= mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
1616 } else if (const auto *CI = dyn_cast<ConstantInt>(C)) {
1616 } else if (const auto *CI = dyn_cast<ConstantInt>(C)) {
lib/CodeGen/WinEHPrepare.cpp 153 HT.Adjectives = cast<ConstantInt>(CPI->getArgOperand(1))->getZExtValue();
559 cast<ConstantInt>(Catch->getArgOperand(0))->getZExtValue());
lib/ExecutionEngine/ExecutionEngine.cpp 902 Result.IntVal = cast<ConstantInt>(C)->getValue();
992 Result.AggregateVal[i].IntVal = cast<ConstantInt>(
lib/ExecutionEngine/Interpreter/Execution.cpp 1058 const ConstantInt *CPU = cast<ConstantInt>(I.getOperand());
1058 const ConstantInt *CPU = cast<ConstantInt>(I.getOperand());
lib/ExecutionEngine/Orc/ExecutionUtils.cpp 71 auto *Priority = cast<ConstantInt>(CS->getOperand(0));
71 auto *Priority = cast<ConstantInt>(CS->getOperand(0));
lib/ExecutionEngine/Orc/IndirectionUtils.cpp 221 ConstantInt::get(Type::getInt64Ty(FT.getContext()), Addr);
lib/ExecutionEngine/Orc/Speculation.cpp 97 ConstantInt::get(LoadValueTy, 0),
117 Mutator.CreateICmpEQ(LoadGuard, ConstantInt::get(LoadValueTy, 0),
126 Mutator.CreateStore(ConstantInt::get(LoadValueTy, 1),
lib/FuzzMutate/OpDescriptor.cpp 18 Cs.push_back(ConstantInt::get(IntTy, APInt::getMaxValue(W)));
19 Cs.push_back(ConstantInt::get(IntTy, APInt::getMinValue(W)));
20 Cs.push_back(ConstantInt::get(IntTy, APInt::getSignedMaxValue(W)));
21 Cs.push_back(ConstantInt::get(IntTy, APInt::getSignedMinValue(W)));
22 Cs.push_back(ConstantInt::get(IntTy, APInt::getOneBitSet(W, W / 2)));
lib/FuzzMutate/Operations.cpp 191 if (auto *CI = dyn_cast<ConstantInt>(V))
201 Result.push_back(ConstantInt::get(Int32Ty, 0));
203 Result.push_back(ConstantInt::get(Int32Ty, N - 1));
205 Result.push_back(ConstantInt::get(Int32Ty, N / 2));
214 unsigned Idx = cast<ConstantInt>(Srcs[1])->getZExtValue();
248 if (auto *CI = dyn_cast<ConstantInt>(V))
260 Result.push_back(ConstantInt::get(Int32Ty, I));
269 unsigned Idx = cast<ConstantInt>(Srcs[2])->getZExtValue();
lib/IR/AbstractCallSite.cpp 87 cast<ConstantInt>(CBCalleeIdxAsCM->getValue())->getZExtValue();
112 int64_t Idx = cast<ConstantInt>(OpAsCM->getValue())->getSExtValue();
lib/IR/AsmWriter.cpp 1293 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
1293 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
1804 if (auto *CE = N->getCount().dyn_cast<ConstantInt*>())
1804 if (auto *CE = N->getCount().dyn_cast<ConstantInt*>())
lib/IR/AutoUpgrade.cpp 989 unsigned ShiftVal = cast<llvm::ConstantInt>(Shift)->getZExtValue();
1288 Constant *ShiftAmt = ConstantInt::get(Ty, 32);
1295 Constant *Mask = ConstantInt::get(Ty, 0xffffffff);
1672 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(C), 1)));
1699 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(C), 1)));
1807 (!isa<ConstantInt>(CI->getArgOperand(3)) ||
1808 cast<ConstantInt>(CI->getArgOperand(3))->getZExtValue() != 4)) {
1899 C = ConstantInt::getAllOnesValue(Builder.getInt16Ty());
1901 C = ConstantInt::getNullValue(Builder.getInt16Ty());
1910 ConstantInt::get(I32Ty, 0));
1912 ConstantInt::get(I32Ty, 0));
1923 ConstantInt::get(I32Ty, 0));
1998 unsigned Imm = cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue();
2001 unsigned Imm = cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue();
2100 (!isa<ConstantInt>(CI->getArgOperand(3)) ||
2101 cast<ConstantInt>(CI->getArgOperand(3))->getZExtValue() != 4)) {
2179 Imm = cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue();
2245 ConstantInt::get(I32Ty, I));
2296 unsigned Imm = cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue();
2380 unsigned Shift = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
2386 unsigned Shift = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
2393 unsigned Shift = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
2399 unsigned Shift = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
2408 unsigned Imm = cast <ConstantInt>(CI->getArgOperand(2))->getZExtValue();
2422 unsigned Imm = cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue();
2466 unsigned Imm = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
2490 unsigned Imm = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
2513 uint8_t Imm = cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue();
2544 unsigned Imm = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
2566 unsigned Imm = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
2585 unsigned Imm = cast<ConstantInt>(CI->getArgOperand(1))->getZExtValue();
2604 unsigned Imm = cast<ConstantInt>(CI->getArgOperand(2))->getZExtValue();
3025 C, ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(C), 1)));
3110 if (!isa<ConstantInt>(CI->getArgOperand(4)) ||
3111 cast<ConstantInt>(CI->getArgOperand(4))->getZExtValue() != 4) {
3167 (!isa<ConstantInt>(CI->getArgOperand(4)) ||
3168 cast<ConstantInt>(CI->getArgOperand(4))->getZExtValue() != 4)) {
3222 (!isa<ConstantInt>(CI->getArgOperand(4)) ||
3223 cast<ConstantInt>(CI->getArgOperand(4))->getZExtValue() != 4)) {
3706 const ConstantInt *Align = cast<ConstantInt>(CI->getArgOperand(3));
3706 const ConstantInt *Align = cast<ConstantInt>(CI->getArgOperand(3));
4000 if (auto *Behavior =
4001 mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(0))) {
4005 ConstantAsMetadata::get(ConstantInt::get(Int32Ty, Module::Max)),
lib/IR/BasicBlock.cpp 73 ConstantInt::get(llvm::Type::getInt32Ty(getContext()), 1);
485 auto *CI = mdconst::extract<ConstantInt>(MDIrrLoopHeader->getOperand(1));
485 auto *CI = mdconst::extract<ConstantInt>(MDIrrLoopHeader->getOperand(1));
lib/IR/ConstantFold.cpp 63 ConstantExpr::getExtractElement(CV, ConstantInt::get(Ty, i));
155 if (isa<ConstantInt>(V) || isa<ConstantFP>(V))
165 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
165 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
196 return ConstantInt::get(FP->getContext(),
223 if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
223 if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
228 return ConstantInt::get(CI->getContext(), V);
244 if (ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS))
244 if (ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS))
268 ConstantInt *Amt = dyn_cast<ConstantInt>(CE->getOperand(1));
268 ConstantInt *Amt = dyn_cast<ConstantInt>(CE->getOperand(1));
291 ConstantInt *Amt = dyn_cast<ConstantInt>(CE->getOperand(1));
291 ConstantInt *Amt = dyn_cast<ConstantInt>(CE->getOperand(1));
338 ConstantInt::get(Res->getType(), ByteStart*8));
355 Constant *N = ConstantInt::get(DestTy, ATy->getNumElements());
377 Constant *N = ConstantInt::get(DestTy, NumElems);
423 return ConstantInt::get(DestTy, 1);
431 return ConstantInt::get(DestTy, 1);
581 ConstantExpr::getExtractElement(V, ConstantInt::get(Ty, i));
621 return ConstantInt::get(FPC->getContext(), IntVal);
631 return ConstantInt::get(DestTy, 0);
652 bool isOne = isa<ConstantInt>(Idx) && cast<ConstantInt>(Idx)->isOne();
652 bool isOne = isa<ConstantInt>(Idx) && cast<ConstantInt>(Idx)->isOne();
664 ConstantInt *CI = cast<ConstantInt>(CE->getOperand(2));
664 ConstantInt *CI = cast<ConstantInt>(CE->getOperand(2));
683 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
683 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
693 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
693 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
695 return ConstantInt::get(V->getContext(),
700 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
700 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
702 return ConstantInt::get(V->getContext(),
711 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
711 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
712 return ConstantInt::get(V->getContext(),
746 ConstantInt::get(Ty, i));
748 ConstantInt::get(Ty, i));
755 if (!isa<ConstantInt>(Cond)) break;
795 auto *CIdx = dyn_cast<ConstantInt>(Idx);
795 auto *CIdx = dyn_cast<ConstantInt>(Idx);
833 ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx);
833 ConstantInt *CIdx = dyn_cast<ConstantInt>(Idx);
850 Constant *C = ConstantExpr::getExtractElement(Val, ConstantInt::get(Ty, i));
887 ConstantInt::get(Ty, Elt - SrcNumElts));
890 InElt = ConstantExpr::getExtractElement(V1, ConstantInt::get(Ty, Elt));
974 Constant *ExtractIdx = ConstantInt::get(Ty, i);
1100 if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
1100 if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
1213 } else if (isa<ConstantInt>(C1)) {
1219 if (ConstantInt *CI1 = dyn_cast<ConstantInt>(C1)) {
1219 if (ConstantInt *CI1 = dyn_cast<ConstantInt>(C1)) {
1220 if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
1220 if (ConstantInt *CI2 = dyn_cast<ConstantInt>(C2)) {
1227 return ConstantInt::get(CI1->getContext(), C1V + C2V);
1229 return ConstantInt::get(CI1->getContext(), C1V - C2V);
1231 return ConstantInt::get(CI1->getContext(), C1V * C2V);
1234 return ConstantInt::get(CI1->getContext(), C1V.udiv(C2V));
1239 return ConstantInt::get(CI1->getContext(), C1V.sdiv(C2V));
1242 return ConstantInt::get(CI1->getContext(), C1V.urem(C2V));
1247 return ConstantInt::get(CI1->getContext(), C1V.srem(C2V));
1249 return ConstantInt::get(CI1->getContext(), C1V & C2V);
1251 return ConstantInt::get(CI1->getContext(), C1V | C2V);
1253 return ConstantInt::get(CI1->getContext(), C1V ^ C2V);
1256 return ConstantInt::get(CI1->getContext(), C1V.shl(C2V));
1260 return ConstantInt::get(CI1->getContext(), C1V.lshr(C2V));
1264 return ConstantInt::get(CI1->getContext(), C1V.ashr(C2V));
1312 Constant *ExtractIdx = ConstantInt::get(Ty, i);
1368 return ConstantInt::getFalse(C1->getContext());
1407 if (!isa<ConstantInt>(C1) || !isa<ConstantInt>(C2))
1407 if (!isa<ConstantInt>(C1) || !isa<ConstantInt>(C2))
1411 if (cast<ConstantInt>(C1)->getValue().getActiveBits() > 64 ||
1412 cast<ConstantInt>(C2)->getValue().getActiveBits() > 64)
1417 int64_t C1Val = cast<ConstantInt>(C1)->getSExtValue();
1418 int64_t C2Val = cast<ConstantInt>(C2)->getSExtValue();
1457 ConstantInt *R = nullptr;
1458 R = dyn_cast<ConstantInt>(
1462 R = dyn_cast<ConstantInt>(
1466 R = dyn_cast<ConstantInt>(
1547 ConstantInt *R = nullptr;
1549 R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
1553 R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
1557 R = dyn_cast<ConstantInt>(ConstantExpr::getICmp(pred, V1, V2));
1758 if (isa<ConstantInt>(CE1->getOperand(i)))
1766 if (isa<ConstantInt>(CE2->getOperand(i)))
1814 return ConstantInt::get(ResultTy, CmpInst::isTrueWhenEqual(Predicate));
1818 return ConstantInt::get(ResultTy, CmpInst::isUnordered(Predicate));
1829 return ConstantInt::getFalse(C1->getContext());
1831 return ConstantInt::getTrue(C1->getContext());
1841 return ConstantInt::getFalse(C1->getContext());
1843 return ConstantInt::getTrue(C1->getContext());
1851 if (isa<ConstantInt>(C2))
1861 if (isa<ConstantInt>(C1) && isa<ConstantInt>(C2)) {
1861 if (isa<ConstantInt>(C1) && isa<ConstantInt>(C2)) {
1862 const APInt &V1 = cast<ConstantInt>(C1)->getValue();
1863 const APInt &V2 = cast<ConstantInt>(C2)->getValue();
1866 case ICmpInst::ICMP_EQ: return ConstantInt::get(ResultTy, V1 == V2);
1867 case ICmpInst::ICMP_NE: return ConstantInt::get(ResultTy, V1 != V2);
1868 case ICmpInst::ICMP_SLT: return ConstantInt::get(ResultTy, V1.slt(V2));
1869 case ICmpInst::ICMP_SGT: return ConstantInt::get(ResultTy, V1.sgt(V2));
1870 case ICmpInst::ICMP_SLE: return ConstantInt::get(ResultTy, V1.sle(V2));
1871 case ICmpInst::ICMP_SGE: return ConstantInt::get(ResultTy, V1.sge(V2));
1872 case ICmpInst::ICMP_ULT: return ConstantInt::get(ResultTy, V1.ult(V2));
1873 case ICmpInst::ICMP_UGT: return ConstantInt::get(ResultTy, V1.ugt(V2));
1874 case ICmpInst::ICMP_ULE: return ConstantInt::get(ResultTy, V1.ule(V2));
1875 case ICmpInst::ICMP_UGE: return ConstantInt::get(ResultTy, V1.uge(V2));
1886 return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered);
1888 return ConstantInt::get(ResultTy, R!=APFloat::cmpUnordered);
1890 return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered ||
1893 return ConstantInt::get(ResultTy, R==APFloat::cmpEqual);
1895 return ConstantInt::get(ResultTy, R!=APFloat::cmpEqual);
1897 return ConstantInt::get(ResultTy, R==APFloat::cmpLessThan ||
1900 return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered ||
1903 return ConstantInt::get(ResultTy, R==APFloat::cmpLessThan);
1905 return ConstantInt::get(ResultTy, R==APFloat::cmpUnordered ||
1908 return ConstantInt::get(ResultTy, R==APFloat::cmpGreaterThan);
1910 return ConstantInt::get(ResultTy, R!=APFloat::cmpGreaterThan);
1912 return ConstantInt::get(ResultTy, R==APFloat::cmpLessThan ||
1915 return ConstantInt::get(ResultTy, R!=APFloat::cmpLessThan);
1917 return ConstantInt::get(ResultTy, R==APFloat::cmpGreaterThan ||
1928 ConstantExpr::getExtractElement(C1, ConstantInt::get(Ty, i));
1930 ConstantExpr::getExtractElement(C2, ConstantInt::get(Ty, i));
2003 return ConstantInt::get(ResultTy, Result);
2074 return ConstantInt::get(ResultTy, Result);
2131 if (auto *CI = dyn_cast<ConstantInt>(Idxs[0])) {
2131 if (auto *CI = dyn_cast<ConstantInt>(Idxs[0])) {
2136 CI = dyn_cast_or_null<ConstantInt>(CV->getSplatValue());
2149 const ConstantInt *CI) {
2248 if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx0))
2248 if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx0))
2336 !isa<ConstantInt>(Idxs[0]) && !isa<ConstantDataVector>(Idxs[0]);
2339 if (!isa<ConstantInt>(Idxs[i]) && !isa<ConstantDataVector>(Idxs[i])) {
2344 if (!isa<ConstantInt>(Idxs[i - 1]) && !isa<ConstantDataVector>(Idxs[i - 1]))
2363 if (ConstantInt *CI = dyn_cast<ConstantInt>(Idxs[i])) {
2363 if (ConstantInt *CI = dyn_cast<ConstantInt>(Idxs[i])) {
2376 auto *CI = cast<ConstantInt>(CV->getElementAsConstant(I));
2376 auto *CI = cast<ConstantInt>(CV->getElementAsConstant(I));
2418 ConstantInt::get(CurrIdx->getType()->getScalarType(), NumElements);
lib/IR/ConstantRange.cpp 1499 auto *FirstLow = mdconst::extract<ConstantInt>(Ranges.getOperand(0));
1499 auto *FirstLow = mdconst::extract<ConstantInt>(Ranges.getOperand(0));
1500 auto *FirstHigh = mdconst::extract<ConstantInt>(Ranges.getOperand(1));
1500 auto *FirstHigh = mdconst::extract<ConstantInt>(Ranges.getOperand(1));
1505 auto *Low = mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 0));
1505 auto *Low = mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 0));
1506 auto *High = mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 1));
1506 auto *High = mdconst::extract<ConstantInt>(Ranges.getOperand(2 * i + 1));
lib/IR/Constants.cpp 87 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
87 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
102 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
102 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
128 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
128 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
154 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
154 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
180 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
180 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
292 return ConstantInt::get(Ty, 0);
330 Constant *C = ConstantInt::get(Ty->getContext(), V);
345 return ConstantInt::get(Ty->getContext(),
377 if (ConstantInt *CI = dyn_cast<ConstantInt>(Elt)) {
377 if (ConstantInt *CI = dyn_cast<ConstantInt>(Elt)) {
451 if (!isa<ConstantInt>(CE->getOperand(1)) ||CE->getOperand(1)->isNullValue())
609 ConstantInt *ConstantInt::getTrue(LLVMContext &Context) {
612 pImpl->TheTrueVal = ConstantInt::get(Type::getInt1Ty(Context), 1);
616 ConstantInt *ConstantInt::getFalse(LLVMContext &Context) {
619 pImpl->TheFalseVal = ConstantInt::get(Type::getInt1Ty(Context), 0);
625 ConstantInt *TrueC = ConstantInt::getTrue(Ty->getContext());
625 ConstantInt *TrueC = ConstantInt::getTrue(Ty->getContext());
633 ConstantInt *FalseC = ConstantInt::getFalse(Ty->getContext());
633 ConstantInt *FalseC = ConstantInt::getFalse(Ty->getContext());
640 ConstantInt *ConstantInt::get(LLVMContext &Context, const APInt &V) {
643 std::unique_ptr<ConstantInt> &Slot = pImpl->IntConstants[V];
647 Slot.reset(new ConstantInt(ITy, V));
663 ConstantInt *ConstantInt::get(IntegerType *Ty, uint64_t V, bool isSigned) {
667 ConstantInt *ConstantInt::getSigned(IntegerType *Ty, int64_t V) {
676 ConstantInt *C = get(Ty->getContext(), V);
687 ConstantInt *ConstantInt::get(IntegerType* Ty, StringRef Str, uint8_t radix) {
879 return getStructElement(cast<ConstantInt>(C)->getZExtValue());
912 return getStructElement(cast<ConstantInt>(C)->getZExtValue());
946 if (auto *CI = dyn_cast<ConstantInt>(C))
946 if (auto *CI = dyn_cast<ConstantInt>(C))
972 if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
972 if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) {
1153 if ((isa<ConstantFP>(V) || isa<ConstantInt>(V)) &&
1195 auto *CI = dyn_cast<ConstantInt>(*OI);
1195 auto *CI = dyn_cast<ConstantInt>(*OI);
1421 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
1421 if (const ConstantInt *CI = dyn_cast<ConstantInt>(this))
1426 return cast<ConstantInt>(C)->getValue();
1930 Constant *GEPIdx = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
1942 Constant *Zero = ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0);
1943 Constant *One = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
1951 return getOffsetOf(STy, ConstantInt::get(Type::getInt32Ty(STy->getContext()),
1959 ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0),
2350 return ConstantInt::get(Ty, 1);
2376 return ConstantInt::get(Ty, 1);
2653 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
2653 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
2778 return ConstantInt::get(getElementType(), getElementAsInteger(Elt));
lib/IR/Core.cpp 1300 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), N, SignExtend != 0));
1307 return wrap(ConstantInt::get(Ty->getContext(),
1314 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str),
1320 return wrap(ConstantInt::get(unwrap<IntegerType>(IntTy), StringRef(Str, SLen),
1338 return unwrap<ConstantInt>(ConstantVal)->getZExtValue();
1342 return unwrap<ConstantInt>(ConstantVal)->getSExtValue();
3195 unwrap<SwitchInst>(Switch)->addCase(unwrap<ConstantInt>(OnVal), unwrap(Dest));
lib/IR/DIBuilder.cpp 327 ConstantInt::get(IntegerType::get(VMContext, 32), VBPtrOffset));
369 ConstantAsMetadata::get(ConstantInt::get(IntegerType::get(VMContext, 64),
lib/IR/DataLayout.cpp 817 unsigned FieldNo = cast<ConstantInt>(Idx)->getZExtValue();
826 if (int64_t arrayIdx = cast<ConstantInt>(Idx)->getSExtValue())
lib/IR/DebugInfo.cpp 683 if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
683 if (auto *Val = mdconst::dyn_extract_or_null<ConstantInt>(
lib/IR/DebugInfoMetadata.cpp 320 ConstantInt::getSigned(Type::getInt64Ty(Context), Count));
lib/IR/DiagnosticInfo.cpp 59 if (const auto *CI =
60 mdconst::dyn_extract<ConstantInt>(SrcLoc->getOperand(0)))
lib/IR/Function.cpp 1552 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
1552 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
1561 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
1561 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(1));
1575 R.insert(mdconst::extract<ConstantInt>(MD->getOperand(i))
lib/IR/IRBuilder.cpp 400 CallInst *IRBuilderBase::CreateLifetimeStart(Value *Ptr, ConstantInt *Size) {
416 CallInst *IRBuilderBase::CreateLifetimeEnd(Value *Ptr, ConstantInt *Size) {
432 CallInst *IRBuilderBase::CreateInvariantStart(Value *Ptr, ConstantInt *Size) {
lib/IR/Instructions.cpp 57 auto C = dyn_cast<ConstantInt>(getArraySize());
492 APInt Val(128, mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(1))
496 Vals.push_back(MDB.createConstant(ConstantInt::get(
504 mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(i + 1))
509 ConstantInt::get(Type::getInt64Ty(getContext()),
518 const ConstantInt *CVal = dyn_cast<ConstantInt>(val);
518 const ConstantInt *CVal = dyn_cast<ConstantInt>(val);
536 ArraySize = ConstantInt::get(IntPtrTy, 1);
1200 Amt = ConstantInt::get(Type::getInt32Ty(Context), 1);
1262 if (ConstantInt *CI = dyn_cast<ConstantInt>(getOperand(0)))
1262 if (ConstantInt *CI = dyn_cast<ConstantInt>(getOperand(0)))
1272 if (!isa<ConstantInt>(getArraySize())) return false;
1666 if (ConstantInt *CI = dyn_cast<ConstantInt>(getOperand(i))) {
1666 if (ConstantInt *CI = dyn_cast<ConstantInt>(getOperand(i))) {
1680 if (!isa<ConstantInt>(getOperand(i)))
1837 NewMask[i] = ConstantInt::get(Int32Ty, MaskElt);
1861 if (auto *CI = dyn_cast<ConstantInt>(Op)) {
1861 if (auto *CI = dyn_cast<ConstantInt>(Op)) {
1897 return cast<ConstantInt>(C)->getZExtValue();
1912 cast<ConstantInt>(C)->getZExtValue());
3843 void SwitchInst::addCase(ConstantInt *OnVal, BasicBlock *Dest) {
3930 ConstantInt *C = mdconst::extract<ConstantInt>(ProfileData->getOperand(CI));
3930 ConstantInt *C = mdconst::extract<ConstantInt>(ProfileData->getOperand(CI));
3953 ConstantInt *OnVal, BasicBlock *Dest,
4008 return mdconst::extract<ConstantInt>(ProfileData->getOperand(idx + 1))
lib/IR/IntrinsicInst.cpp 102 return ConstantInt::get(Type::getInt64Ty(Context), 1);
lib/IR/LLVMContextImpl.h 340 if (auto *RHSCount = RHS->getCount().dyn_cast<ConstantInt*>())
340 if (auto *RHSCount = RHS->getCount().dyn_cast<ConstantInt*>())
343 cast<ConstantInt>(MD->getValue())->getSExtValue())
351 return hash_combine(cast<ConstantInt>(MD->getValue())->getSExtValue(),
1261 DenseMap<APInt, std::unique_ptr<ConstantInt>, DenseMapAPIntKeyInfo>;
1314 ConstantInt *TheTrueVal = nullptr;
1315 ConstantInt *TheFalseVal = nullptr;
lib/IR/MDBuilder.cpp 50 Vals[i + 1] = createConstant(ConstantInt::get(Int32Ty, Weights[i]));
68 Ops.push_back(createConstant(ConstantInt::get(Int64Ty, Count)));
73 Ops.push_back(createConstant(ConstantInt::get(Int64Ty, ID)));
88 return createRange(ConstantInt::get(Ty, Lo), ConstantInt::get(Ty, Hi));
88 return createRange(ConstantInt::get(Ty, Lo), ConstantInt::get(Ty, Hi));
113 Ops.push_back(createConstant(ConstantInt::get(Int64, CalleeArgNo)));
116 Ops.push_back(createConstant(ConstantInt::get(Int64, ArgNo, true)));
119 Ops.push_back(createConstant(ConstantInt::get(Int1, VarArgArePassed)));
131 cast<ConstantInt>(NewCBCalleeIdxAsCM->getValue())->getZExtValue();
143 cast<ConstantInt>(OldCBCalleeIdxAsCM->getValue())->getZExtValue();
184 Constant *Flags = ConstantInt::get(Type::getInt64Ty(Context), 1);
205 Vals[i * 3 + 0] = createConstant(ConstantInt::get(Int64, Fields[i].Offset));
206 Vals[i * 3 + 1] = createConstant(ConstantInt::get(Int64, Fields[i].Size));
221 Ops[i * 2 + 2] = createConstant(ConstantInt::get(Int64, Fields[i].second));
230 ConstantInt *Off = ConstantInt::get(Type::getInt64Ty(Context), Offset);
230 ConstantInt *Off = ConstantInt::get(Type::getInt64Ty(Context), Offset);
240 ConstantInt *Off = ConstantInt::get(Int64, Offset);
240 ConstantInt *Off = ConstantInt::get(Int64, Offset);
243 createConstant(ConstantInt::get(Int64, 1))});
254 Ops[1] = createConstant(ConstantInt::get(Int64, Size));
258 Ops[I * 3 + 4] = createConstant(ConstantInt::get(Int64, Fields[I].Offset));
259 Ops[I * 3 + 5] = createConstant(ConstantInt::get(Int64, Fields[I].Size));
268 auto *OffsetNode = createConstant(ConstantInt::get(Int64, Offset));
269 auto *SizeNode = createConstant(ConstantInt::get(Int64, Size));
271 auto *ImmutabilityFlagNode = createConstant(ConstantInt::get(Int64, 1));
282 uint64_t Offset = mdconst::extract<ConstantInt>(OffsetNode)->getZExtValue();
293 if (!mdconst::extract<ConstantInt>(ImmutabilityFlagNode)->getValue())
301 uint64_t Size = mdconst::extract<ConstantInt>(SizeNode)->getZExtValue();
308 createConstant(ConstantInt::get(Type::getInt64Ty(Context), Weight)),
318 createConstant(ConstantInt::get(IntType, Index)),
319 createConstant(ConstantInt::get(IntType, LikleyWeight)),
320 createConstant(ConstantInt::get(IntType, UnlikleyWeight)),
lib/IR/Metadata.cpp 948 static bool tryMergeRange(SmallVectorImpl<ConstantInt *> &EndPoints,
949 ConstantInt *Low, ConstantInt *High) {
949 ConstantInt *Low, ConstantInt *High) {
959 cast<ConstantInt>(ConstantInt::get(Ty, Union.getLower()));
959 cast<ConstantInt>(ConstantInt::get(Ty, Union.getLower()));
961 cast<ConstantInt>(ConstantInt::get(Ty, Union.getUpper()));
961 cast<ConstantInt>(ConstantInt::get(Ty, Union.getUpper()));
967 static void addRange(SmallVectorImpl<ConstantInt *> &EndPoints,
968 ConstantInt *Low, ConstantInt *High) {
968 ConstantInt *Low, ConstantInt *High) {
990 SmallVector<ConstantInt *, 4> EndPoints;
996 ConstantInt *ALow = mdconst::extract<ConstantInt>(A->getOperand(2 * AI));
996 ConstantInt *ALow = mdconst::extract<ConstantInt>(A->getOperand(2 * AI));
997 ConstantInt *BLow = mdconst::extract<ConstantInt>(B->getOperand(2 * BI));
997 ConstantInt *BLow = mdconst::extract<ConstantInt>(B->getOperand(2 * BI));
1001 mdconst::extract<ConstantInt>(A->getOperand(2 * AI + 1)));
1005 mdconst::extract<ConstantInt>(B->getOperand(2 * BI + 1)));
1010 addRange(EndPoints, mdconst::extract<ConstantInt>(A->getOperand(2 * AI)),
1011 mdconst::extract<ConstantInt>(A->getOperand(2 * AI + 1)));
1015 addRange(EndPoints, mdconst::extract<ConstantInt>(B->getOperand(2 * BI)),
1016 mdconst::extract<ConstantInt>(B->getOperand(2 * BI + 1)));
1024 ConstantInt *FB = EndPoints[0];
1025 ConstantInt *FE = EndPoints[1];
1044 for (auto *I : EndPoints)
1053 ConstantInt *AVal = mdconst::extract<ConstantInt>(A->getOperand(0));
1053 ConstantInt *AVal = mdconst::extract<ConstantInt>(A->getOperand(0));
1054 ConstantInt *BVal = mdconst::extract<ConstantInt>(B->getOperand(0));
1054 ConstantInt *BVal = mdconst::extract<ConstantInt>(B->getOperand(0));
1325 auto *CITrue = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(1));
1325 auto *CITrue = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(1));
1326 auto *CIFalse = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(2));
1326 auto *CIFalse = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(2));
1356 auto *V = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(i));
1356 auto *V = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(i));
1364 TotalVal = mdconst::dyn_extract<ConstantInt>(ProfileData->getOperand(2))
1456 auto *OffsetConst = cast<ConstantInt>(
1456 auto *OffsetConst = cast<ConstantInt>(
1459 auto *NewOffsetMD = ConstantAsMetadata::get(ConstantInt::get(
1495 {ConstantAsMetadata::get(ConstantInt::get(
1503 {ConstantAsMetadata::get(ConstantInt::get(
1509 uint64_t Val = cast<ConstantInt>(
lib/IR/Module.cpp 278 if (ConstantInt *Behavior = mdconst::dyn_extract_or_null<ConstantInt>(MD)) {
278 if (ConstantInt *Behavior = mdconst::dyn_extract_or_null<ConstantInt>(MD)) {
341 ConstantAsMetadata::get(ConstantInt::get(Int32Ty, Behavior)),
352 addModuleFlag(Behavior, Key, ConstantInt::get(Int32Ty, Val));
458 return cast<ConstantInt>(Val->getValue())->getZExtValue();
465 return cast<ConstantInt>(Val->getValue())->getZExtValue();
472 return cast<ConstantInt>(Val->getValue())->getZExtValue();
495 cast<ConstantInt>(Val->getValue())->getZExtValue());
509 cast<ConstantInt>(Val->getValue())->getZExtValue());
523 cast<ConstantInt>(Val->getValue())->getZExtValue());
552 return Val && (cast<ConstantInt>(Val->getValue())->getZExtValue() > 0);
lib/IR/Operator.cpp 42 ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand());
42 ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand());
lib/IR/ProfileSummary.cpp 30 ConstantAsMetadata::get(ConstantInt::get(Int64Ty, Val))};
53 ConstantAsMetadata::get(ConstantInt::get(Int32Ty, Entry.Cutoff)),
54 ConstantAsMetadata::get(ConstantInt::get(Int64Ty, Entry.MinCount)),
55 ConstantAsMetadata::get(ConstantInt::get(Int32Ty, Entry.NumCounts))};
95 Val = cast<ConstantInt>(ValMD->getValue())->getZExtValue();
135 Summary.emplace_back(cast<ConstantInt>(Op0->getValue())->getZExtValue(),
136 cast<ConstantInt>(Op1->getValue())->getZExtValue(),
137 cast<ConstantInt>(Op2->getValue())->getZExtValue());
lib/IR/SafepointIRVerifier.cpp 149 ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
149 ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
lib/IR/Type.cpp 565 const ConstantInt *CU = dyn_cast_or_null<ConstantInt>(C);
565 const ConstantInt *CU = dyn_cast_or_null<ConstantInt>(C);
lib/IR/Value.cpp 634 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
634 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
640 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
640 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
647 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
647 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
653 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
653 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
728 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
728 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
lib/IR/Verifier.cpp 1464 ConstantInt *Value
1465 = mdconst::dyn_extract_or_null<ConstantInt>(Op->getOperand(2));
1950 cast<ConstantInt>(Call.getArgOperand(1))->getSExtValue();
1963 const int NumCallArgs = cast<ConstantInt>(Call.getArgOperand(3))->getZExtValue();
1983 = cast<ConstantInt>(Call.getArgOperand(4))->getZExtValue();
2014 cast<ConstantInt>(NumTransitionArgsV)->getZExtValue();
2024 const int NumDeoptArgs = cast<ConstantInt>(NumDeoptArgsV)->getZExtValue();
2471 SmallPtrSet<ConstantInt*, 32> Constants;
3332 ConstantInt *Low =
3333 mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i));
3335 ConstantInt *High =
3336 mdconst::dyn_extract<ConstantInt>(Range->getOperand(2 * i + 1));
3358 mdconst::dyn_extract<ConstantInt>(Range->getOperand(0))->getValue();
3360 mdconst::dyn_extract<ConstantInt>(Range->getOperand(1))->getValue();
4014 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(MD->getOperand(0));
4014 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(MD->getOperand(0));
4205 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(AlignMD->getOperand(0));
4205 ConstantInt *CI = mdconst::dyn_extract<ConstantInt>(AlignMD->getOperand(0));
4371 ConstantInt *ElementSizeCI =
4372 cast<ConstantInt>(AMI->getRawElementSizeInBytes());
4379 if (auto *LengthCI = dyn_cast<ConstantInt>(AMI->getLength())) {
4379 if (auto *LengthCI = dyn_cast<ConstantInt>(AMI->getLength())) {
4459 auto *IdxArg = cast<ConstantInt>(Call.getArgOperand(2));
4459 auto *IdxArg = cast<ConstantInt>(Call.getArgOperand(2));
4541 const int BaseIndex = cast<ConstantInt>(Base)->getZExtValue();
4542 const int DerivedIndex = cast<ConstantInt>(Derived)->getZExtValue();
4556 cast<ConstantInt>(StatepointCall.getArgOperand(3))->getZExtValue();
4563 cast<ConstantInt>(StatepointCall.getArgOperand(NumCallArgs + 5))
4570 cast<ConstantInt>(StatepointCall.getArgOperand(DeoptArgsStart))
4614 ConstantInt *Alignment = cast<ConstantInt>(Call.getArgOperand(1));
4614 ConstantInt *Alignment = cast<ConstantInt>(Call.getArgOperand(1));
4636 ConstantInt *Alignment = cast<ConstantInt>(Call.getArgOperand(2));
4636 ConstantInt *Alignment = cast<ConstantInt>(Call.getArgOperand(2));
4710 auto *Op3 = cast<ConstantInt>(Call.getArgOperand(2));
4710 auto *Op3 = cast<ConstantInt>(Call.getArgOperand(2));
5251 auto *TypeSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
5251 auto *TypeSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
5285 auto *OffsetEntryCI =
5286 mdconst::dyn_extract_or_null<ConstantInt>(FieldOffset);
5320 auto *MemberSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
5320 auto *MemberSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
5347 auto *Offset = mdconst::dyn_extract<ConstantInt>(MD->getOperand(2));
5347 auto *Offset = mdconst::dyn_extract<ConstantInt>(MD->getOperand(2));
5391 auto *OffsetEntryCI =
5392 mdconst::extract<ConstantInt>(BaseNode->getOperand(Idx + 1));
5401 auto *PrevOffsetEntryCI =
5402 mdconst::extract<ConstantInt>(BaseNode->getOperand(PrevIdx + 1));
5409 auto *LastOffsetEntryCI = mdconst::extract<ConstantInt>(
5409 auto *LastOffsetEntryCI = mdconst::extract<ConstantInt>(
5456 auto *AccessSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
5456 auto *AccessSizeNode = mdconst::dyn_extract_or_null<ConstantInt>(
5464 auto *IsImmutableCI = mdconst::dyn_extract_or_null<ConstantInt>(
5464 auto *IsImmutableCI = mdconst::dyn_extract_or_null<ConstantInt>(
5486 auto *OffsetCI = mdconst::dyn_extract_or_null<ConstantInt>(MD->getOperand(2));
5486 auto *OffsetCI = mdconst::dyn_extract_or_null<ConstantInt>(MD->getOperand(2));
lib/Linker/IRMover.cpp 1213 ConstantInt *Behavior = mdconst::extract<ConstantInt>(Op->getOperand(0));
1213 ConstantInt *Behavior = mdconst::extract<ConstantInt>(Op->getOperand(0));
1227 ConstantInt *SrcBehavior =
1228 mdconst::extract<ConstantInt>(SrcOp->getOperand(0));
1253 ConstantInt *DstBehavior =
1254 mdconst::extract<ConstantInt>(DstOp->getOperand(0));
1321 ConstantInt *DstValue =
1322 mdconst::extract<ConstantInt>(DstOp->getOperand(2));
1323 ConstantInt *SrcValue =
1324 mdconst::extract<ConstantInt>(SrcOp->getOperand(2));
lib/ProfileData/InstrProf.cpp 958 ConstantInt::get(Type::getInt32Ty(Ctx), ValueKind)));
961 MDHelper.createConstant(ConstantInt::get(Type::getInt64Ty(Ctx), Sum)));
967 ConstantInt::get(Type::getInt64Ty(Ctx), VD.Value)));
969 ConstantInt::get(Type::getInt64Ty(Ctx), VD.Count)));
999 ConstantInt *KindInt = mdconst::dyn_extract<ConstantInt>(MD->getOperand(1));
999 ConstantInt *KindInt = mdconst::dyn_extract<ConstantInt>(MD->getOperand(1));
1006 ConstantInt *TotalCInt = mdconst::dyn_extract<ConstantInt>(MD->getOperand(2));
1006 ConstantInt *TotalCInt = mdconst::dyn_extract<ConstantInt>(MD->getOperand(2));
1016 ConstantInt *Value = mdconst::dyn_extract<ConstantInt>(MD->getOperand(I));
1016 ConstantInt *Value = mdconst::dyn_extract<ConstantInt>(MD->getOperand(I));
1017 ConstantInt *Count =
1018 mdconst::dyn_extract<ConstantInt>(MD->getOperand(I + 1));
1081 auto *InitVal = dyn_cast_or_null<ConstantInt>(IRInstrVar->getInitializer());
lib/Target/AArch64/AArch64FastISel.cpp 275 unsigned materializeInt(const ConstantInt *CI, MVT VT);
380 unsigned AArch64FastISel::materializeInt(const ConstantInt *CI, MVT VT) {
536 return materializeInt(ConstantInt::get(Type::getInt64Ty(*Context), 0), VT);
539 if (const auto *CI = dyn_cast<ConstantInt>(C))
539 if (const auto *CI = dyn_cast<ConstantInt>(C))
568 if (const auto *C = dyn_cast<ConstantInt>(MI->getOperand(0)))
568 if (const auto *C = dyn_cast<ConstantInt>(MI->getOperand(0)))
571 if (const auto *C = dyn_cast<ConstantInt>(MI->getOperand(1)))
571 if (const auto *C = dyn_cast<ConstantInt>(MI->getOperand(1)))
633 unsigned Idx = cast<ConstantInt>(Op)->getZExtValue();
638 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
638 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
645 ConstantInt *CI =
646 cast<ConstantInt>(cast<AddOperator>(Op)->getOperand(1));
685 if (isa<ConstantInt>(LHS))
688 if (const ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
688 if (const ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
705 if (const ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
705 if (const ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
715 const auto *CI = dyn_cast<ConstantInt>(U->getOperand(1));
715 const auto *CI = dyn_cast<ConstantInt>(U->getOperand(1));
762 if (const auto *C = dyn_cast<ConstantInt>(LHS))
762 if (const auto *C = dyn_cast<ConstantInt>(LHS))
766 if (const auto *C = dyn_cast<ConstantInt>(RHS))
766 if (const auto *C = dyn_cast<ConstantInt>(RHS))
797 if (const auto *C = dyn_cast<ConstantInt>(LHS))
797 if (const auto *C = dyn_cast<ConstantInt>(LHS))
802 const auto *C = cast<ConstantInt>(RHS);
802 const auto *C = cast<ConstantInt>(RHS);
857 if (const auto *C = dyn_cast<ConstantInt>(LHS))
857 if (const auto *C = dyn_cast<ConstantInt>(LHS))
861 if (const auto *C = dyn_cast<ConstantInt>(RHS))
861 if (const auto *C = dyn_cast<ConstantInt>(RHS))
1198 if (isa<ConstantInt>(SI->getOperand(1)))
1213 if (const auto *C = dyn_cast<ConstantInt>(RHS)) {
1213 if (const auto *C = dyn_cast<ConstantInt>(RHS)) {
1233 if (const auto *C = dyn_cast<ConstantInt>(SI->getOperand(1)))
1233 if (const auto *C = dyn_cast<ConstantInt>(SI->getOperand(1)))
1257 if (const auto *C = dyn_cast<ConstantInt>(MulLHS))
1257 if (const auto *C = dyn_cast<ConstantInt>(MulLHS))
1262 uint64_t ShiftVal = cast<ConstantInt>(MulRHS)->getValue().logBase2();
1278 if (const auto *C = dyn_cast<ConstantInt>(SI->getOperand(1))) {
1278 if (const auto *C = dyn_cast<ConstantInt>(SI->getOperand(1))) {
1610 if (isa<ConstantInt>(LHS) && !isa<ConstantInt>(RHS))
1610 if (isa<ConstantInt>(LHS) && !isa<ConstantInt>(RHS))
1621 if (isa<ConstantInt>(SI->getOperand(1)))
1630 if (const auto *C = dyn_cast<ConstantInt>(RHS)) {
1630 if (const auto *C = dyn_cast<ConstantInt>(RHS)) {
1643 if (const auto *C = dyn_cast<ConstantInt>(MulLHS))
1643 if (const auto *C = dyn_cast<ConstantInt>(MulLHS))
1648 uint64_t ShiftVal = cast<ConstantInt>(MulRHS)->getValue().logBase2();
1664 if (const auto *C = dyn_cast<ConstantInt>(SI->getOperand(1))) {
1664 if (const auto *C = dyn_cast<ConstantInt>(SI->getOperand(1))) {
2206 if (const auto *CI = dyn_cast<ConstantInt>(Op0)) {
2206 if (const auto *CI = dyn_cast<ConstantInt>(Op0)) {
2343 if (const auto *C = dyn_cast<ConstantInt>(AndLHS))
2343 if (const auto *C = dyn_cast<ConstantInt>(AndLHS))
2347 if (const auto *C = dyn_cast<ConstantInt>(AndRHS))
2347 if (const auto *C = dyn_cast<ConstantInt>(AndRHS))
2369 if (!isa<ConstantInt>(RHS))
2372 if (cast<ConstantInt>(RHS)->getValue() != APInt(BW, -1, true))
2493 } else if (const auto *CI = dyn_cast<ConstantInt>(BI->getCondition())) {
2493 } else if (const auto *CI = dyn_cast<ConstantInt>(BI->getCondition())) {
2661 if (auto *CI = dyn_cast<ConstantInt>(SI->getTrueValue())) {
2672 } else if (auto *CI = dyn_cast<ConstantInt>(SI->getFalseValue())) {
3406 if (isa<ConstantInt>(LHS) && !isa<ConstantInt>(RHS) &&
3406 if (isa<ConstantInt>(LHS) && !isa<ConstantInt>(RHS) &&
3416 if (const auto *C = dyn_cast<ConstantInt>(RHS))
3416 if (const auto *C = dyn_cast<ConstantInt>(RHS))
3421 if (const auto *C = dyn_cast<ConstantInt>(RHS))
3421 if (const auto *C = dyn_cast<ConstantInt>(RHS))
3489 unsigned Depth = cast<ConstantInt>(II->getOperand(0))->getZExtValue();
3525 if (isa<ConstantInt>(MTI->getLength()) && IsMemCpy) {
3528 uint64_t Len = cast<ConstantInt>(MTI->getLength())->getZExtValue();
3698 if (isa<ConstantInt>(LHS) && !isa<ConstantInt>(RHS) &&
3698 if (isa<ConstantInt>(LHS) && !isa<ConstantInt>(RHS) &&
3708 if (const auto *C = dyn_cast<ConstantInt>(RHS))
3708 if (const auto *C = dyn_cast<ConstantInt>(RHS))
3715 if (const auto *C = dyn_cast<ConstantInt>(RHS))
3715 if (const auto *C = dyn_cast<ConstantInt>(RHS))
4272 return materializeInt(ConstantInt::get(*Context, APInt(RegSize, 0)), RetVT);
4393 return materializeInt(ConstantInt::get(*Context, APInt(RegSize, 0)), RetVT);
4688 if (const auto *C = dyn_cast<ConstantInt>(Src0))
4688 if (const auto *C = dyn_cast<ConstantInt>(Src0))
4693 if (const auto *C = dyn_cast<ConstantInt>(Src1))
4693 if (const auto *C = dyn_cast<ConstantInt>(Src1))
4759 if (const auto *C = dyn_cast<ConstantInt>(I->getOperand(1))) {
4759 if (const auto *C = dyn_cast<ConstantInt>(I->getOperand(1))) {
4924 if (!isa<ConstantInt>(I->getOperand(1)))
4927 const APInt &C = cast<ConstantInt>(I->getOperand(1))->getValue();
5027 unsigned Field = cast<ConstantInt>(Idx)->getZExtValue();
5035 if (const auto *CI = dyn_cast<ConstantInt>(Idx)) {
5035 if (const auto *CI = dyn_cast<ConstantInt>(Idx)) {
5040 DL.getTypeAllocSize(Ty) * cast<ConstantInt>(CI)->getSExtValue();
lib/Target/AArch64/AArch64ISelLowering.cpp 8586 if (!isa<ConstantInt>(Instr->getOperand(1)))
12191 Lo, Builder.CreateShl(Hi, ConstantInt::get(ValTy, 64)), "val64");
12341 ConstantInt* Mask = dyn_cast<ConstantInt>(AndI.getOperand(1));
12341 ConstantInt* Mask = dyn_cast<ConstantInt>(AndI.getOperand(1));
lib/Target/AArch64/AArch64InstructionSelector.cpp 3682 CstIdxs.emplace_back(ConstantInt::get(Type::getInt8Ty(Ctx), Offset));
lib/Target/AArch64/AArch64StackTagging.cpp 117 uint64_t StoreSize = cast<ConstantInt>(MSI->getLength())->getZExtValue();
122 cast<ConstantInt>(MSI->getValue()));
127 ConstantInt *V) {
141 ConstantInt *C =
142 ConstantInt::get(IRB.getInt64Ty(), Cst * V->getZExtValue());
228 {Ptr, ConstantInt::get(IRB.getInt64Ty(), Size)});
237 IRB.CreateCall(SetTagFn, {Ptr, ConstantInt::get(IRB.getInt64Ty(), Size)});
373 if (MSI->isVolatile() || !isa<ConstantInt>(MSI->getLength()))
376 if (!isa<ConstantInt>(MSI->getValue()))
431 ConstantInt::get(IRB.getInt64Ty(), Size)});
476 cast<ConstantInt>(Info.AI->getArraySize())->getZExtValue())
625 ConstantInt::get(IRB.getInt64Ty(), Info.Tag)});
636 dyn_cast<ConstantInt>(Start->getArgOperand(0))->getZExtValue();
lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp 659 ConstantInt *One = Builder.getInt32(1);
732 ConstantInt *TruncMask = Builder.getInt32((UINT64_C(1) << DivBits) - 1);
775 ConstantInt *Zero = Builder.getInt32(0);
776 ConstantInt *One = Builder.getInt32(1);
777 ConstantInt *MinusOne = Builder.getInt32(~0);
781 ConstantInt *K31 = Builder.getInt32(31);
949 ConstantInt *Lower =
950 mdconst::extract<ConstantInt>(Range->getOperand(0));
956 ConstantAsMetadata::get(ConstantInt::get(I32Ty, Lower->getValue().zext(32))),
958 ConstantAsMetadata::get(ConstantInt::get(I32Ty, 0))
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.cpp 206 Dims.push_back(mdconst::extract<ConstantInt>(Op)->getZExtValue());
278 mdconst::extract<ConstantInt>(Op0->getOperand(0))->getZExtValue());
280 mdconst::extract<ConstantInt>(Op0->getOperand(1))->getZExtValue());
293 mdconst::extract<ConstantInt>(Node->getOperand(1))->getZExtValue());
648 uint64_t(mdconst::extract<ConstantInt>(Op)->getZExtValue())));
685 mdconst::extract<ConstantInt>(Op0->getOperand(0))->getZExtValue()));
687 mdconst::extract<ConstantInt>(Op0->getOperand(1))->getZExtValue()));
702 mdconst::extract<ConstantInt>(Node->getOperand(1))->getZExtValue()),
lib/Target/AMDGPU/AMDGPULibCalls.cpp 593 if (!isa<ConstantInt>(PacketSize) || !isa<ConstantInt>(PacketAlign))
593 if (!isa<ConstantInt>(PacketSize) || !isa<ConstantInt>(PacketAlign))
595 unsigned Size = cast<ConstantInt>(PacketSize)->getZExtValue();
596 unsigned Align = cast<ConstantInt>(PacketAlign)->getZExtValue();
878 ConstantInt *CINT;
888 CINT = dyn_cast<ConstantInt>(opr1);
897 CINT = CDV ? dyn_cast_or_null<ConstantInt>(CDV->getSplatValue()) : nullptr;
1159 ConstantInt *CINT = dyn_cast<ConstantInt>(opr1);
1159 ConstantInt *CINT = dyn_cast<ConstantInt>(opr1);
1399 CI->replaceAllUsesWith(ConstantInt::get(B.getInt32Ty(), N));
1589 if (ConstantInt *iopr1 = dyn_cast_or_null<ConstantInt>(copr1)) {
1589 if (ConstantInt *iopr1 = dyn_cast_or_null<ConstantInt>(copr1)) {
1598 if (ConstantInt *iopr1 = dyn_cast_or_null<ConstantInt>(copr1)) {
1598 if (ConstantInt *iopr1 = dyn_cast_or_null<ConstantInt>(copr1)) {
lib/Target/AMDGPU/AMDGPULowerIntrinsics.cpp 59 ConstantInt *CI = dyn_cast<ConstantInt>(Size);
59 ConstantInt *CI = dyn_cast<ConstantInt>(Size);
lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp 178 ConstantInt::get(Builder.getInt64Ty(), DerefBytes))));
186 MDB.createConstant(ConstantInt::get(Builder.getInt64Ty(),
195 MDB.createConstant(ConstantInt::get(Builder.getInt64Ty(),
lib/Target/AMDGPU/AMDGPULowerKernelAttributes.cpp 201 ConstantInt *KnownSize
202 = mdconst::extract<ConstantInt>(MD->getOperand(I));
225 ConstantInt *KnownSize = mdconst::extract<ConstantInt>(MD->getOperand(I));
225 ConstantInt *KnownSize = mdconst::extract<ConstantInt>(MD->getOperand(I));
lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp 348 Value *sumC = ConstantInt::get(SizetTy, Sum, false);
377 ConstantInt *zeroInt =
378 ConstantInt::get(Ctx, APInt(32, StringRef("0"), 10));
390 new StoreInst(ConstantInt::get(I32Ty, UniqID), id_gep_cast);
394 ConstantInt *fourInt =
395 ConstantInt::get(Ctx, APInt(32, StringRef("4"), 10));
464 Value *ANumV = ConstantInt::get(Int32Ty, ANum, false);
470 Value *ANumV = ConstantInt::get(Int32Ty, 0xFFFFFF00, false);
488 ConstantInt::get(Int32Ty, 0), ConstantInt::get(Int32Ty, 1),
488 ConstantInt::get(Int32Ty, 0), ConstantInt::get(Int32Ty, 1),
489 ConstantInt::get(Int32Ty, 2), ConstantInt::get(Int32Ty, 2)};
489 ConstantInt::get(Int32Ty, 2), ConstantInt::get(Int32Ty, 2)};
537 BuffOffset.push_back(ConstantInt::get(I32Ty, ArgSize));
lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp 317 ConstantInt *I0 = dyn_cast<ConstantInt>(GEP->getOperand(1));
317 ConstantInt *I0 = dyn_cast<ConstantInt>(GEP->getOperand(1));
lib/Target/AMDGPU/AMDGPUSubtarget.cpp 471 MinSize = MaxSize = mdconst::extract<ConstantInt>(
lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp 319 auto *Ordering = dyn_cast<ConstantInt>(Inst->getArgOperand(2));
319 auto *Ordering = dyn_cast<ConstantInt>(Inst->getArgOperand(2));
320 auto *Volatile = dyn_cast<ConstantInt>(Inst->getArgOperand(4));
320 auto *Volatile = dyn_cast<ConstantInt>(Inst->getArgOperand(4));
619 const ConstantInt *IsVolatile = cast<ConstantInt>(II->getArgOperand(4));
619 const ConstantInt *IsVolatile = cast<ConstantInt>(II->getArgOperand(4));
637 ConstantInt *NewVal = (TrueAS == NewAS) ?
638 ConstantInt::getTrue(Ctx) : ConstantInt::getFalse(Ctx);
638 ConstantInt::getTrue(Ctx) : ConstantInt::getFalse(Ctx);
700 ConstantInt *CI = dyn_cast<ConstantInt>(EE->getOperand(1));
700 ConstantInt *CI = dyn_cast<ConstantInt>(EE->getOperand(1));
710 ConstantInt *CI = dyn_cast<ConstantInt>(IE->getOperand(2));
710 ConstantInt *CI = dyn_cast<ConstantInt>(IE->getOperand(2));
lib/Target/AMDGPU/AMDGPUUnifyDivergentExitNodes.cpp 184 ConstantInt *BoolTrue = ConstantInt::getTrue(F.getContext());
184 ConstantInt *BoolTrue = ConstantInt::getTrue(F.getContext());
lib/Target/AMDGPU/AMDGPUUnifyMetadata.cpp 66 auto CMajor = mdconst::extract<ConstantInt>(VersionMD->getOperand(0));
68 auto CMinor = mdconst::extract<ConstantInt>(VersionMD->getOperand(1));
lib/Target/AMDGPU/R600OpenCLImageTypeLoweringPass.cpp 182 Replacement = ConstantInt::get(Int32Type, ResourceID);
215 Replacement = ConstantInt::get(Int32Type, ResourceID);
lib/Target/AMDGPU/SIAnnotateControlFlow.cpp 63 ConstantInt *BoolTrue;
64 ConstantInt *BoolFalse;
146 BoolTrue = ConstantInt::getTrue(Context);
147 BoolFalse = ConstantInt::getFalse(Context);
149 IntMaskZero = ConstantInt::get(IntMask, 0);
lib/Target/AMDGPU/SIISelLowering.cpp 970 const ConstantInt *Vol = cast<ConstantInt>(CI.getOperand(4));
970 const ConstantInt *Vol = cast<ConstantInt>(CI.getOperand(4));
987 const ConstantInt *Vol = dyn_cast<ConstantInt>(CI.getOperand(4));
987 const ConstantInt *Vol = dyn_cast<ConstantInt>(CI.getOperand(4));
1011 const ConstantInt *Vol = cast<ConstantInt>(CI.getOperand(1));
1011 const ConstantInt *Vol = cast<ConstantInt>(CI.getOperand(1));
lib/Target/AMDGPU/Utils/AMDGPUPALMetadata.cpp 58 auto Key = mdconst::dyn_extract<ConstantInt>(Tuple->getOperand(I));
59 auto Val = mdconst::dyn_extract<ConstantInt>(Tuple->getOperand(I + 1));
lib/Target/ARM/ARMAsmPrinter.cpp 729 if (auto WCharWidthValue = mdconst::extract_or_null<ConstantInt>(
740 if (auto EnumWidthValue = mdconst::extract_or_null<ConstantInt>(
1199 Offset = -cast<ConstantInt>(CPE.Val.ConstVal)->getSExtValue();
lib/Target/ARM/ARMBaseRegisterInfo.cpp 466 ConstantInt::get(Type::getInt32Ty(MF.getFunction().getContext()), Val);
lib/Target/ARM/ARMCodeGenPrepare.cpp 347 !isa<ConstantInt>(I->getOperand(1)))
350 ConstantInt *OverflowConst = cast<ConstantInt>(I->getOperand(1));
350 ConstantInt *OverflowConst = cast<ConstantInt>(I->getOperand(1));
362 ConstantInt *ICmpConst = nullptr;
363 if (auto *Const = dyn_cast<ConstantInt>(CI->getOperand(0)))
363 if (auto *Const = dyn_cast<ConstantInt>(CI->getOperand(0)))
365 else if (auto *Const = dyn_cast<ConstantInt>(CI->getOperand(1)))
365 else if (auto *Const = dyn_cast<ConstantInt>(CI->getOperand(1)))
487 auto Const = cast<ConstantInt>(I->getOperand(1));
488 auto *NewConst = ConstantInt::get(Ctx, Const->getValue().abs());
488 auto *NewConst = ConstantInt::get(Ctx, Const->getValue().abs());
561 if (auto *Const = dyn_cast<ConstantInt>(Op)) {
561 if (auto *Const = dyn_cast<ConstantInt>(Op)) {
723 ConstantInt *Mask =
724 ConstantInt::get(SrcTy, APInt::getMaxValue(NumBits).getZExtValue());
lib/Target/ARM/ARMFastISel.cpp 470 const ConstantInt *CI = cast<ConstantInt>(C);
470 const ConstantInt *CI = cast<ConstantInt>(C);
653 else if (isa<ConstantInt>(C))
765 unsigned Idx = cast<ConstantInt>(Op)->getZExtValue();
770 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
770 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
777 ConstantInt *CI =
778 cast<ConstantInt>(cast<AddOperator>(Op)->getOperand(1));
1295 } else if (const ConstantInt *CI =
1296 dyn_cast<ConstantInt>(BI->getCondition())) {
1370 if (const ConstantInt *ConstInt = dyn_cast<ConstantInt>(Src2Value)) {
1370 if (const ConstantInt *ConstInt = dyn_cast<ConstantInt>(Src2Value)) {
1488 Constant *Zero = ConstantInt::get(Type::getInt32Ty(*Context), 0);
1632 if (const ConstantInt *ConstInt = dyn_cast<ConstantInt>(I->getOperand(2))) {
1632 if (const ConstantInt *ConstInt = dyn_cast<ConstantInt>(I->getOperand(2))) {
2508 unsigned Depth = cast<ConstantInt>(I.getOperand(0))->getZExtValue();
2529 if (isa<ConstantInt>(MTI.getLength()) && isMemCpy) {
2532 uint64_t Len = cast<ConstantInt>(MTI.getLength())->getZExtValue();
2778 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Src2Value)) {
2778 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Src2Value)) {
lib/Target/ARM/ARMISelDAGToDAG.cpp 2989 ConstantInt::get(Type::getInt32Ty(*CurDAG->getContext()), Val),
lib/Target/ARM/ARMISelLowering.cpp 9643 const Constant *C = ConstantInt::get(Int32Ty, NumLPads);
9744 const Constant *C = ConstantInt::get(Int32Ty, NumLPads);
10146 const Constant *C = ConstantInt::get(Int32Ty, LoopSize);
16263 Info.align = MaybeAlign(cast<ConstantInt>(AlignArg)->getZExtValue());
16304 Info.align = MaybeAlign(cast<ConstantInt>(AlignArg)->getZExtValue());
16580 if (!isa<ConstantInt>(Idx))
16630 Lo, Builder.CreateShl(Hi, ConstantInt::get(ValTy, 32)), "val64");
lib/Target/ARM/ARMLegalizerInfo.cpp 466 *ConstantInt::get(Ctx, AsInteger));
lib/Target/ARM/ARMParallelDSP.cpp 699 ConstantInt::get(IntegerType::get(M->getContext(), 64), 0) :
700 ConstantInt::get(IntegerType::get(M->getContext(), 32), 0);
789 Value *ShiftVal = ConstantInt::get(LoadTy, OffsetTy->getBitWidth());
lib/Target/ARM/ARMTargetTransformInfo.cpp 518 ConstantInt *C = dyn_cast<ConstantInt>(MI->getLength());
518 ConstantInt *C = dyn_cast<ConstantInt>(MI->getLength());
999 HWLoopInfo.LoopDecrement = ConstantInt::get(HWLoopInfo.CountType, 1);
lib/Target/ARM/MVETailPredication.cpp 320 ConstantInt *VF = ConstantInt::get(cast<IntegerType>(TripCount->getType()),
320 ConstantInt *VF = ConstantInt::get(cast<IntegerType>(TripCount->getType()),
482 ConstantInt *Factor =
483 ConstantInt::get(cast<IntegerType>(Ty), VecTy->getNumElements());
lib/Target/ARM/ThumbRegisterInfo.cpp 71 const Constant *C = ConstantInt::get(
90 const Constant *C = ConstantInt::get(
lib/Target/AVR/AVRISelLowering.cpp 1780 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1780 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1787 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1787 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1794 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1794 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1801 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1801 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1808 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1808 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1815 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1815 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1822 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1822 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1830 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1830 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1837 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
1837 if (const ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
lib/Target/BPF/BPFAbstractMemberAccess.cpp 222 auto *CI = SR->getCount().dyn_cast<ConstantInt *>();
222 auto *CI = SR->getCount().dyn_cast<ConstantInt *>();
289 ConstantInt::get(Type::getInt32Ty(Call->getParent()->getContext()), 0);
506 const ConstantInt *CV = dyn_cast<ConstantInt>(IndexValue);
506 const ConstantInt *CV = dyn_cast<ConstantInt>(IndexValue);
520 auto SOff = dyn_cast<ConstantInt>(MemberTy->getStorageOffsetInBits());
532 SOff = dyn_cast<ConstantInt>(Member->getStorageOffsetInBits());
560 auto SOffset = dyn_cast<ConstantInt>(MemberTy->getStorageOffsetInBits());
lib/Target/BPF/BPFISelDAGToDAG.cpp 398 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
398 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV)) {
lib/Target/BPF/BTFDebug.cpp 486 auto *CI = SR->getCount().dyn_cast<ConstantInt *>();
486 auto *CI = SR->getCount().dyn_cast<ConstantInt *>();
lib/Target/Hexagon/BitTracker.cpp 422 BT::RegisterCell BT::MachineEvaluator::eIMM(const ConstantInt *CI) const {
lib/Target/Hexagon/BitTracker.h 417 RegisterCell eIMM(const ConstantInt *CI) const;
lib/Target/Hexagon/HexagonCommonGEP.cpp 212 ConstantInt *CI = dyn_cast<ConstantInt>(Idx);
212 ConstantInt *CI = dyn_cast<ConstantInt>(Idx);
249 if (ConstantInt *CI = dyn_cast<ConstantInt>(GN.Idx))
249 if (ConstantInt *CI = dyn_cast<ConstantInt>(GN.Idx))
947 return isa<ConstantInt>(N->Idx);
1109 IdxList[IdxC++] = ConstantInt::get(Int32Ty, 0);
lib/Target/Hexagon/HexagonConstPropagation.cpp 352 const ConstantInt *intToConst(const APInt &Val) const;
422 if (isa<ConstantInt>(C)) {
423 const ConstantInt *CI = cast<ConstantInt>(C);
423 const ConstantInt *CI = cast<ConstantInt>(C);
1086 const ConstantInt *CI = dyn_cast<ConstantInt>(C);
1086 const ConstantInt *CI = dyn_cast<ConstantInt>(C);
1093 const ConstantInt *MachineConstEvaluator::intToConst(const APInt &Val) const {
1094 return ConstantInt::get(CX, Val);
1988 const ConstantInt *CI = ConstantInt::get(Ty, V, true);
1988 const ConstantInt *CI = ConstantInt::get(Ty, V, true);
2031 const ConstantInt *CI = ConstantInt::get(Ty, Res, false);
2031 const ConstantInt *CI = ConstantInt::get(Ty, Res, false);
2244 const ConstantInt *C32 = ConstantInt::get(Ty, static_cast<int64_t>(V32));
2244 const ConstantInt *C32 = ConstantInt::get(Ty, static_cast<int64_t>(V32));
lib/Target/Hexagon/HexagonGenExtract.cpp 98 ConstantInt *CSL = nullptr, *CSR = nullptr, *CM = nullptr;
119 CSR = ConstantInt::get(Type::getInt32Ty(Ctx), 0);
128 CSL = ConstantInt::get(Type::getInt32Ty(Ctx), 0);
135 CSL = ConstantInt::get(Type::getInt32Ty(Ctx), 0);
173 CM = ConstantInt::get(Ctx, A);
lib/Target/Hexagon/HexagonISelLowering.cpp 2095 MutableArrayRef<ConstantInt*> Consts) const {
2104 Consts[i] = ConstantInt::get(IntTy, 0);
2109 const ConstantInt *CI = CN->getConstantIntValue();
2110 Consts[i] = ConstantInt::get(IntTy, CI->getValue().getSExtValue());
2114 Consts[i] = ConstantInt::get(IntTy, A.getZExtValue());
2128 SmallVector<ConstantInt*,4> Consts(Elem.size());
2211 SmallVector<ConstantInt*,8> Consts(Elem.size());
lib/Target/Hexagon/HexagonISelLowering.h 342 MutableArrayRef<ConstantInt*> Consts) const;
lib/Target/Hexagon/HexagonISelLoweringHVX.cpp 392 SmallVector<ConstantInt*, 128> Consts(VecLen);
lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp 632 if (!isa<ConstantInt>(InitV) || !cast<ConstantInt>(InitV)->isZero())
632 if (!isa<ConstantInt>(InitV) || !cast<ConstantInt>(InitV)->isZero())
648 if (auto *T = dyn_cast<ConstantInt>(IncV))
648 if (auto *T = dyn_cast<ConstantInt>(IncV))
951 if (PV.Inv && !isa<ConstantInt>(PV.Q))
1037 Value *Mask = ConstantInt::get(DestTy, (1u << TruncTy->getBitWidth()) - 1);
1046 if (ConstantInt *CI = dyn_cast<ConstantInt>(In->getOperand(i)))
1046 if (ConstantInt *CI = dyn_cast<ConstantInt>(In->getOperand(i)))
1048 In->setOperand(i, ConstantInt::get(DestTy, CI->getZExtValue()));
1265 if (auto *C = dyn_cast<ConstantInt>(V))
1265 if (auto *C = dyn_cast<ConstantInt>(V))
1412 if (isa<ConstantInt>(Op) && cast<ConstantInt>(Op)->isZero())
1412 if (isa<ConstantInt>(Op) && cast<ConstantInt>(Op)->isZero())
1426 ShVal = IRB.CreateShl(Op, ConstantInt::get(VTy, 1));
1456 Value *S = IRB.CreateLShr(PN, ConstantInt::get(PN->getType(), IterCount));
1535 auto *BMI = ConstantInt::get(P->getType(), APInt::getLowBitsSet(32, IC));
1541 auto *QI = dyn_cast<ConstantInt>(PV.Q);
1541 auto *QI = dyn_cast<ConstantInt>(PV.Q);
1548 auto *QVI = ConstantInt::get(QI->getType(), QV);
1548 auto *QVI = ConstantInt::get(QI->getType(), QV);
1564 if (const auto *CI = dyn_cast<const ConstantInt>(V))
1564 if (const auto *CI = dyn_cast<const ConstantInt>(V))
1571 if (const auto SI = dyn_cast<const ConstantInt>(I->getOperand(1)))
1675 ConstantInt *Msb = dyn_cast<ConstantInt>(I->getOperand(1));
1675 ConstantInt *Msb = dyn_cast<ConstantInt>(I->getOperand(1));
1722 ConstantInt *CA = dyn_cast<ConstantInt>(BitOp2->getOperand(1));
1722 ConstantInt *CA = dyn_cast<ConstantInt>(BitOp2->getOperand(1));
1723 ConstantInt *CB = dyn_cast<ConstantInt>(BitOp1->getOperand(1));
1723 ConstantInt *CB = dyn_cast<ConstantInt>(BitOp1->getOperand(1));
1739 ConstantInt *C0 = dyn_cast<ConstantInt>(I->getOperand(1));
1739 ConstantInt *C0 = dyn_cast<ConstantInt>(I->getOperand(1));
1749 ConstantInt *C1 = dyn_cast<ConstantInt>(And0->getOperand(1));
1749 ConstantInt *C1 = dyn_cast<ConstantInt>(And0->getOperand(1));
2161 if (ConstantInt *CI = dyn_cast<ConstantInt>(NumBytes)) {
2161 if (ConstantInt *CI = dyn_cast<ConstantInt>(NumBytes)) {
2214 Value *Thr = ConstantInt::get(Ty, Threshold);
lib/Target/Hexagon/HexagonOptimizeSZextends.cpp 109 ConstantInt *C = dyn_cast<ConstantInt>(AshrOp1);
109 ConstantInt *C = dyn_cast<ConstantInt>(AshrOp1);
120 C = dyn_cast<ConstantInt>(ShlOp1);
lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.cpp 420 ConstantInt *C1 = dyn_cast<ConstantInt>(I1->getOperand(i));
420 ConstantInt *C1 = dyn_cast<ConstantInt>(I1->getOperand(i));
421 ConstantInt *C2 = dyn_cast<ConstantInt>(I2->getOperand(i));
421 ConstantInt *C2 = dyn_cast<ConstantInt>(I2->getOperand(i));
lib/Target/Lanai/LanaiISelLowering.cpp 272 if (isa<ConstantInt>(CallOperandVal))
lib/Target/Mips/MipsConstantIslandPass.cpp 1658 const Constant *C = ConstantInt::get(Int32Ty, V);
lib/Target/Mips/MipsFastISel.cpp 299 if (isa<ConstantInt>(LHS) && !isa<ConstantInt>(RHS))
299 if (isa<ConstantInt>(LHS) && !isa<ConstantInt>(RHS))
322 if (const auto *C = dyn_cast<ConstantInt>(RHS))
322 if (const auto *C = dyn_cast<ConstantInt>(RHS))
360 const ConstantInt *CI = cast<ConstantInt>(C);
360 const ConstantInt *CI = cast<ConstantInt>(C);
459 else if (isa<ConstantInt>(C))
497 unsigned Idx = cast<ConstantInt>(Op)->getZExtValue();
502 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
502 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
509 ConstantInt *CI =
510 cast<ConstantInt>(cast<AddOperator>(Op)->getOperand(1));
1992 if (const auto *C = dyn_cast<ConstantInt>(I->getOperand(1))) {
1992 if (const auto *C = dyn_cast<ConstantInt>(I->getOperand(1))) {
lib/Target/Mips/MipsISelLowering.cpp 3834 if (isa<ConstantInt>(CallOperandVal))
lib/Target/Mips/MipsSEISelDAGToDAG.cpp 1227 const ConstantInt *Const32 = ConstantInt::get(Int32Ty, 32);
1227 const ConstantInt *Const32 = ConstantInt::get(Int32Ty, 32);
lib/Target/NVPTX/NVPTXAllocaHoisting.cpp 48 if (allocaInst && isa<ConstantInt>(allocaInst->getArraySize())) {
lib/Target/NVPTX/NVPTXAsmPrinter.cpp 1051 const ConstantInt *CI = nullptr;
1053 CI = dyn_cast<ConstantInt>(Initializer);
1712 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CPV)) {
1712 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CPV)) {
1804 unsigned char c = (unsigned char)cast<ConstantInt>(CPV)->getZExtValue();
1808 short int16 = (short)cast<ConstantInt>(CPV)->getZExtValue();
1812 if (const ConstantInt *constInt = dyn_cast<ConstantInt>(CPV)) {
1812 if (const ConstantInt *constInt = dyn_cast<ConstantInt>(CPV)) {
1818 if (const auto *constInt = dyn_cast_or_null<ConstantInt>(
1818 if (const auto *constInt = dyn_cast_or_null<ConstantInt>(
1834 if (const ConstantInt *constInt = dyn_cast<ConstantInt>(CPV)) {
1834 if (const ConstantInt *constInt = dyn_cast<ConstantInt>(CPV)) {
1840 if (const auto *constInt = dyn_cast_or_null<ConstantInt>(
1840 if (const auto *constInt = dyn_cast_or_null<ConstantInt>(
1920 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CPV)) {
1920 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CPV)) {
1977 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV))
1977 if (const ConstantInt *CI = dyn_cast<ConstantInt>(CV))
lib/Target/NVPTX/NVPTXGenericToNVVM.cpp 221 Value *Idx = ConstantInt::get(Type::getInt32Ty(M->getContext()), i);
lib/Target/NVPTX/NVPTXISelLowering.cpp 3802 MaybeAlign(cast<ConstantInt>(I.getArgOperand(1))->getZExtValue());
3822 MaybeAlign(cast<ConstantInt>(I.getArgOperand(1))->getZExtValue());
lib/Target/NVPTX/NVPTXImageOptimizer.cpp 42 void replaceWith(Instruction *From, ConstantInt *To);
96 replaceWith(&I, ConstantInt::getTrue(I.getContext()));
100 replaceWith(&I, ConstantInt::getFalse(I.getContext()));
113 replaceWith(&I, ConstantInt::getTrue(I.getContext()));
119 replaceWith(&I, ConstantInt::getFalse(I.getContext()));
131 replaceWith(&I, ConstantInt::getTrue(I.getContext()));
138 replaceWith(&I, ConstantInt::getFalse(I.getContext()));
146 void NVPTXImageOptimizer::replaceWith(Instruction *From, ConstantInt *To) {
lib/Target/NVPTX/NVPTXLowerAggrCopies.cpp 87 if (ConstantInt *LenCI = dyn_cast<ConstantInt>(IntrCall->getLength())) {
87 if (ConstantInt *LenCI = dyn_cast<ConstantInt>(IntrCall->getLength())) {
110 ConstantInt *CopyLen =
111 ConstantInt::get(Type::getInt32Ty(Context), NumLoads);
lib/Target/NVPTX/NVPTXUtilities.cpp 58 ConstantInt *Val = mdconst::dyn_extract<ConstantInt>(md->getOperand(i + 1));
58 ConstantInt *Val = mdconst::dyn_extract<ConstantInt>(md->getOperand(i + 1));
302 if (const ConstantInt *CI =
303 mdconst::dyn_extract<ConstantInt>(alignNode->getOperand(i))) {
lib/Target/NVPTX/NVVMIntrRange.cpp 74 ConstantAsMetadata::get(ConstantInt::get(Int32Ty, Low)),
75 ConstantAsMetadata::get(ConstantInt::get(Int32Ty, High))};
lib/Target/NVPTX/NVVMReflect.cpp 166 if (auto *Flag = mdconst::extract_or_null<ConstantInt>(
166 if (auto *Flag = mdconst::extract_or_null<ConstantInt>(
172 Call->replaceAllUsesWith(ConstantInt::get(Call->getType(), ReflectVal));
lib/Target/PowerPC/PPCFastISel.cpp 176 unsigned PPCMaterializeInt(const ConstantInt *CI, MVT VT,
355 unsigned Idx = cast<ConstantInt>(Op)->getZExtValue();
360 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
360 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
367 ConstantInt *CI =
368 cast<ConstantInt>(cast<AddOperator>(Op)->getOperand(1));
444 const ConstantInt *Offset =
445 ConstantInt::getSigned(OffsetTy, (int64_t)(Addr.Offset));
802 } else if (const ConstantInt *CI =
803 dyn_cast<ConstantInt>(BI->getCondition())) {
843 if (const ConstantInt *ConstInt = dyn_cast<ConstantInt>(SrcValue2)) {
843 if (const ConstantInt *ConstInt = dyn_cast<ConstantInt>(SrcValue2)) {
1305 if (const ConstantInt *ConstInt = dyn_cast<ConstantInt>(I->getOperand(1))) {
1305 if (const ConstantInt *ConstInt = dyn_cast<ConstantInt>(I->getOperand(1))) {
1717 if (const ConstantInt *CI = dyn_cast<ConstantInt>(RV)) {
1717 if (const ConstantInt *CI = dyn_cast<ConstantInt>(RV)) {
2199 unsigned PPCFastISel::PPCMaterializeInt(const ConstantInt *CI, MVT VT,
2252 else if (const ConstantInt *CI = dyn_cast<ConstantInt>(C))
2252 else if (const ConstantInt *CI = dyn_cast<ConstantInt>(C))
lib/Target/PowerPC/PPCISelLowering.cpp15453 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Mask)) {
15453 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Mask)) {
lib/Target/PowerPC/PPCTargetTransformInfo.cpp 551 HWLoopInfo.LoopDecrement = ConstantInt::get(HWLoopInfo.CountType, 1);
lib/Target/RISCV/RISCVTargetObjectFile.cpp 94 SSThreshold = mdconst::extract<ConstantInt>(MFE.Val)->getZExtValue();
lib/Target/Sparc/SparcISelLowering.cpp 3211 if (ConstantInt *C = dyn_cast<ConstantInt>(info.CallOperandVal)) {
3211 if (ConstantInt *C = dyn_cast<ConstantInt>(info.CallOperandVal)) {
lib/Target/SystemZ/SystemZISelLowering.cpp 853 if (auto *C = dyn_cast<ConstantInt>(SingleUser->getOperand(1)))
853 if (auto *C = dyn_cast<ConstantInt>(SingleUser->getOperand(1)))
1020 if (auto *C = dyn_cast<ConstantInt>(CallOperandVal))
1020 if (auto *C = dyn_cast<ConstantInt>(CallOperandVal))
1026 if (auto *C = dyn_cast<ConstantInt>(CallOperandVal))
1026 if (auto *C = dyn_cast<ConstantInt>(CallOperandVal))
1032 if (auto *C = dyn_cast<ConstantInt>(CallOperandVal))
1032 if (auto *C = dyn_cast<ConstantInt>(CallOperandVal))
1038 if (auto *C = dyn_cast<ConstantInt>(CallOperandVal))
1038 if (auto *C = dyn_cast<ConstantInt>(CallOperandVal))
1044 if (auto *C = dyn_cast<ConstantInt>(CallOperandVal))
1044 if (auto *C = dyn_cast<ConstantInt>(CallOperandVal))
lib/Target/SystemZ/SystemZTDC.cpp 233 auto *Const = dyn_cast<ConstantInt>(I.getOperand(1));
233 auto *Const = dyn_cast<ConstantInt>(I.getOperand(1));
266 auto *MaskC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
266 auto *MaskC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
345 Value *Zero32 = ConstantInt::get(Type::getInt32Ty(Ctx), 0);
361 Value *MaskVal = ConstantInt::get(Type::getInt64Ty(Ctx), Mask);
lib/Target/SystemZ/SystemZTargetTransformInfo.cpp 383 const ConstantInt *CVal =
385 ? dyn_cast_or_null<const ConstantInt>(C->getSplatValue())
386 : dyn_cast<const ConstantInt>(C));
802 if (!isa<LoadInst>(Op) && !isa<ConstantInt>(Op))
868 if (const ConstantInt *C = dyn_cast<ConstantInt>(I->getOperand(1)))
868 if (const ConstantInt *C = dyn_cast<ConstantInt>(I->getOperand(1)))
979 if (ConstantInt *CI = dyn_cast<ConstantInt>(UserI->getOperand(1)))
979 if (ConstantInt *CI = dyn_cast<ConstantInt>(UserI->getOperand(1)))
lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp 239 if (auto *I = cast<ConstantInt>(MD->getValue()))
239 if (auto *I = cast<ConstantInt>(MD->getValue()))
lib/Target/WebAssembly/WebAssemblyFastISel.cpp 275 unsigned Idx = cast<ConstantInt>(Op)->getZExtValue();
280 if (const auto *CI = dyn_cast<ConstantInt>(Op)) {
280 if (const auto *CI = dyn_cast<ConstantInt>(Op)) {
295 auto *CI = cast<ConstantInt>(cast<AddOperator>(Op)->getOperand(1));
295 auto *CI = cast<ConstantInt>(cast<AddOperator>(Op)->getOperand(1));
337 if (isa<ConstantInt>(LHS))
340 if (const auto *CI = dyn_cast<ConstantInt>(RHS)) {
340 if (const auto *CI = dyn_cast<ConstantInt>(RHS)) {
360 if (const auto *CI = dyn_cast<ConstantInt>(RHS)) {
360 if (const auto *CI = dyn_cast<ConstantInt>(RHS)) {
421 if (const ConstantInt *C = dyn_cast<ConstantInt>(ICmp->getOperand(1)))
421 if (const ConstantInt *C = dyn_cast<ConstantInt>(ICmp->getOperand(1)))
lib/Target/WebAssembly/WebAssemblyLowerGlobalDtors.cpp 87 auto *Priority = dyn_cast<ConstantInt>(CS->getOperand(0));
87 auto *Priority = dyn_cast<ConstantInt>(CS->getOperand(0));
lib/Target/X86/X86FastISel.cpp 148 unsigned X86MaterializeInt(const ConstantInt *CI, MVT VT);
664 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Val)) {
664 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Val)) {
887 if (const ConstantInt *CI = dyn_cast<ConstantInt>(U->getOperand(1))) {
887 if (const ConstantInt *CI = dyn_cast<ConstantInt>(U->getOperand(1))) {
913 Disp += SL->getElementOffset(cast<ConstantInt>(Op)->getZExtValue());
921 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
921 if (const ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
928 ConstantInt *CI =
929 cast<ConstantInt>(cast<AddOperator>(Op)->getOperand(1));
1365 static unsigned X86ChooseCmpImmediateOpcode(EVT VT, const ConstantInt *RHSC) {
1404 if (const ConstantInt *Op1C = dyn_cast<ConstantInt>(Op1)) {
1404 if (const ConstantInt *Op1C = dyn_cast<ConstantInt>(Op1)) {
2712 unsigned Depth = cast<ConstantInt>(II->getOperand(0))->getZExtValue();
2729 if (isa<ConstantInt>(MCI->getLength())) {
2732 uint64_t Len = cast<ConstantInt>(MCI->getLength())->getZExtValue();
2884 if (isa<ConstantInt>(LHS) && !isa<ConstantInt>(RHS) &&
2884 if (isa<ConstantInt>(LHS) && !isa<ConstantInt>(RHS) &&
2912 if (const auto *CI = dyn_cast<ConstantInt>(RHS)) {
2912 if (const auto *CI = dyn_cast<ConstantInt>(RHS)) {
3032 if (!isa<ConstantInt>(Index))
3034 unsigned Idx = cast<ConstantInt>(Index)->getZExtValue();
3257 if (auto *CI = dyn_cast<ConstantInt>(Val)) {
3257 if (auto *CI = dyn_cast<ConstantInt>(Val)) {
3428 } else if (isa<ConstantInt>(ArgVal) || isa<ConstantPointerNull>(ArgVal)) {
3684 unsigned X86FastISel::X86MaterializeInt(const ConstantInt *CI, MVT VT) {
3855 if (const auto *CI = dyn_cast<ConstantInt>(C))
3855 if (const auto *CI = dyn_cast<ConstantInt>(C))
lib/Target/X86/X86FrameLowering.cpp 2544 ConstantInt *ValConst = dyn_cast_or_null<ConstantInt>(NodeVal->getValue());
2544 ConstantInt *ValConst = dyn_cast_or_null<ConstantInt>(NodeVal->getValue());
lib/Target/X86/X86ISelDAGToDAG.cpp 3577 const ConstantInt *Val = cast<ConstantSDNode>(Imm)->getConstantIntValue();
3610 const ConstantInt *Val = cast<ConstantSDNode>(Imm)->getConstantIntValue();
lib/Target/X86/X86ISelLowering.cpp 2294 ConstantInt::get(Type::getInt32Ty(IRB.getContext()), Offset),
6033 if (auto *CInt = dyn_cast<ConstantInt>(Cst)) {
9657 ConstVecOps[i] = ConstantInt::get(Context, C->getAPIntValue());
18876 ConstantInt::get(*DAG.getContext(), FF.zext(64)), PtrVT);
26535 if (auto *C = dyn_cast<ConstantInt>(AI->getValOperand()))
26535 if (auto *C = dyn_cast<ConstantInt>(AI->getValOperand()))
39000 ConstantInt *Elem =
39001 dyn_cast<ConstantInt>(Init->getAggregateElement(j));
45510 if (ConstantInt *C = dyn_cast<ConstantInt>(info.CallOperandVal)) {
45510 if (ConstantInt *C = dyn_cast<ConstantInt>(info.CallOperandVal)) {
45516 if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
45516 if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
45522 if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
45522 if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
45528 if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
45528 if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
45534 if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
45534 if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
45540 if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
45540 if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
45552 if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
45552 if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
45559 if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
45559 if (ConstantInt *C = dyn_cast<ConstantInt>(CallOperandVal)) {
45692 if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
45706 if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
lib/Target/X86/X86MCInstLower.cpp 1734 } else if (auto *CI = dyn_cast<ConstantInt>(COp)) {
lib/Target/X86/X86ShuffleDecodeConstantPool.cpp 61 if (!COp || (!isa<UndefValue>(COp) && !isa<ConstantInt>(COp)))
70 auto *Elt = cast<ConstantInt>(COp);
70 auto *Elt = cast<ConstantInt>(COp);
81 if (!COp || (!isa<UndefValue>(COp) && !isa<ConstantInt>(COp)))
91 MaskBits.insertBits(cast<ConstantInt>(COp)->getValue(), BitOffset);
lib/Target/XCore/XCoreISelDAGToDAG.cpp 147 ConstantInt::get(Type::getInt32Ty(*CurDAG->getContext()), Val),
lib/Target/XCore/XCoreISelLowering.cpp 300 Constant *Idx = ConstantInt::get(Ty, Offset);
lib/Target/XCore/XCoreInstrInfo.cpp 444 const Constant *C = ConstantInt::get(
lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp 244 Constant *Mask = ConstantInt::get(I.getType(), MOps.Mask);
lib/Transforms/CFGuard/CFGuard.cpp 229 if (auto *MD =
230 mdconst::extract_or_null<ConstantInt>(M.getModuleFlag("cfguard")))
lib/Transforms/Coroutines/CoroCleanup.cpp 73 II->replaceAllUsesWith(ConstantInt::getTrue(Context));
lib/Transforms/Coroutines/CoroElide.cpp 119 auto *False = ConstantInt::getFalse(C);
119 auto *False = ConstantInt::getFalse(C);
lib/Transforms/Coroutines/CoroFrame.cpp 453 if (auto *CI = dyn_cast<ConstantInt>(AI->getArraySize()))
453 if (auto *CI = dyn_cast<ConstantInt>(AI->getArraySize()))
620 ConstantInt::get(Type::getInt32Ty(C), 0),
621 ConstantInt::get(Type::getInt32Ty(C), Index),
625 if (auto *CI = dyn_cast<ConstantInt>(AI->getArraySize())) {
625 if (auto *CI = dyn_cast<ConstantInt>(AI->getArraySize())) {
628 Indices.push_back(ConstantInt::get(Type::getInt32Ty(C), 0));
lib/Transforms/Coroutines/CoroInstr.h 56 ConstantInt *getRawIndex() const {
57 return cast<ConstantInt>(getArgOperand(IndexArg));
211 return cast<ConstantInt>(getArgOperand(SizeArg))->getZExtValue();
215 return cast<ConstantInt>(getArgOperand(AlignArg))->getZExtValue();
345 return cast<ConstantInt>(getArgOperand(AlignArg))->getZExtValue();
467 return cast<ConstantInt>(getArgOperand(AlignArg))->getZExtValue();
lib/Transforms/Coroutines/CoroInternal.h 148 ConstantInt *getIndex(uint64_t Value) const {
149 return ConstantInt::get(getIndexType(), Value);
lib/Transforms/Coroutines/CoroSplit.cpp 256 End->replaceAllUsesWith(InResume ? ConstantInt::getTrue(Context)
257 : ConstantInt::getFalse(Context));
293 ConstantInt *IndexVal = Shape.getIndex(SuspendIndex);
799 auto *SizeConstant = ConstantInt::get(SizeIntrin->getType(), Size);
929 if (ConstantInt *Cond = dyn_cast<ConstantInt>(V)) {
929 if (ConstantInt *Cond = dyn_cast<ConstantInt>(V)) {
lib/Transforms/Coroutines/Coroutines.cpp 109 auto *IndexVal = ConstantInt::get(Type::getInt8Ty(Context), Index);
109 auto *IndexVal = ConstantInt::get(Type::getInt8Ty(Context), Index);
621 if (!isa<ConstantInt>(V)) {
lib/Transforms/IPO/ArgumentPromotion.cpp 181 Indices.push_back(cast<ConstantInt>(*II)->getSExtValue());
263 ConstantInt::get(Type::getInt32Ty(F->getContext()), 0), nullptr};
265 Idxs[1] = ConstantInt::get(Type::getInt32Ty(F->getContext()), i);
292 Ops.push_back(ConstantInt::get(IdxTy, II));
393 Value *Idxs[2] = {ConstantInt::get(Type::getInt32Ty(F->getContext()), 0),
397 Idxs[1] = ConstantInt::get(Type::getInt32Ty(F->getContext()), i);
443 Operands.push_back(cast<ConstantInt>(*II)->getSExtValue());
637 if (ConstantInt *CI = dyn_cast<ConstantInt>(*II))
637 if (ConstantInt *CI = dyn_cast<ConstantInt>(*II))
696 if (ConstantInt *C = dyn_cast<ConstantInt>(*i))
696 if (ConstantInt *C = dyn_cast<ConstantInt>(*i))
lib/Transforms/IPO/Attributor.cpp 3574 auto *Num = cast<ConstantInt>(MallocCall->getOperand(0));
3574 auto *Num = cast<ConstantInt>(MallocCall->getOperand(0));
3575 auto *SizeT = dyn_cast<ConstantInt>(MallocCall->getOperand(1));
3575 auto *SizeT = dyn_cast<ConstantInt>(MallocCall->getOperand(1));
3578 ConstantInt::get(MallocCall->getOperand(0)->getType(), TotalSize);
3580 Size = cast<ConstantInt>(MallocCall->getOperand(0));
3605 BI, ConstantInt::get(F->getContext(), APInt(8, 0, false)), Size,
3606 ConstantInt::get(Type::getInt1Ty(F->getContext()), false)};
3719 if (auto *Size = dyn_cast<ConstantInt>(I.getOperand(0)))
3719 if (auto *Size = dyn_cast<ConstantInt>(I.getOperand(0)))
3727 if (auto *Num = dyn_cast<ConstantInt>(I.getOperand(0)))
3727 if (auto *Num = dyn_cast<ConstantInt>(I.getOperand(0)))
3728 if (auto *Size = dyn_cast<ConstantInt>(I.getOperand(1)))
3728 if (auto *Size = dyn_cast<ConstantInt>(I.getOperand(1)))
lib/Transforms/IPO/CrossDSOCFI.cpp 50 ConstantInt *extractNumericTypeId(MDNode *MD);
65 ConstantInt *CrossDSOCFI::extractNumericTypeId(MDNode *MD) {
70 auto C = dyn_cast_or_null<ConstantInt>(TM->getValue());
88 if (ConstantInt *TypeId = extractNumericTypeId(Type))
97 if (ConstantInt *TypeId =
143 ConstantInt *CaseTypeId = ConstantInt::get(Type::getInt64Ty(Ctx), TypeId);
143 ConstantInt *CaseTypeId = ConstantInt::get(Type::getInt64Ty(Ctx), TypeId);
lib/Transforms/IPO/GlobalDCE.cpp 166 (cast<ConstantInt>(LTOPostLinkMD->getValue())->getZExtValue() != 0);
181 cast<ConstantInt>(
244 auto *Offset = dyn_cast<ConstantInt>(CI->getArgOperand(1));
244 auto *Offset = dyn_cast<ConstantInt>(CI->getArgOperand(1));
lib/Transforms/IPO/GlobalOpt.cpp 386 ConstantInt *IdxVal = dyn_cast<ConstantInt>(GEPI.getOperand());
386 ConstantInt *IdxVal = dyn_cast<ConstantInt>(GEPI.getOperand());
561 unsigned Val = cast<ConstantInt>(GEP->getOperand(2))->getZExtValue();
838 ConstantInt *NElements, const DataLayout &DL,
886 ConstantInt::getFalse(GV->getContext()),
894 new StoreInst(ConstantInt::getTrue(GV->getContext()), InitBool, false,
920 LV = ConstantInt::getFalse(GV->getContext());
1222 unsigned FieldNo = cast<ConstantInt>(GEPI->getOperand(2))->getZExtValue();
1315 ConstantInt::get(IntPtrTy, TypeSize),
1335 Constant *ConstantZero = ConstantInt::get(CI->getArgOperand(0)->getType(), 0);
1505 if (ConstantInt *NElements = dyn_cast<ConstantInt>(NElems))
1505 if (ConstantInt *NElements = dyn_cast<ConstantInt>(NElems))
1523 if (NElems == ConstantInt::get(CI->getArgOperand(0)->getType(), 1))
1541 Value *AllocSize = ConstantInt::get(IntPtrTy, TypeSize);
1542 Value *NumElements = ConstantInt::get(IntPtrTy, AT->getNumElements());
1631 ConstantInt::getFalse(GV->getContext()),
1649 auto *CI = dyn_cast<ConstantInt>(OtherVal);
1649 auto *CI = dyn_cast<ConstantInt>(OtherVal);
1653 auto *CIInit = dyn_cast<ConstantInt>(GV->getInitializer());
1653 auto *CIInit = dyn_cast<ConstantInt>(GV->getInitializer());
1704 StoreVal = ConstantInt::get(Type::getInt1Ty(GV->getContext()),
2403 ConstantInt *CU = cast<ConstantInt>(Addr->getOperand(OpNo));
2403 ConstantInt *CU = cast<ConstantInt>(Addr->getOperand(OpNo));
2412 ConstantInt *CI = cast<ConstantInt>(Addr->getOperand(OpNo));
2412 ConstantInt *CI = cast<ConstantInt>(Addr->getOperand(OpNo));
2560 ConstantInt *CI = cast<ConstantInt>(GEP->getOperand(2));
2560 ConstantInt *CI = cast<ConstantInt>(GEP->getOperand(2));
lib/Transforms/IPO/GlobalSplit.cpp 61 !isa<ConstantInt>(GEP->getOperand(1)) ||
62 !cast<ConstantInt>(GEP->getOperand(1))->isZero() ||
63 !isa<ConstantInt>(GEP->getOperand(2)))
92 uint64_t ByteOffset = cast<ConstantInt>(
110 ConstantInt::get(Int32Ty, ByteOffset - SplitBegin)),
117 unsigned I = cast<ConstantInt>(GEP->getOperand(2))->getZExtValue();
122 Ops.push_back(ConstantInt::get(Int32Ty, 0));
lib/Transforms/IPO/LowerTypeTests.cpp 236 auto *CI = mdconst::extract_or_null<ConstantInt>(
236 auto *CI = mdconst::extract_or_null<ConstantInt>(
564 cast<ConstantInt>(
583 B.CreateAnd(BitOffset, ConstantInt::get(BitsType, BitWidth - 1));
584 Value *BitMask = B.CreateShl(ConstantInt::get(BitsType, 1), BitIndex);
586 return B.CreateICmpNE(MaskedBits, ConstantInt::get(BitsType, 0));
624 ConstantExpr::getIntToPtr(ConstantInt::get(Int8Ty, Mask), Int8PtrTy));
638 Constant *Idxs[] = {ConstantInt::get(IntPtrTy, 0),
639 ConstantInt::get(IntPtrTy, ByteArrayOffsets[I])};
683 return B.CreateICmpNE(ByteAndMask, ConstantInt::get(Int8Ty, 0));
696 cast<ConstantInt>(
731 return ConstantInt::getFalse(M.getContext());
736 return ConstantInt::getTrue(M.getContext());
764 ConstantInt::get(Int8Ty, DL.getPointerSizeInBits(0)),
808 P->addIncoming(ConstantInt::get(Int1Ty, 0), InitialBB);
873 Constant *CombinedGlobalIdxs[] = {ConstantInt::get(Int32Ty, 0),
874 ConstantInt::get(Int32Ty, I * 2)};
918 Storage = cast<ConstantInt>(C)->getZExtValue();
930 uint64_t BitSize = cast<ConstantInt>(TIL.SizeM1)->getZExtValue() + 1;
976 ConstantInt::get(isa<IntegerType>(Ty) ? Ty : Int64Ty, Const);
990 auto *MinC = ConstantAsMetadata::get(ConstantInt::get(IntPtrTy, Min));
991 auto *MaxC = ConstantAsMetadata::get(ConstantInt::get(IntPtrTy, Max));
1126 Int8Ty, CombinedGlobalAddr, ConstantInt::get(IntPtrTy, BSI.ByteOffset)),
1127 TIL.AlignLog2 = ConstantInt::get(Int8Ty, BSI.AlignLog2);
1128 TIL.SizeM1 = ConstantInt::get(IntPtrTy, BSI.BitSize - 1);
1140 TIL.InlineBits = ConstantInt::get(
1185 auto OffsetInt = dyn_cast<ConstantInt>(OffsetConstMD->getValue());
1513 ArrayRef<Constant *>{ConstantInt::get(IntPtrTy, 0),
1514 ConstantInt::get(IntPtrTy, I)}),
1576 ConstantInt::get(Int64Ty, IndirectIndex))));
lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp 334 llvm::ConstantInt::get(Type::getInt8Ty(Ctx), Linkage)));
357 ConstantInt::get(Type::getInt8Ty(Ctx), A.getVisibility())),
359 ConstantInt::get(Type::getInt8Ty(Ctx), A.isWeakForLinker())),
432 if (auto *MD = mdconst::extract_or_null<ConstantInt>(
432 if (auto *MD = mdconst::extract_or_null<ConstantInt>(
lib/Transforms/IPO/WholeProgramDevirt.cpp 427 auto *CI = dyn_cast<ConstantInt>(Arg);
427 auto *CI = dyn_cast<ConstantInt>(Arg);
803 cast<ConstantInt>(
1179 EvalArgs.push_back(ConstantInt::get(ArgTy, Args[I]));
1184 !isa<ConstantInt>(RetVal))
1186 Target.RetVal = cast<ConstantInt>(RetVal)->getZExtValue();
1196 ConstantInt::get(cast<IntegerType>(Call.CS.getType()), TheRetVal));
1253 ConstantExpr::getIntToPtr(ConstantInt::get(Int32Ty, Const), Int8PtrTy));
1273 return ConstantInt::get(IntTy, Storage);
1285 auto *MinC = ConstantAsMetadata::get(ConstantInt::get(IntPtrTy, Min));
1286 auto *MaxC = ConstantAsMetadata::get(ConstantInt::get(IntPtrTy, Max));
1316 ConstantInt::get(Int64Ty, M->Offset));
1377 auto IsBitSet = B.CreateICmpNE(BitsAndBit, ConstantInt::get(Int8Ty, 0));
1482 Constant *ByteConst = ConstantInt::get(Int32Ty, OffsetByte);
1483 Constant *BitConst = ConstantInt::get(Int8Ty, 1ULL << OffsetBit);
1529 ArrayRef<Constant *>{ConstantInt::get(Int32Ty, 0),
1530 ConstantInt::get(Int32Ty, 1)}),
1753 auto True = ConstantInt::getTrue(M.getContext());
lib/Transforms/InstCombine/InstCombineAddSub.cpp 842 ConstantInt::get(X->getType(), *C2 + C1->trunc(C2->getBitWidth()));
905 return BinaryOperator::CreateXor(Op0, ConstantInt::get(Add.getType(), *C2));
941 return BinaryOperator::CreateAnd(NotX, ConstantInt::get(Ty, 1));
1044 ConstantInt::get(X->getType()->getContext(), C0 * C1);
1095 return CallInst::Create(getUAddSat(), { X, ConstantInt::get(Ty, *C) });
1227 if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
1227 if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
1228 Value *XorLHS = nullptr; ConstantInt *XorRHS = nullptr;
1249 Constant *ShAmt = ConstantInt::get(Ty, ExtendAmt);
1275 auto *Shl = BinaryOperator::CreateShl(LHS, ConstantInt::get(Ty, 1));
1322 if (ConstantInt *CRHS = dyn_cast<ConstantInt>(RHS)) {
1322 if (ConstantInt *CRHS = dyn_cast<ConstantInt>(RHS)) {
1325 ConstantInt *C2;
1726 Builder.CreateAdd(Op0, ConstantInt::get(I.getType(), 1)), X);
1903 Constant *NegDivC = ConstantInt::get(I.getType(), -(*DivC));
2001 Value *Cmp = Builder.CreateICmpSLT(A, ConstantInt::getNullValue(Ty));
lib/Transforms/InstCombine/InstCombineAndOrXor.cpp 71 return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 0);
73 return ConstantInt::get(CmpInst::makeCmpResultType(LHS->getType()), 1);
105 NewRHS = ConstantInt::get(I.getType(), C->byteSwap());
118 ConstantInt *OpRHS,
119 ConstantInt *AndRHS,
177 return Builder.CreateICmp(Pred, V, ConstantInt::get(Ty, Hi));
183 Builder.CreateSub(V, ConstantInt::get(Ty, Lo), V->getName() + ".off");
184 Constant *HiMinusLo = ConstantInt::get(Ty, Hi - Lo);
232 ConstantInt *ACst = dyn_cast<ConstantInt>(A);
232 ConstantInt *ACst = dyn_cast<ConstantInt>(A);
233 ConstantInt *BCst = dyn_cast<ConstantInt>(B);
233 ConstantInt *BCst = dyn_cast<ConstantInt>(B);
234 ConstantInt *CCst = dyn_cast<ConstantInt>(C);
234 ConstantInt *CCst = dyn_cast<ConstantInt>(C);
299 Y = ConstantInt::get(X->getType(), Mask);
300 Z = ConstantInt::get(X->getType(), 0);
456 ConstantInt *BCst = dyn_cast<ConstantInt>(B);
456 ConstantInt *BCst = dyn_cast<ConstantInt>(B);
459 ConstantInt *CCst = dyn_cast<ConstantInt>(C);
459 ConstantInt *CCst = dyn_cast<ConstantInt>(C);
462 ConstantInt *DCst = dyn_cast<ConstantInt>(D);
462 ConstantInt *DCst = dyn_cast<ConstantInt>(D);
465 ConstantInt *ECst = dyn_cast<ConstantInt>(E);
465 ConstantInt *ECst = dyn_cast<ConstantInt>(E);
476 ECst = cast<ConstantInt>(ConstantExpr::getXor(DCst, ECst));
511 Value *NewMask = ConstantInt::get(BCst->getType(), BorD);
512 Value *NewMaskedValue = ConstantInt::get(BCst->getType(), BandBxorDorE);
543 return ConstantInt::get(LHS->getType(), !IsAnd);
565 return ConstantInt::get(LHS->getType(), !IsAnd);
677 ConstantInt *BCst = dyn_cast<ConstantInt>(B);
677 ConstantInt *BCst = dyn_cast<ConstantInt>(B);
680 ConstantInt *DCst = dyn_cast<ConstantInt>(D);
680 ConstantInt *DCst = dyn_cast<ConstantInt>(D);
722 ConstantInt *CCst = dyn_cast<ConstantInt>(C);
722 ConstantInt *CCst = dyn_cast<ConstantInt>(C);
725 ConstantInt *ECst = dyn_cast<ConstantInt>(E);
725 ConstantInt *ECst = dyn_cast<ConstantInt>(E);
729 CCst = cast<ConstantInt>(ConstantExpr::getXor(BCst, CCst));
731 ECst = cast<ConstantInt>(ConstantExpr::getXor(DCst, ECst));
737 return ConstantInt::get(LHS->getType(), !IsAnd);
756 ConstantInt *RangeStart = dyn_cast<ConstantInt>(Cmp0->getOperand(1));
756 ConstantInt *RangeStart = dyn_cast<ConstantInt>(Cmp0->getOperand(1));
837 Value *Or = Builder.CreateOr(X, ConstantInt::get(X->getType(), Xor));
838 return Builder.CreateICmp(Pred, Or, ConstantInt::get(X->getType(), *C2));
850 Value *Add = Builder.CreateAdd(X, ConstantInt::get(X->getType(), -(*C1)));
852 return Builder.CreateICmp(NewPred, Add, ConstantInt::get(X->getType(), 1));
872 ConstantInt *LHSC = dyn_cast<ConstantInt>(LHS->getOperand(1));
872 ConstantInt *LHSC = dyn_cast<ConstantInt>(LHS->getOperand(1));
873 ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS->getOperand(1));
873 ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS->getOperand(1));
1018 return Builder.CreateICmpULT(X, ConstantInt::get(X->getType(), HighestBit),
1039 return Builder.CreateICmpEQ(CtPop, ConstantInt::get(CtPop->getType(), 1));
1047 return Builder.CreateICmpNE(CtPop, ConstantInt::get(CtPop->getType(), 1));
1200 ConstantInt *LHSC = dyn_cast<ConstantInt>(LHS->getOperand(1));
1200 ConstantInt *LHSC = dyn_cast<ConstantInt>(LHS->getOperand(1));
1201 ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS->getOperand(1));
1201 ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS->getOperand(1));
1222 ConstantInt *AndC, *SmallC = nullptr, *BigC = nullptr;
1246 Value *NewVal = ConstantInt::get(AndC->getType()->getContext(), N);
1656 if (auto *ScalarC = dyn_cast<ConstantInt>(C))
1656 if (auto *ScalarC = dyn_cast<ConstantInt>(C))
1668 auto *CI = dyn_cast<ConstantInt>(Elt);
1668 auto *CI = dyn_cast<ConstantInt>(Elt);
1758 Value *IsZero = Builder.CreateICmpEQ(X, ConstantInt::get(I.getType(), 0));
1765 Constant *NewC = ConstantInt::get(I.getType(), *C & *XorC);
1780 Value *And = Builder.CreateAnd(X, ConstantInt::get(I.getType(),
1783 return BinaryOperator::CreateOr(And, ConstantInt::get(I.getType(),
1808 if (ConstantInt *AndRHS = dyn_cast<ConstantInt>(Op1)) {
1808 if (ConstantInt *AndRHS = dyn_cast<ConstantInt>(Op1)) {
1825 ConstantInt *C1;
1845 if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1)))
1845 if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1)))
1853 Value *X = nullptr; ConstantInt *YC = nullptr;
1972 return SelectInst::Create(NewICmpInst, X, ConstantInt::getNullValue(Ty));
2198 ConstantInt *LHSC = dyn_cast<ConstantInt>(LHS->getOperand(1));
2198 ConstantInt *LHSC = dyn_cast<ConstantInt>(LHS->getOperand(1));
2199 ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS->getOperand(1));
2199 ConstantInt *RHSC = dyn_cast<ConstantInt>(RHS->getOperand(1));
2221 ConstantInt *LAddC, *RAddC;
2229 ConstantInt *MaxAddC = nullptr;
2246 Value *MaskC = ConstantInt::get(LAddC->getType(), ~DiffC);
2299 Builder.CreateAdd(B, ConstantInt::getSigned(B->getType(), -1)), A);
2338 ConstantInt *AddC;
2491 return BinaryOperator::CreateXor(Or, ConstantInt::get(I.getType(), *CV));
2499 ConstantInt *C1 = dyn_cast<ConstantInt>(C);
2499 ConstantInt *C1 = dyn_cast<ConstantInt>(C);
2500 ConstantInt *C2 = dyn_cast<ConstantInt>(D);
2500 ConstantInt *C2 = dyn_cast<ConstantInt>(D);
2524 ConstantInt *C3 = nullptr, *C4 = nullptr;
2681 return SelectInst::Create(A, ConstantInt::getSigned(I.getType(), -1), Op1);
2684 return SelectInst::Create(A, ConstantInt::getSigned(I.getType(), -1), Op0);
2691 ConstantInt *CI;
2692 if (Op0->hasOneUse() && !isa<ConstantInt>(Op1) &&
2723 return SelectInst::Create(NewICmpInst, ConstantInt::getAllOnesValue(Ty),
2831 Value *Zero = ConstantInt::getNullValue(LHS0->getType());
2840 Value *MinusOne = ConstantInt::getAllOnesValue(LHS0->getType());
3104 Constant *NewC = ConstantInt::get(I.getType(), *C + *RHSC);
3109 Constant *NewC = ConstantInt::get(I.getType(), *C + *RHSC);
3116 Constant *NewC = ConstantInt::get(I.getType(), *C ^ *RHSC);
3125 if (ConstantInt *RHSC = dyn_cast<ConstantInt>(Op1)) {
3125 if (ConstantInt *RHSC = dyn_cast<ConstantInt>(Op1)) {
3127 if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1))) {
3127 if (ConstantInt *Op0CI = dyn_cast<ConstantInt>(Op0I->getOperand(1))) {
3132 ConstantInt *C1;
3136 (C1 = dyn_cast<ConstantInt>(E1->getOperand(1)))) {
3138 ConstantInt *C2 = Op0CI, *C3 = RHSC;
3145 Value *FoldVal = ConstantInt::get(Opnd0->getType(), FoldConst);
3231 Value *Cmp = Builder.CreateICmpSLT(A, ConstantInt::getNullValue(Ty));
lib/Transforms/InstCombine/InstCombineAtomicRMW.cpp 34 auto C = dyn_cast<ConstantInt>(RMWI.getValOperand());
71 auto C = dyn_cast<ConstantInt>(RMWI.getValOperand());
141 RMWI.setOperand(1, ConstantInt::get(RMWI.getType(), 0));
lib/Transforms/InstCombine/InstCombineCalls.cpp 103 ? cast<ConstantInt>(Elt)->isNegative()
105 BoolVec.push_back(ConstantInt::get(BoolTy, Sign));
136 ConstantInt *MemOpLength = dyn_cast<ConstantInt>(MI->getLength());
136 ConstantInt *MemOpLength = dyn_cast<ConstantInt>(MI->getLength());
174 mdconst::hasa<ConstantInt>(M->getOperand(0)) &&
175 mdconst::extract<ConstantInt>(M->getOperand(0))->isZero() &&
177 mdconst::hasa<ConstantInt>(M->getOperand(1)) &&
178 mdconst::extract<ConstantInt>(M->getOperand(1))->getValue() ==
245 ConstantInt *LenC = dyn_cast<ConstantInt>(MI->getLength());
245 ConstantInt *LenC = dyn_cast<ConstantInt>(MI->getLength());
246 ConstantInt *FillC = dyn_cast<ConstantInt>(MI->getValue());
246 ConstantInt *FillC = dyn_cast<ConstantInt>(MI->getValue());
272 StoreInst *S = Builder.CreateStore(ConstantInt::get(ITy, Fill), Dest,
360 auto CInt = dyn_cast<ConstantInt>(Arg1);
376 auto SubElt = cast<ConstantInt>(CDV->getElementAsConstant(SubEltIdx));
405 auto ShiftAmt = ConstantInt::get(SVT, Count.zextOrTrunc(BitWidth));
488 auto *COp = dyn_cast_or_null<ConstantInt>(CElt);
488 auto *COp = dyn_cast_or_null<ConstantInt>(CElt);
515 ConstantVec.push_back(ConstantInt::getNullValue(SVT));
531 ShiftVecAmts.push_back(ConstantInt::get(SVT, Idx));
669 auto *CInt = dyn_cast<ConstantInt>(II.getArgOperand(2));
669 auto *CInt = dyn_cast<ConstantInt>(II.getArgOperand(2));
727 ConstantInt *CILength, ConstantInt *CIIndex,
727 ConstantInt *CILength, ConstantInt *CIIndex,
731 Constant *Args[] = {ConstantInt::get(IntTy64, Val),
738 ConstantInt *CI0 =
739 C0 ? dyn_cast_or_null<ConstantInt>(C0->getAggregateElement((unsigned)0))
877 ConstantInt *CI00 =
878 C0 ? dyn_cast_or_null<ConstantInt>(C0->getAggregateElement((unsigned)0))
880 ConstantInt *CI10 =
881 C1 ? dyn_cast_or_null<ConstantInt>(C1->getAggregateElement((unsigned)0))
893 Constant *Args[] = {ConstantInt::get(IntTy64, Val.getZExtValue()),
902 Constant *CILength = ConstantInt::get(IntTy8, Length, false);
903 Constant *CIIndex = ConstantInt::get(IntTy8, Index, false);
934 if (!COp || (!isa<UndefValue>(COp) && !isa<ConstantInt>(COp)))
942 int8_t Index = cast<ConstantInt>(COp)->getValue().getZExtValue();
952 Indexes[I] = ConstantInt::get(MaskEltTy, Index);
981 if (!COp || (!isa<UndefValue>(COp) && !isa<ConstantInt>(COp)))
989 APInt Index = cast<ConstantInt>(COp)->getValue();
1002 Indexes[I] = ConstantInt::get(MaskEltTy, Index);
1029 if (!COp || (!isa<UndefValue>(COp) && !isa<ConstantInt>(COp)))
1037 uint32_t Index = cast<ConstantInt>(COp)->getZExtValue();
1039 Indexes[I] = ConstantInt::get(MaskEltTy, Index);
1052 unsigned Alignment = cast<ConstantInt>(II.getArgOperand(1))->getZExtValue();
1089 cast<ConstantInt>(II.getArgOperand(2))->getZExtValue());
1227 auto *C = ConstantInt::get(Op0->getType(), DefiniteZeros);
1248 ConstantAsMetadata::get(ConstantInt::get(IT, DefiniteZeros)),
1249 ConstantAsMetadata::get(ConstantInt::get(IT, PossibleZeros + 1))};
1285 ConstantAsMetadata::get(ConstantInt::get(IT, MinCount)),
1286 ConstantAsMetadata::get(ConstantInt::get(IT, MaxCount + 1))};
1419 if (!COp || !isa<ConstantInt>(COp))
1422 Indexes[I] = cast<ConstantInt>(COp)->getLimitedValue();
1442 auto *IntrAlign = dyn_cast<ConstantInt>(II.getArgOperand(1));
1442 auto *IntrAlign = dyn_cast<ConstantInt>(II.getArgOperand(1));
1809 if (ConstantInt *CI = dyn_cast<ConstantInt>(NumBytes))
1809 if (ConstantInt *CI = dyn_cast<ConstantInt>(NumBytes))
1897 Value *CV = ConstantInt::get(X->getType(), C);
1919 if (ConstantInt *Power = dyn_cast<ConstantInt>(II->getArgOperand(1))) {
1919 if (ConstantInt *Power = dyn_cast<ConstantInt>(II->getArgOperand(1))) {
1953 Constant *WidthC = ConstantInt::get(Ty, BitWidth);
2034 IID, X, ConstantInt::get(Arg1->getType(), NewC)));
2099 return replaceInstUsesWith(*SI, ConstantInt::get(Ty, Min));
2104 return replaceInstUsesWith(*SI, ConstantInt::get(Ty, Max));
2148 IID, X, ConstantInt::get(II->getType(), NewVal)));
2415 if (auto *C = dyn_cast<ConstantInt>(II->getArgOperand(1))) {
2415 if (auto *C = dyn_cast<ConstantInt>(II->getArgOperand(1))) {
2422 return replaceInstUsesWith(CI, ConstantInt::get(II->getType(), 0));
2424 if (auto *InC = dyn_cast<ConstantInt>(II->getArgOperand(0))) {
2424 if (auto *InC = dyn_cast<ConstantInt>(II->getArgOperand(0))) {
2429 return replaceInstUsesWith(CI, ConstantInt::get(II->getType(), Result));
2439 if (auto *C = dyn_cast<ConstantInt>(II->getArgOperand(1))) {
2439 if (auto *C = dyn_cast<ConstantInt>(II->getArgOperand(1))) {
2445 return replaceInstUsesWith(CI, ConstantInt::get(II->getType(), 0));
2447 if (auto *InC = dyn_cast<ConstantInt>(II->getArgOperand(0))) {
2447 if (auto *InC = dyn_cast<ConstantInt>(II->getArgOperand(0))) {
2450 return replaceInstUsesWith(CI, ConstantInt::get(II->getType(), Result));
2634 if (auto *R = dyn_cast<ConstantInt>(II->getArgOperand(2))) {
2634 if (auto *R = dyn_cast<ConstantInt>(II->getArgOperand(2))) {
2675 if (auto *R = dyn_cast<ConstantInt>(II->getArgOperand(4))) {
2675 if (auto *R = dyn_cast<ConstantInt>(II->getArgOperand(4))) {
2706 auto *C = dyn_cast<ConstantInt>(Mask);
2706 auto *C = dyn_cast<ConstantInt>(Mask);
2860 if (auto *C = dyn_cast<ConstantInt>(II->getArgOperand(2))) {
2860 if (auto *C = dyn_cast<ConstantInt>(II->getArgOperand(2))) {
2914 ConstantInt *CILength =
2915 C1 ? dyn_cast_or_null<ConstantInt>(C1->getAggregateElement((unsigned)0))
2917 ConstantInt *CIIndex =
2918 C1 ? dyn_cast_or_null<ConstantInt>(C1->getAggregateElement((unsigned)1))
2950 ConstantInt *CILength = dyn_cast<ConstantInt>(II->getArgOperand(1));
2950 ConstantInt *CILength = dyn_cast<ConstantInt>(II->getArgOperand(1));
2951 ConstantInt *CIIndex = dyn_cast<ConstantInt>(II->getArgOperand(2));
2951 ConstantInt *CIIndex = dyn_cast<ConstantInt>(II->getArgOperand(2));
2977 ConstantInt *CI11 =
2978 C1 ? dyn_cast_or_null<ConstantInt>(C1->getAggregateElement((unsigned)1))
3012 ConstantInt *CILength = dyn_cast<ConstantInt>(II->getArgOperand(2));
3012 ConstantInt *CILength = dyn_cast<ConstantInt>(II->getArgOperand(2));
3013 ConstantInt *CIIndex = dyn_cast<ConstantInt>(II->getArgOperand(3));
3013 ConstantInt *CIIndex = dyn_cast<ConstantInt>(II->getArgOperand(3));
3172 if (!Elt || !(isa<ConstantInt>(Elt) || isa<UndefValue>(Elt))) {
3194 cast<ConstantInt>(Mask->getAggregateElement(i))->getZExtValue();
3240 ConstantInt *IntrAlign = dyn_cast<ConstantInt>(II->getArgOperand(AlignArg));
3240 ConstantInt *IntrAlign = dyn_cast<ConstantInt>(II->getArgOperand(AlignArg));
3243 ConstantInt::get(Type::getInt32Ty(II->getContext()),
3286 if (ConstantInt *Splat =
3287 dyn_cast_or_null<ConstantInt>(CV1->getSplatValue()))
3369 return replaceInstUsesWith(CI, ConstantInt::get(II->getType(), Exp));
3396 const ConstantInt *CMask = dyn_cast<ConstantInt>(Src1);
3396 const ConstantInt *CMask = dyn_cast<ConstantInt>(Src1);
3402 return replaceInstUsesWith(*II, ConstantInt::get(II->getType(), false));
3410 return replaceInstUsesWith(*II, ConstantInt::get(II->getType(), true));
3413 return replaceInstUsesWith(*II, ConstantInt::get(II->getType(), false));
3433 II->setArgOperand(1, ConstantInt::get(Src1->getType(),
3446 { Src0, ConstantInt::get(Src1->getType(), Mask & FullMask) }
3470 return replaceInstUsesWith(*II, ConstantInt::get(II->getType(), Result));
3520 ConstantInt *CWidth = dyn_cast<ConstantInt>(II->getArgOperand(2));
3520 ConstantInt *CWidth = dyn_cast<ConstantInt>(II->getArgOperand(2));
3524 return replaceInstUsesWith(*II, ConstantInt::getNullValue(Ty));
3528 II->setArgOperand(2, ConstantInt::get(CWidth->getType(),
3535 ConstantInt *COffset = dyn_cast<ConstantInt>(II->getArgOperand(1));
3535 ConstantInt *COffset = dyn_cast<ConstantInt>(II->getArgOperand(1));
3539 II->setArgOperand(1, ConstantInt::get(COffset->getType(),
3573 ConstantInt *En = cast<ConstantInt>(II->getArgOperand(1));
3573 ConstantInt *En = cast<ConstantInt>(II->getArgOperand(1));
3663 const ConstantInt *CC = cast<ConstantInt>(II->getArgOperand(2));
3663 const ConstantInt *CC = cast<ConstantInt>(II->getArgOperand(2));
3706 II->setArgOperand(2, ConstantInt::get(CC->getType(),
3724 II->setArgOperand(1, ConstantInt::getNullValue(Src1->getType()));
3725 II->setArgOperand(2, ConstantInt::get(CC->getType(), CmpInst::ICMP_NE));
3789 ConstantInt::get(CC->getType(), SrcPred) };
3805 const ConstantInt *C = dyn_cast<ConstantInt>(II->getArgOperand(0));
3805 const ConstantInt *C = dyn_cast<ConstantInt>(II->getArgOperand(0));
3815 auto BC = cast<ConstantInt>(II->getArgOperand(5));
3816 auto RM = cast<ConstantInt>(II->getArgOperand(3));
3817 auto BM = cast<ConstantInt>(II->getArgOperand(4));
3986 II->setOperand(2, ConstantInt::get(OpIntTy, GCR.getBasePtrIndex()));
4219 ConstantInt *Op0C = dyn_cast<ConstantInt>(Call.getOperand(0));
4219 ConstantInt *Op0C = dyn_cast<ConstantInt>(Call.getOperand(0));
4220 ConstantInt *Op1C =
4221 (NumArgs == 1) ? nullptr : dyn_cast<ConstantInt>(Call.getOperand(1));
lib/Transforms/InstCombine/InstCombineCasts.cpp 32 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val)) {
32 if (ConstantInt *CI = dyn_cast<ConstantInt>(Val)) {
35 return ConstantInt::get(Val->getType(), 0);
47 if (ConstantInt *RHS = dyn_cast<ConstantInt>(I->getOperand(1))) {
47 if (ConstantInt *RHS = dyn_cast<ConstantInt>(I->getOperand(1))) {
131 Amt = ConstantInt::get(AI.getArraySize()->getType(), Scale);
137 Value *Off = ConstantInt::get(AI.getArraySize()->getType(),
463 ConstantInt *ShiftVal = nullptr;
731 Value *And = Builder.CreateAnd(Src, ConstantInt::get(SrcTy, 1));
742 Value *And = Builder.CreateAnd(X, ConstantInt::get(SrcTy, MaskC));
749 Value *And = Builder.CreateAnd(X, ConstantInt::get(SrcTy, MaskC));
758 Value *A = nullptr; ConstantInt *Cst = nullptr;
802 return BinaryOperator::CreateAShr(A, ConstantInt::get(CI.getType(),
835 ConstantInt::get(DestTy, Cst->getValue().trunc(DestSize)));
861 Value *Sh = ConstantInt::get(In->getType(),
868 Constant *One = ConstantInt::get(In->getType(), 1);
897 Constant *Res = ConstantInt::get(CI.getType(), isNE);
906 In = Builder.CreateLShr(In, ConstantInt::get(In->getType(), ShAmt),
911 Constant *One = ConstantInt::get(In->getType(), 1);
946 ConstantInt::get(ITy, UnknownBit));
950 Result, ConstantInt::get(ITy, UnknownBit.countTrailingZeros()));
953 Result = Builder.CreateXor(Result, ConstantInt::get(ITy, 1));
1133 Constant *C = ConstantInt::get(Res->getType(),
1156 Constant *AndConst = ConstantInt::get(A->getType(), AndValue);
1163 return BinaryOperator::CreateAnd(A, ConstantInt::get(A->getType(),
1170 ConstantInt::get(Trunc->getType(),
1236 Value *Sh = ConstantInt::get(Op0->getType(),
1247 if (ConstantInt *Op1C = dyn_cast<ConstantInt>(Op1)) {
1247 if (ConstantInt *Op1C = dyn_cast<ConstantInt>(Op1)) {
1262 ConstantInt::getAllOnesValue(CI.getType()) :
1263 ConstantInt::getNullValue(CI.getType());
1274 ConstantInt::get(In->getType(), ShiftAmt));
1279 ConstantInt::getAllOnesValue(In->getType()),
1288 ConstantInt::get(In->getType(), ShiftAmt));
1291 In = Builder.CreateAShr(In, ConstantInt::get(In->getType(),
1397 Value *ShAmt = ConstantInt::get(DestTy, DestBitSize-SrcBitSize);
1409 Constant *ShAmt = ConstantInt::get(DestTy, DestBitSize - SrcBitSize);
1431 ConstantInt *BA = nullptr, *CA = nullptr;
1438 Constant *ShAmtV = ConstantInt::get(CI.getType(), ShAmt);
1947 Constant *Piece = ConstantExpr::getLShr(C, ConstantInt::get(C->getType(),
1980 ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1));
1980 ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(1));
lib/Transforms/InstCombine/InstCombineCompares.cpp 148 ConstantInt *AndCst) {
163 !isa<ConstantInt>(GEP->getOperand(1)) ||
164 !cast<ConstantInt>(GEP->getOperand(1))->isZero() ||
175 ConstantInt *Idx = dyn_cast<ConstantInt>(GEP->getOperand(i));
175 ConstantInt *Idx = dyn_cast<ConstantInt>(GEP->getOperand(i));
250 if (!isa<ConstantInt>(C)) return nullptr;
254 bool IsTrueForElt = !cast<ConstantInt>(C)->isZero();
327 Value *FirstTrueIdx = ConstantInt::get(Idx->getType(), FirstTrueElement);
335 Value *SecondTrueIdx = ConstantInt::get(Idx->getType(), SecondTrueElement);
347 Value *FirstFalseIdx = ConstantInt::get(Idx->getType(), FirstFalseElement);
355 Value *SecondFalseIdx = ConstantInt::get(Idx->getType(),SecondFalseElement);
367 Value *Offs = ConstantInt::get(Idx->getType(), -FirstTrueElement);
371 Value *End = ConstantInt::get(Idx->getType(),
381 Value *Offs = ConstantInt::get(Idx->getType(), -FirstFalseElement);
385 Value *End = ConstantInt::get(Idx->getType(),
406 V = Builder.CreateLShr(ConstantInt::get(Ty, MagicBitvector), V);
407 V = Builder.CreateAnd(ConstantInt::get(Ty, 1), V);
408 return new ICmpInst(ICmpInst::ICMP_NE, V, ConstantInt::get(Ty, 0));
437 if (ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(i))) {
437 if (ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(i))) {
465 ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(i));
465 ConstantInt *CI = dyn_cast<ConstantInt>(GEP->getOperand(i));
512 Constant *OffsetVal = ConstantInt::get(IntPtrTy, NewOffs);
657 NewInsts[Base] = ConstantInt::getNullValue(IndexType);
698 if (isa<ConstantInt>(Op) && cast<ConstantInt>(Op)->isZero())
698 if (isa<ConstantInt>(Op) && cast<ConstantInt>(Op)->isZero())
767 Constant *Index = ConstantInt::getNullValue(IndexType);
998 ConstantInt::get(I.getType(), ICmpInst::isTrueWhenEqual(Cond)));
1098 ConstantInt::get(CmpTy, !CmpInst::isTrueWhenEqual(ICI.getPredicate())));
1113 Constant *R = ConstantInt::get(X->getType(),
1123 ConstantInt::get(X->getType(), -C));
1135 ConstantInt::get(X->getType(), SMax - C));
1146 ConstantInt::get(X->getType(), SMax - (C - 1)));
1180 ConstantInt::get(A->getType(), AP2.logBase2()));
1183 return getICmp(I.ICMP_EQ, A, ConstantInt::getNullValue(A->getType()));
1196 return getICmp(I.ICMP_UGE, A, ConstantInt::get(A->getType(), Shift));
1197 return getICmp(I.ICMP_EQ, A, ConstantInt::get(A->getType(), Shift));
1199 return getICmp(I.ICMP_EQ, A, ConstantInt::get(A->getType(), Shift));
1205 auto *TorF = ConstantInt::get(I.getType(), I.getPredicate() == I.ICMP_NE);
1231 ConstantInt::get(A->getType(), AP2.getBitWidth() - AP2TrailingZeros));
1234 return getICmp(I.ICMP_EQ, A, ConstantInt::getNullValue(A->getType()));
1240 return getICmp(I.ICMP_EQ, A, ConstantInt::get(A->getType(), Shift));
1244 auto *TorF = ConstantInt::get(I.getType(), I.getPredicate() == I.ICMP_NE);
1256 ConstantInt *CI2, ConstantInt *CI1,
1256 ConstantInt *CI2, ConstantInt *CI1,
1388 X, ConstantInt::getNullValue(XTy));
1448 ConstantInt *CI, *CI2; // I = icmp ugt (add (add A, B), CI2), CI
1481 return replaceInstUsesWith(Cmp, ConstantInt::get(Cmp.getType(), *Imp));
1538 ConstantInt::get(V->getType(), 1));
1553 return new ICmpInst(Pred, X, ConstantInt::get(X->getType(), NewRHS));
1587 ConstantInt::getAllOnesValue(X->getType()));
1590 ConstantInt::getNullValue(X->getType()));
1598 return new ICmpInst(Pred, X, ConstantInt::get(X->getType(), C ^ *XorC));
1606 return new ICmpInst(Pred, X, ConstantInt::get(X->getType(), C ^ *XorC));
1623 ConstantInt::get(X->getType(), ~C));
1627 ConstantInt::get(X->getType(), ~C));
1682 return replaceInstUsesWith(Cmp, ConstantInt::getFalse(Cmp.getType()));
1684 return replaceInstUsesWith(Cmp, ConstantInt::getTrue(Cmp.getType()));
1686 Cmp.setOperand(1, ConstantInt::get(And->getType(), NewCst));
1688 And->setOperand(1, ConstantInt::get(And->getType(), NewAndCst));
1773 Constant *ZextC1 = ConstantInt::get(WideType, C1.zext(WideScalarBits));
1774 Constant *ZextC2 = ConstantInt::get(WideType, C2->zext(WideScalarBits));
1840 !LI->isVolatile() && isa<ConstantInt>(Y)) {
1841 ConstantInt *C2 = cast<ConstantInt>(Y);
1841 ConstantInt *C2 = cast<ConstantInt>(Y);
1887 ConstantInt::get(V->getType(), 1));
1904 return new ICmpInst(Pred, A, ConstantInt::getNullValue(OrOp0->getType()));
1916 Builder.CreateICmp(Pred, P, ConstantInt::getNullValue(P->getType()));
1918 Builder.CreateICmp(Pred, Q, ConstantInt::getNullValue(Q->getType()));
1993 return new ICmpInst(Pred, Y, ConstantInt::get(ShiftType, CLog2));
1995 Constant *BitWidthMinusOne = ConstantInt::get(ShiftType, TypeBits - 1);
2016 return new ICmpInst(Pred, Y, ConstantInt::get(ShiftType, C.logBase2()));
2051 return new ICmpInst(Pred, X, ConstantInt::get(ShType, ShiftedC));
2056 return new ICmpInst(Pred, X, ConstantInt::get(ShType, ShiftedC));
2065 return new ICmpInst(Pred, X, ConstantInt::get(ShType, ShiftedC));
2081 return new ICmpInst(Pred, X, ConstantInt::get(ShType, ShiftedC));
2086 return new ICmpInst(Pred, X, ConstantInt::get(ShType, ShiftedC));
2095 return new ICmpInst(Pred, X, ConstantInt::get(ShType, ShiftedC));
2101 Constant *Mask = ConstantInt::get(
2105 Constant *LShrC = ConstantInt::get(ShType, C.lshr(*ShiftAmt));
2113 Constant *Mask = ConstantInt::get(
2155 ConstantInt::get(TruncTy, C.ashr(*ShiftAmt).trunc(TypeBits - Amt));
2202 return new ICmpInst(Pred, X, ConstantInt::get(ShrTy, ShiftedC));
2209 return new ICmpInst(Pred, X, ConstantInt::get(ShrTy, ShiftedC));
2217 return new ICmpInst(Pred, X, ConstantInt::get(ShrTy, ShiftedC));
2223 return new ICmpInst(Pred, X, ConstantInt::get(ShrTy, ShiftedC));
2242 return new ICmpInst(Pred, X, ConstantInt::get(ShrTy, C << ShAmtVal));
2248 Constant *Mask = ConstantInt::get(ShrTy, Val);
2250 return new ICmpInst(Pred, And, ConstantInt::get(ShrTy, C << ShAmtVal));
2279 Constant *MaskC = ConstantInt::get(Ty, SignMask | (*DivisorC - 1));
2286 return new ICmpInst(ICmpInst::ICMP_SGT, And, ConstantInt::getNullValue(Ty));
2291 return new ICmpInst(ICmpInst::ICMP_UGT, And, ConstantInt::get(Ty, SignMask));
2310 ConstantInt::get(Y->getType(), C2->udiv(C + 1)));
2317 ConstantInt::get(Y->getType(), C2->udiv(C)));
2449 ConstantInt::get(Div->getType(), LoBound));
2453 ConstantInt::get(Div->getType(), HiBound));
2462 ConstantInt::get(Div->getType(), LoBound));
2466 ConstantInt::get(Div->getType(), HiBound));
2476 return new ICmpInst(Pred, X, ConstantInt::get(Div->getType(), LoBound));
2485 ConstantInt::get(Div->getType(), HiBound));
2487 ConstantInt::get(Div->getType(), HiBound));
2505 ConstantInt::get(Y->getType(), 0));
2513 ConstantInt::get(Y->getType(), SubResult));
2587 return new ICmpInst(Pred, X, ConstantInt::get(Ty, NewC));
2595 return new ICmpInst(ICmpInst::ICMP_SLT, X, ConstantInt::get(Ty, Upper));
2597 return new ICmpInst(ICmpInst::ICMP_SGE, X, ConstantInt::get(Ty, Lower));
2600 return new ICmpInst(ICmpInst::ICMP_ULT, X, ConstantInt::get(Ty, Upper));
2602 return new ICmpInst(ICmpInst::ICMP_UGE, X, ConstantInt::get(Ty, Lower));
2623 Value *&RHS, ConstantInt *&Less,
2624 ConstantInt *&Equal,
2625 ConstantInt *&Greater) {
2676 ConstantInt *C) {
2685 ConstantInt *C1LessThan, *C2Equal, *C3GreaterThan;
2748 return new ICmpInst(Pred, X, ConstantInt::getNullValue(X->getType()));
2752 return new ICmpInst(Pred, X, ConstantInt::get(X->getType(), 1));
2757 ConstantInt::getAllOnesValue(X->getType()));
2765 return new ICmpInst(Pred, X, ConstantInt::getNullValue(X->getType()));
2799 if (auto *Elem = dyn_cast_or_null<ConstantInt>(Mask->getSplatValue())) {
2799 if (auto *Elem = dyn_cast_or_null<ConstantInt>(Mask->getSplatValue())) {
2809 Value *NewC = ConstantInt::get(EltTy, C->trunc(EltTy->getBitWidth()));
2885 if (ConstantInt *ConstRHS = dyn_cast<ConstantInt>(Cmp.getOperand(1)))
2885 if (ConstantInt *ConstRHS = dyn_cast<ConstantInt>(Cmp.getOperand(1)))
3033 Cmp.setOperand(1, ConstantInt::get(Ty, C.byteSwap()));
3042 Cmp.setOperand(1, ConstantInt::getNullValue(Ty));
3058 Cmp.setOperand(1, ConstantInt::get(Ty, Mask2));
3124 II->getArgOperand(0), ConstantInt::get(Ty, Limit));
3133 II->getArgOperand(0), ConstantInt::get(Ty, Limit));
3147 ConstantInt::getNullValue(Ty));
3156 ConstantInt::getNullValue(Ty));
3197 ConstantInt *CI = nullptr;
3200 CI = dyn_cast<ConstantInt>(Op1);
3204 CI = dyn_cast<ConstantInt>(Op2);
3438 Value *T0 = Builder.CreateAdd(X, ConstantInt::get(XType, AddCst));
3440 Value *T1 = Builder.CreateICmp(DstPred, T0, ConstantInt::get(XType, ICmpCst));
3822 if (ConstantInt *C1 = dyn_cast<ConstantInt>(B))
3822 if (ConstantInt *C1 = dyn_cast<ConstantInt>(B))
3823 if (ConstantInt *C2 = dyn_cast<ConstantInt>(D)) {
3823 if (ConstantInt *C2 = dyn_cast<ConstantInt>(D)) {
3830 ConstantInt *C3 = Builder.getInt(AP1 - AP2);
3834 ConstantInt *C3 = Builder.getInt(AP2 - AP1);
3912 return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
3914 return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
3966 Constant *Mask = ConstantInt::get(
4136 ConstantInt *C1, *C2;
4196 ConstantInt *Cst1;
4291 ? new ICmpInst(ICmpInst::ICMP_ULT, CtPop, ConstantInt::get(Ty, 2))
4292 : new ICmpInst(ICmpInst::ICMP_UGT, CtPop, ConstantInt::get(Ty, 1));
4376 if (IsSignedCmp || !IsSignedExt || !isa<ConstantInt>(C))
4577 if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->getOperand(1))) {
4577 if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->getOperand(1))) {
4611 ConstantInt *CI;
4629 if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal)) {
4629 if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal)) {
4641 if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal)) {
4641 if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal)) {
4652 if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal)) {
4652 if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal)) {
4664 if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal)) {
4664 if (ConstantInt *CI = dyn_cast<ConstantInt>(OtherVal)) {
4706 ConstantInt *CI = cast<ConstantInt>(BO->getOperand(1));
4706 ConstantInt *CI = cast<ConstantInt>(BO->getOperand(1));
4980 ? replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()))
4981 : replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
5003 auto *CmpC = ConstantInt::get(XTy, ValToCheck.countTrailingZeros());
5009 auto *CmpC = ConstantInt::get(XTy, ValToCheck.countTrailingZeros());
5024 return new ICmpInst(NewPred, X, ConstantInt::get(X->getType(), CmpVal));
5031 return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
5033 return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
5042 ConstantInt::get(Op1->getType(), *CmpC - 1));
5053 return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
5055 return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
5064 ConstantInt::get(Op1->getType(), *CmpC + 1));
5075 return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
5077 return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
5084 ConstantInt::get(Op1->getType(), *CmpC - 1));
5090 return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
5092 return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
5099 ConstantInt::get(Op1->getType(), *CmpC + 1));
5106 return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
5108 return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
5115 return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
5117 return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
5124 return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
5126 return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
5133 return replaceInstUsesWith(I, ConstantInt::getTrue(I.getType()));
5135 return replaceInstUsesWith(I, ConstantInt::getFalse(I.getType()));
5170 if (auto *CI = dyn_cast<ConstantInt>(C)) {
5170 if (auto *CI = dyn_cast<ConstantInt>(C)) {
5186 auto *CI = dyn_cast<ConstantInt>(Elt);
5186 auto *CI = dyn_cast<ConstantInt>(Elt);
5198 Constant *OneOrNegOne = ConstantInt::get(Type, WillIncrement ? 1 : -1, true);
5535 ConstantInt::get(Op1->getType(), ~(*C)));
lib/Transforms/InstCombine/InstCombineInternal.h 172 return ConstantExpr::getAdd(C, ConstantInt::get(C->getType(), 1));
177 return ConstantExpr::getSub(C, ConstantInt::get(C->getType(), 1));
258 SafeC = ConstantInt::get(EltTy, 1);
694 new StoreInst(ConstantInt::getTrue(Ctx),
828 ConstantInt *&Less, ConstantInt *&Equal,
828 ConstantInt *&Less, ConstantInt *&Equal,
829 ConstantInt *&Greater);
907 ConstantInt *AndCst = nullptr);
928 ConstantInt *C);
979 Instruction *OptAndOp(BinaryOperator *Op, ConstantInt *OpRHS,
980 ConstantInt *AndRHS, BinaryOperator &TheAnd);
lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp 196 if (const ConstantInt *C = dyn_cast<ConstantInt>(AI.getArraySize())) {
196 if (const ConstantInt *C = dyn_cast<ConstantInt>(AI.getArraySize())) {
359 AI.setOperand(0, ConstantInt::get(AI.getArraySize()->getType(), 1));
673 auto *Zero = ConstantInt::get(IdxType, 0);
673 auto *Zero = ConstantInt::get(IdxType, 0);
679 ConstantInt::get(IdxType, i),
724 auto *Zero = ConstantInt::get(IdxType, 0);
724 auto *Zero = ConstantInt::get(IdxType, 0);
731 ConstantInt::get(IdxType, i),
794 ConstantInt *CS = dyn_cast<ConstantInt>(AI->getArraySize());
794 ConstantInt *CS = dyn_cast<ConstantInt>(AI->getArraySize());
848 if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
848 if (const ConstantInt *CI = dyn_cast<ConstantInt>(V))
914 ConstantInt::get(GEPI->getOperand(Idx)->getType(), 0));
1087 auto *CI = dyn_cast<ConstantInt>(E->getIndexOperand());
1087 auto *CI = dyn_cast<ConstantInt>(E->getIndexOperand());
1208 auto *Zero = ConstantInt::get(IdxType, 0);
1208 auto *Zero = ConstantInt::get(IdxType, 0);
1212 ConstantInt::get(IdxType, i),
1256 auto *Zero = ConstantInt::get(IdxType, 0);
1256 auto *Zero = ConstantInt::get(IdxType, 0);
1262 ConstantInt::get(IdxType, i),
lib/Transforms/InstCombine/InstCombineMulDivRem.cpp 105 return ConstantInt::get(Ty, IVal->logBase2());
121 Elts.push_back(ConstantInt::get(Ty->getScalarType(), IVal->logBase2()));
232 if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) {
232 if (ConstantInt *CI = dyn_cast<ConstantInt>(Op1)) {
242 ConstantInt *C1;
251 ConstantInt::get(Y->getType(), PosVal));
360 return SelectInst::Create(X, Op1, ConstantInt::get(I.getType(), 0));
362 return SelectInst::Create(X, Op0, ConstantInt::get(I.getType(), 0));
626 *I = NonNullOperand == 1 ? ConstantInt::getTrue(CondTy)
627 : ConstantInt::getFalse(CondTy);
707 ConstantInt::get(Ty, Product));
717 ConstantInt::get(Ty, Quotient));
725 ConstantInt::get(Ty, Quotient));
743 ConstantInt::get(Ty, Quotient));
751 ConstantInt::get(Ty, Quotient));
771 Value *Cmp = Builder.CreateICmpULT(Inc, ConstantInt::get(Ty, 3));
772 return SelectInst::Create(Cmp, Op1, ConstantInt::get(Ty, 0));
794 return BinaryOperator::CreateNSWShl(ConstantInt::get(Ty, 1), Y);
796 return BinaryOperator::CreateNUWShl(ConstantInt::get(Ty, 1), Y);
803 I.setOperand(0, ConstantInt::get(Ty, 1));
976 X, ConstantInt::get(X->getType(), C2ShlC1));
992 Value *Cmp = Builder.CreateICmpEQ(Op0, ConstantInt::getAllOnesValue(Ty));
1076 Value *ShAmt = ConstantInt::get(Op1->getType(), Op1C->exactLogBase2());
1102 Constant *NegC = ConstantInt::get(I.getType(), -(*Op1C));
1387 Value *Cmp = Builder.CreateICmpEQ(Op0, ConstantInt::getAllOnesValue(Ty));
1388 return SelectInst::Create(Cmp, ConstantInt::getNullValue(Ty), Op0);
1412 I.setOperand(1, ConstantInt::get(I.getType(), -*Y));
1445 if (ConstantInt *RHS = dyn_cast<ConstantInt>(Elt))
1445 if (ConstantInt *RHS = dyn_cast<ConstantInt>(Elt))
1454 if (ConstantInt *RHS = dyn_cast<ConstantInt>(Elts[i])) {
1454 if (ConstantInt *RHS = dyn_cast<ConstantInt>(Elts[i])) {
1456 Elts[i] = cast<ConstantInt>(ConstantExpr::getNeg(RHS));
lib/Transforms/InstCombine/InstCombinePHI.cpp 417 if (isa<ConstantInt>(FirstInst->getOperand(op)) ||
418 isa<ConstantInt>(GEP->getOperand(op)))
879 static ConstantInt *GetAnyNonZeroConstInt(PHINode &PN) {
882 if (auto *ConstVA = dyn_cast<ConstantInt>(V))
882 if (auto *ConstVA = dyn_cast<ConstantInt>(V))
885 return ConstantInt::get(cast<IntegerType>(PN.getType()), 1);
1004 !isa<ConstantInt>(UserI->getOperand(1)))
1009 if (cast<ConstantInt>(UserI->getOperand(1))->getValue().uge(SizeInBits))
1012 unsigned Shift = cast<ConstantInt>(UserI->getOperand(1))->getZExtValue();
1087 Res = Builder.CreateLShr(Res, ConstantInt::get(InVal->getType(),
1184 ConstantInt *NonZeroConst = nullptr;
lib/Transforms/InstCombine/InstCombineSelect.cpp 177 V = Builder.CreateAnd(V, ConstantInt::get(SelType, AndMask));
184 Constant *C = ConstantInt::get(SelType, TC);
191 Constant *C = ConstantInt::get(SelType, FC);
209 V = Builder.CreateAnd(V, ConstantInt::get(V->getType(), AndMask));
446 Value *C = ConstantInt::get(OOp->getType(), CI);
477 Value *C = ConstantInt::get(OOp->getType(), CI);
526 Constant *One = ConstantInt::get(SelType, 1);
659 V = Builder.CreateAnd(V, ConstantInt::get(V->getType(), C1));
743 Intrinsic::uadd_sat, X, ConstantInt::get(X->getType(), *C));
877 NewI->setArgOperand(1, ConstantInt::getFalse(NewI->getContext()));
886 II->setArgOperand(1, ConstantInt::getTrue(II->getContext()));
915 AdjustedRHS = ConstantInt::get(CmpRHS->getType(), *CmpC + 1);
917 AdjustedRHS = ConstantInt::get(CmpRHS->getType(), *CmpC - 1);
1070 Cmp.setOperand(1, ConstantInt::getNullValue(Cmp.getOperand(0)->getType()));
1230 C1 = ConstantInt::getNullValue(Sel0.getType());
1782 Constant *One = ConstantInt::getTrue(SmallType);
1788 Constant *Zero = ConstantInt::getNullValue(SelType);
1815 Mask.push_back(ConstantInt::get(Int32Ty, i));
1818 Mask.push_back(ConstantInt::get(Int32Ty, i + NumElts));
1992 ConstantInt::get(X->getType(), *C2 - *C1));
1994 ConstantInt::get(X->getType(), *C1));
2005 ConstantInt::get(X->getType(), Diff));
2007 ConstantInt::get(X->getType(), *C1));
lib/Transforms/InstCombine/InstCombineShifts.cpp 220 SumOfShAmts, ConstantInt::get(SumOfShAmts->getType()->getScalarType(),
245 ShAmtsDiff, ConstantInt::get(ShAmtsDiff->getType()->getScalarType(),
248 ConstantExpr::getSub(ConstantInt::get(ShAmtsDiff->getType(),
332 Value *Rem = Builder.CreateAnd(A, ConstantInt::get(I.getType(), *B - 1),
408 ConstantInt *CI = nullptr;
482 InnerShift->setOperand(1, ConstantInt::get(ShType, ShAmt));
511 ConstantInt::get(ShType, Mask));
642 isa<ConstantInt>(TrOp->getOperand(1))) {
670 ConstantInt::get(I.getContext(), MaskV),
682 ConstantInt *CC;
702 Constant *Mask = ConstantInt::get(I.getContext(), Bits);
737 Constant *Mask = ConstantInt::get(I.getContext(), Bits);
882 return BinaryOperator::CreateAnd(X, ConstantInt::get(Ty, Mask));
892 Constant *ShiftDiff = ConstantInt::get(Ty, ShAmt - ShrAmt);
900 Constant *ShiftDiff = ConstantInt::get(Ty, ShrAmt - ShAmt);
913 return BinaryOperator::CreateShl(X, ConstantInt::get(Ty, AmtSum));
934 Constant *AllOnes = ConstantInt::getAllOnesValue(Ty);
953 auto *NewC = ConstantExpr::getShl(ConstantInt::get(Ty, 1), C1);
954 return SelectInst::Create(X, NewC, ConstantInt::getNullValue(Ty));
962 ConstantInt::get(Ty, APInt::getSignMask(BitWidth)), X);
993 Constant *RHS = ConstantInt::getSigned(Ty, IsPop ? -1 : 0);
1003 Constant *ShiftDiff = ConstantInt::get(Ty, ShAmt - ShlAmt);
1013 return BinaryOperator::CreateAnd(NewLShr, ConstantInt::get(Ty, Mask));
1017 Constant *ShiftDiff = ConstantInt::get(Ty, ShlAmt - ShAmt);
1027 return BinaryOperator::CreateAnd(NewShl, ConstantInt::get(Ty, Mask));
1032 return BinaryOperator::CreateAnd(X, ConstantInt::get(Ty, Mask));
1074 return BinaryOperator::CreateLShr(X, ConstantInt::get(Ty, AmtSum));
1088 Constant *AllOnes = ConstantInt::getAllOnesValue(Ty);
1199 Constant *ShiftDiff = ConstantInt::get(Ty, ShAmt - ShlAmt);
1206 Constant *ShiftDiff = ConstantInt::get(Ty, ShlAmt - ShAmt);
1219 return BinaryOperator::CreateAShr(X, ConstantInt::get(Ty, AmtSum));
1227 Value *NewSh = Builder.CreateAShr(X, ConstantInt::get(SrcTy, ShAmt));
lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp 55 I->setOperand(OpNo, ConstantInt::get(Op->getType(), *C & Demanded));
292 isa<ConstantInt>(I->getOperand(1)) &&
293 isa<ConstantInt>(LHSInst->getOperand(1)) &&
295 ConstantInt *AndRHS = cast<ConstantInt>(LHSInst->getOperand(1));
295 ConstantInt *AndRHS = cast<ConstantInt>(LHSInst->getOperand(1));
296 ConstantInt *XorRHS = cast<ConstantInt>(I->getOperand(1));
296 ConstantInt *XorRHS = cast<ConstantInt>(I->getOperand(1));
300 ConstantInt::get(I->getType(), NewMask & AndRHS->getValue());
305 ConstantInt::get(I->getType(), NewMask & XorRHS->getValue());
601 if (ConstantInt *Rem = dyn_cast<ConstantInt>(I->getOperand(1))) {
601 if (ConstantInt *Rem = dyn_cast<ConstantInt>(I->getOperand(1))) {
680 ConstantInt::get(I->getType(), InputBit-ResultBit));
683 ConstantInt::get(I->getType(), ResultBit-InputBit));
737 return ConstantInt::getNullValue(VTy);
948 Constant *Amt = ConstantInt::get(VarX->getType(), ShlAmt - ShrAmt);
954 Constant *Amt = ConstantInt::get(VarX->getType(), ShrAmt - ShlAmt);
985 ConstantInt *NewDMask = nullptr;
992 ConstantInt *DMask = cast<ConstantInt>(II->getArgOperand(DMaskIdx));
992 ConstantInt *DMask = cast<ConstantInt>(II->getArgOperand(DMaskIdx));
1010 NewDMask = ConstantInt::get(DMask->getType(), NewDMaskVal);
1221 ConstantInt *Idx = dyn_cast<ConstantInt>(I->getOperand(2));
1221 ConstantInt *Idx = dyn_cast<ConstantInt>(I->getOperand(2));
1334 Op, Value, ConstantInt::get(Type::getInt32Ty(I->getContext()), Idx),
1347 Elts.push_back(ConstantInt::get(Type::getInt32Ty(I->getContext()),
lib/Transforms/InstCombine/InstCombineVectorOps.cpp 267 ConstantInt *EEIIndexC = dyn_cast<ConstantInt>(EEI->getIndexOperand());
267 ConstantInt *EEIIndexC = dyn_cast<ConstantInt>(EEI->getIndexOperand());
328 auto *IndexC = dyn_cast<ConstantInt>(Index);
328 auto *IndexC = dyn_cast<ConstantInt>(Index);
410 if (auto *Elt = dyn_cast<ConstantInt>(Index)) {
410 if (auto *Elt = dyn_cast<ConstantInt>(Index)) {
426 ConstantInt::get(Int32Ty,
458 Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()), i));
464 Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()),
475 if (!isa<ConstantInt>(IdxOp))
477 unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue();
488 if (isa<ConstantInt>(EI->getOperand(1))) {
490 cast<ConstantInt>(EI->getOperand(1))->getZExtValue();
501 ConstantInt::get(Type::getInt32Ty(V->getContext()),
506 ConstantInt::get(Type::getInt32Ty(V->getContext()),
542 ExtendMask.push_back(ConstantInt::get(IntType, i));
620 Mask.assign(NumElts, ConstantInt::get(Type::getInt32Ty(V->getContext()),0));
631 if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp)) {
631 if (isa<ConstantInt>(EI->getOperand(1)) && isa<ConstantInt>(IdxOp)) {
633 cast<ConstantInt>(EI->getOperand(1))->getZExtValue();
634 unsigned InsertedIdx = cast<ConstantInt>(IdxOp)->getZExtValue();
651 Mask[i] = ConstantInt::get(Type::getInt32Ty(V->getContext()), i);
657 ConstantInt::get(Type::getInt32Ty(V->getContext()),
668 Mask.push_back(ConstantInt::get(
686 Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()), i));
769 auto *Idx = dyn_cast<ConstantInt>(CurrIE->getOperand(2));
769 auto *Idx = dyn_cast<ConstantInt>(CurrIE->getOperand(2));
801 Constant *Zero = ConstantInt::get(Int32Ty, 0);
802 if (!cast<ConstantInt>(FirstIE->getOperand(2))->isZero())
840 Constant *Zero = ConstantInt::getNullValue(I32Ty);
876 Constant *NewMaskEltC = ConstantInt::get(I32Ty, IdxC);
914 ConstantInt *IdxC1, *IdxC2;
969 NewMaskElts[I] = ConstantInt::get(Int32Ty, InsEltIndex + NumElts);
1004 Mask[I] = ConstantInt::get(Type::getInt32Ty(InsElt.getContext()),
1014 Mask[I] = ConstantInt::get(Type::getInt32Ty(InsElt.getContext()), I);
1191 ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(2));
1191 ConstantInt *CI = dyn_cast<ConstantInt>(I->getOperand(2));
1307 MaskValues.push_back(ConstantInt::get(I32Ty, Mask[i]));
1366 int Element = cast<ConstantInt>(I->getOperand(2))->getLimitedValue();
1387 ConstantInt::get(I32Ty, Index), "", I);
1451 Constant *ShlOne = ConstantExpr::getShl(ConstantInt::get(Ty, 1), C);
1798 IndexC = ConstantInt::get(IndexC->getType(), NewInsIndex);
1806 ConstantInt *IndexC;
1878 NewMask[i] = ConstantInt::get(I32Ty, Mask[i]);
1881 NewMask[i] = ConstantInt::get(I32Ty, Mask[i] - (WideElts - NarrowElts));
1915 Elts.push_back(ConstantInt::get(Int32Ty, Mask[i]));
2031 ShuffleMask[I] = ConstantInt::get(Int32Ty, Idx);
2048 NewBC, ConstantInt::get(Int32Ty, BegIdx), SVI.getName() + ".extract");
2230 Elts.push_back(ConstantInt::get(Int32Ty, newMask[i]));
lib/Transforms/InstCombine/InstructionCombining.cpp 531 RHS = ConstantExpr::getShl(ConstantInt::get(Op->getType(), 1), C);
802 if (ConstantInt *C = dyn_cast<ConstantInt>(V))
802 if (ConstantInt *C = dyn_cast<ConstantInt>(V))
818 if (!isa<ConstantInt>(Elt))
1014 if (InC && !isa<ConstantExpr>(InC) && isa<ConstantInt>(InC))
1116 NewIndices.push_back(ConstantInt::get(IndexTy, FirstIdx));
1130 NewIndices.push_back(ConstantInt::get(Type::getInt32Ty(Ty->getContext()),
1138 NewIndices.push_back(ConstantInt::get(IndexTy,Offset/EltSize));
1211 if (ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
1211 if (ConstantInt *CI = dyn_cast<ConstantInt>(Op)) {
1219 Op = ConstantInt::get(CI->getType(), Quotient);
1237 if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
1237 if (ConstantInt *CI = dyn_cast<ConstantInt>(RHS)) {
1264 isa<ConstantInt>(BO->getOperand(1))) {
1271 int32_t Amt = cast<ConstantInt>(BO->getOperand(1))->
1287 Op = ConstantInt::get(BO->getType(), Amt - logScale);
1968 if (auto *C = dyn_cast<ConstantInt>(GEP.getOperand(1)))
1968 if (auto *C = dyn_cast<ConstantInt>(GEP.getOperand(1)))
2402 ConstantInt::get(Type::getInt1Ty(C->getContext()),
2570 if (BI.isConditional() && !isa<ConstantInt>(BI.getCondition()) &&
2572 BI.setCondition(ConstantInt::getFalse(BI.getCondition()->getType()));
2595 ConstantInt *AddRHS;
2602 Case.setValue(cast<ConstantInt>(NewCase));
2636 Case.setValue(ConstantInt::get(SI.getContext(), TruncatedCase));
2724 if (ConstantInt *CI = dyn_cast<ConstantInt>(WO->getRHS()))
2724 if (ConstantInt *CI = dyn_cast<ConstantInt>(WO->getRHS()))
3246 Constant *C = ConstantInt::get(Ty, Known.getConstant());
3447 if (BI->isConditional() && isa<ConstantInt>(BI->getCondition())) {
3448 bool CondVal = cast<ConstantInt>(BI->getCondition())->getZExtValue();
3454 if (ConstantInt *Cond = dyn_cast<ConstantInt>(SI->getCondition())) {
3454 if (ConstantInt *Cond = dyn_cast<ConstantInt>(SI->getCondition())) {
lib/Transforms/Instrumentation/AddressSanitizer.cpp 602 const ConstantInt *CI = dyn_cast<ConstantInt>(AI.getArraySize());
602 const ConstantInt *CI = dyn_cast<ConstantInt>(AI.getArraySize());
1051 auto *Size = cast<ConstantInt>(II.getArgOperand(0));
1051 auto *Size = cast<ConstantInt>(II.getArgOperand(0));
1058 !ConstantInt::isValueValidForType(IntptrTy, SizeValue))
1117 LineNo = mdconst::extract<ConstantInt>(MDN->getOperand(1))->getLimitedValue();
1119 mdconst::extract<ConstantInt>(MDN->getOperand(2))->getLimitedValue();
1147 ConstantInt *IsDynInit = mdconst::extract<ConstantInt>(MDN->getOperand(3));
1147 ConstantInt *IsDynInit = mdconst::extract<ConstantInt>(MDN->getOperand(3));
1149 ConstantInt *IsBlacklisted =
1150 mdconst::extract<ConstantInt>(MDN->getOperand(4));
1254 ConstantInt::get(Type::getInt32Ty(M.getContext()), MD.LineNo),
1255 ConstantInt::get(Type::getInt32Ty(M.getContext()), MD.ColumnNo),
1293 ShadowBase = ConstantInt::get(IntptrTy, Mapping.Offset);
1402 dyn_cast<ConstantInt>(CI->getOperand(1 + OpOffset)))
1518 auto Zero = ConstantInt::get(IntptrTy, 0);
1524 if (auto *Masked = dyn_cast<ConstantInt>(Vector->getOperand(Idx))) {
1524 if (auto *Masked = dyn_cast<ConstantInt>(Vector->getOperand(Idx))) {
1540 IRB.CreateGEP(VTy, Addr, {Zero, ConstantInt::get(IntptrTy, Idx)});
1613 Value *ExpVal = Exp == 0 ? nullptr : ConstantInt::get(IRB.getInt32Ty(), Exp);
1644 IRB.CreateAnd(AddrLong, ConstantInt::get(IntptrTy, Granularity - 1));
1648 LastAccessedByte, ConstantInt::get(IntptrTy, TypeSize / 8 - 1));
1673 {AddrLong, ConstantInt::get(IRB.getInt32Ty(), Exp)});
1685 IRB.CreateICmpEQ(Tag, ConstantInt::get(IntptrTy, kMyriadDDRTag));
1742 Value *Size = ConstantInt::get(IntptrTy, TypeSize / 8);
1750 {AddrLong, Size, ConstantInt::get(IRB.getInt32Ty(), Exp)});
1753 IRB.CreateAdd(AddrLong, ConstantInt::get(IntptrTy, TypeSize / 8 - 1)),
1793 auto *Priority = cast<ConstantInt>(CS->getOperand(0));
1793 auto *Priority = cast<ConstantInt>(CS->getOperand(0));
2094 ConstantInt::get(IntptrTy, 0), kAsanGlobalsRegisteredFlagName);
2166 ConstantInt::get(IntptrTy, 0), kAsanGlobalsRegisteredFlagName);
2198 ConstantInt::get(IntptrTy, N)});
2205 ConstantInt::get(IntptrTy, N)});
2330 SourceLoc = ConstantInt::get(IntptrTy, 0);
2348 ODRIndicator = ConstantExpr::getIntToPtr(ConstantInt::get(IntptrTy, -1),
2369 ConstantInt::get(IntptrTy, SizeInBytes),
2370 ConstantInt::get(IntptrTy, SizeInBytes + RightRedzoneSize),
2373 ConstantInt::get(IntptrTy, MD.IsDynInit), SourceLoc,
2833 Value *Ptr = IRB.CreateAdd(ShadowBase, ConstantInt::get(IntptrTy, i));
2870 {IRB.CreateAdd(ShadowBase, ConstantInt::get(IntptrTy, i)),
2871 ConstantInt::get(IntptrTy, j - i)});
2935 ConstantInt::get(IRB.getInt64Ty(), L.FrameSize),
3096 ConstantInt::get(IntptrTy, LocalStackSize));
3100 ConstantInt::get(IntptrTy, 0));
3119 FakeStack = ConstantInt::get(IntptrTy, 0);
3131 IRB.CreateAdd(LocalStackBase, ConstantInt::get(IntptrTy, Desc.Offset)),
3139 IRB.CreateStore(ConstantInt::get(IntptrTy, kCurrentStackFrameMagic),
3144 ConstantInt::get(IntptrTy, ASan.LongSize / 8)),
3154 ConstantInt::get(IntptrTy, 2 * ASan.LongSize / 8)),
3190 IRBRet.CreateStore(ConstantInt::get(IntptrTy, kRetiredStackFrameMagic),
3218 ConstantInt::get(IntptrTy, ClassSize - ASan.LongSize / 8));
3228 {FakeStack, ConstantInt::get(IntptrTy, LocalStackSize)});
3246 Value *SizeArg = ConstantInt::get(IntptrTy, Size);
3267 Value *AllocaRzSize = ConstantInt::get(IntptrTy, kAllocaRzSize);
3268 Value *AllocaRzMask = ConstantInt::get(IntptrTy, AllocaRedzoneMask);
3278 ConstantInt::get(IntptrTy, ElementSize));
3294 ConstantInt::get(IntptrTy, Align + kAllocaRzSize), PartialPadding);
3304 ConstantInt::get(IntptrTy, Align));
lib/Transforms/Instrumentation/BoundsChecking.cpp 73 ConstantInt *SizeCI = dyn_cast<ConstantInt>(Size);
73 ConstantInt *SizeCI = dyn_cast<ConstantInt>(Size);
76 Value *NeededSizeVal = ConstantInt::get(IntTy, NeededSize);
91 ? ConstantInt::getFalse(Ptr->getContext())
96 ? ConstantInt::getFalse(Ptr->getContext())
101 Value *Cmp1 = IRB.CreateICmpSLT(Offset, ConstantInt::get(IntTy, 0));
116 ConstantInt *C = dyn_cast_or_null<ConstantInt>(Or);
116 ConstantInt *C = dyn_cast_or_null<ConstantInt>(Or);
lib/Transforms/Instrumentation/CGProfile.cpp 92 MDB.createConstant(ConstantInt::get(
lib/Transforms/Instrumentation/ControlHeightReduction.cpp 615 ConstantInt *TrueWeight = mdconst::extract<ConstantInt>(MD->getOperand(1));
615 ConstantInt *TrueWeight = mdconst::extract<ConstantInt>(MD->getOperand(1));
616 ConstantInt *FalseWeight = mdconst::extract<ConstantInt>(MD->getOperand(2));
616 ConstantInt *FalseWeight = mdconst::extract<ConstantInt>(MD->getOperand(2));
1832 ConstantInt::getTrue(F.getContext()));
1845 Value *MergedCondition = ConstantInt::getTrue(F.getContext());
1919 ConstantInt::getTrue(F.getContext()) :
1920 ConstantInt::getFalse(F.getContext());
1944 ConstantInt::getTrue(F.getContext()) :
1945 ConstantInt::getFalse(F.getContext());
1970 ConstantInt::getTrue(F.getContext()), Cond);
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp 328 ConstantInt *ZeroShadow;
329 ConstantInt *ShadowPtrMask;
330 ConstantInt *ShadowPtrMul;
555 ZeroShadow = ConstantInt::getSigned(ShadowTy, 0);
556 ShadowPtrMul = ConstantInt::getSigned(IntptrTy, ShadowWidth / 8);
558 ShadowPtrMask = ConstantInt::getSigned(IntptrTy, ~0x700000000000LL);
560 ShadowPtrMask = ConstantInt::getSigned(IntptrTy, ~0xF000000000LL);
588 ConstantInt::get(IntptrTy, uintptr_t(GetArgTLSPtr)),
595 ConstantInt::get(IntptrTy, uintptr_t(GetRetvalTLSPtr)),
1221 ConstantInt::get(DFS.IntptrTy, 1));
1235 {ShadowAddr, ConstantInt::get(DFS.IntptrTy, Size)});
1276 ConstantInt::get(DFS.IntptrTy, 1));
1294 DFS.DFSanUnionLoadFn, {ShadowAddr, ConstantInt::get(DFS.IntptrTy, Size)});
1343 Value *ExtZeroShadow = ConstantInt::get(ShadowTy, 0);
1357 ShadowVec, Shadow, ConstantInt::get(Type::getInt32Ty(*DFS.Ctx), i));
1496 ConstantInt::get(I.getLength()->getType(), DFSF.DFS.ShadowWidth / 8));
lib/Transforms/Instrumentation/GCOVProfiling.cpp 1224 Builder.CreateRet(ConstantInt::get(RetTy, 0));
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp 597 return ConstantExpr::getIntToPtr(ConstantInt::get(IntptrTy, Mapping.Offset),
624 {shadowBase(), Ptr, ConstantInt::get(Int32Ty, AccessInfo)});
640 ConstantInt::get(PtrTag->getType(), matchAllTag));
650 IRB.CreateICmpUGT(MemTag, ConstantInt::get(Int8Ty, 15));
658 PtrLowBits, ConstantInt::get(Int8Ty, (1 << AccessSizeIndex) - 1));
755 ConstantInt::get(IntptrTy, TypeSize / 8)});
765 const ConstantInt *CI = dyn_cast<ConstantInt>(AI.getArraySize());
765 const ConstantInt *CI = dyn_cast<ConstantInt>(AI.getArraySize());
784 ConstantInt::get(IntptrTy, AlignedSize)});
798 ConstantInt::get(Int8Ty, Size % Mapping.getObjectAlignment()),
859 ConstantInt::get(IntptrTy, RetagMask(AllocaNo)));
864 return ConstantInt::get(IntptrTy, 0);
867 return IRB.CreateXor(StackTag, ConstantInt::get(IntptrTy, 0xFFU));
878 ConstantInt::get(IntptrTy, (1ULL << kPointerTagShift) - 1));
894 ConstantInt::get(PtrLong->getType(), 0xFFULL << kPointerTagShift));
898 ConstantInt::get(PtrLong->getType(), ~(0xFFULL << kPointerTagShift)));
942 IRB.CreateICmpEQ(ThreadLong, ConstantInt::get(IntptrTy, 0));
1003 ConstantInt::get(IntptrTy, (uint64_t)-1));
1005 IRB.CreateAdd(ThreadLong, ConstantInt::get(IntptrTy, 8)), WrapMask);
1015 ConstantInt::get(IntptrTy, (1ULL << kShadowBaseAlignment) - 1)),
1016 ConstantInt::get(IntptrTy, 1), "hwasan.shadow");
1192 cast<ConstantInt>(AI->getArraySize())->getZExtValue();
1233 if (isa<ConstantInt>(AI->getArraySize()))
1298 ConstantInt::get(Int64Ty, DescriptorPos)),
1301 auto *SizeAndTag = ConstantInt::get(Int32Ty, Size | (uint32_t(Tag) << 24));
1313 ConstantInt::get(Int64Ty, uint64_t(Tag) << kPointerTagShift)),
1385 {ConstantInt::get(Int32Ty, 8), // n_namesz
1386 ConstantInt::get(Int32Ty, 8), // n_descsz
1387 ConstantInt::get(Int32Ty, ELF::NT_LLVM_HWASAN_GLOBALS), // n_type
lib/Transforms/Instrumentation/InstrOrderFile.cpp 135 Value *IdxFlags[] = {ConstantInt::get(Int32Ty, 0),
136 ConstantInt::get(Int32Ty, FuncId)};
139 entryB.CreateStore(ConstantInt::get(Int8Ty, 1), MapAddr);
141 entryB.CreateICmpEQ(loadBitMap, ConstantInt::get(Int8Ty, 0));
146 AtomicRMWInst::Add, BufferIdx, ConstantInt::get(Int32Ty, 1),
150 IdxVal, ConstantInt::get(Int32Ty, INSTR_ORDER_FILE_BUFFER_MASK));
151 Value *BufferGEPIdx[] = {ConstantInt::get(Int32Ty, 0), WrappedIdx};
154 updateB.CreateStore(ConstantInt::get(Type::getInt64Ty(Ctx), MD5Hash(F.getName())),
lib/Transforms/Instrumentation/InstrProfiling.cpp 269 Value *InitVal = ConstantInt::get(Cand.first->getType(), 0);
832 Int16ArrayVals[Kind] = ConstantInt::get(Int16Ty, PD.NumValueSites[Kind]);
lib/Transforms/Instrumentation/MemorySanitizer.cpp 1392 IRB.CreateAnd(OffsetLong, ConstantInt::get(MS.IntptrTy, ~AndMask));
1397 IRB.CreateXor(OffsetLong, ConstantInt::get(MS.IntptrTy, XorMask));
1416 ConstantInt::get(MS.IntptrTy, ShadowBase));
1426 ConstantInt::get(MS.IntptrTy, OriginBase));
1430 IRB.CreateAnd(OriginLong, ConstantInt::get(MS.IntptrTy, ~Mask));
1451 Value *SizeVal = ConstantInt::get(MS.IntptrTy, Size);
1482 Base = IRB.CreateAdd(Base, ConstantInt::get(MS.IntptrTy, ArgOffset));
1494 Base = IRB.CreateAdd(Base, ConstantInt::get(MS.IntptrTy, ArgOffset));
2144 if (ConstantInt *Elt =
2145 dyn_cast<ConstantInt>(ConstArg->getAggregateElement(Idx))) {
2148 Elements.push_back(ConstantInt::get(EltTy, V2));
2150 Elements.push_back(ConstantInt::get(EltTy, 1));
2155 if (ConstantInt *Elt = dyn_cast<ConstantInt>(ConstArg)) {
2155 if (ConstantInt *Elt = dyn_cast<ConstantInt>(ConstArg)) {
2158 ShadowMul = ConstantInt::get(Ty, V2);
2160 ShadowMul = ConstantInt::get(Ty, 1);
2648 ConvertShadow, ConstantInt::get(IRB.getInt32Ty(), 0));
2651 ConvertShadow, ConstantInt::get(IRB.getInt32Ty(), i));
2669 ResultShadow, ConstantInt::getNullValue(EltTy),
2670 ConstantInt::get(IRB.getInt32Ty(), i));
2910 unsigned Align = cast<ConstantInt>(I.getArgOperand(2))->getZExtValue();
2939 unsigned Align = cast<ConstantInt>(I.getArgOperand(1))->getZExtValue();
2966 MaskedPassThruShadow, ConstantInt::get(IRB.getInt32Ty(), 0));
2970 MaskedPassThruShadow, ConstantInt::get(IRB.getInt32Ty(), i));
3487 Value *Len = ConstantInt::get(MS.IntptrTy, TypeSize);
3544 ConstantInt::getNullValue(FlatTy));
3546 ConstantInt::getNullValue(FlatTy));
3645 Value *SizeVal = ConstantInt::get(MS.IntptrTy, Size);
3879 ConstantInt::get(IRB.getInt64Ty(), OverflowOffset - AMD64FpEndOffset);
3890 Base = IRB.CreateAdd(Base, ConstantInt::get(MS.IntptrTy, ArgOffset));
3901 Base = IRB.CreateAdd(Base, ConstantInt::get(MS.IntptrTy, ArgOffset));
3945 IRB.CreateAdd(ConstantInt::get(MS.IntptrTy, AMD64FpEndOffset),
3965 ConstantInt::get(MS.IntptrTy, 16)),
3982 ConstantInt::get(MS.IntptrTy, 8)),
4041 Constant *TotalVAArgSize = ConstantInt::get(IRB.getInt64Ty(), VAArgOffset);
4054 Base = IRB.CreateAdd(Base, ConstantInt::get(MS.IntptrTy, ArgOffset));
4088 Value *CopySize = IRB.CreateAdd(ConstantInt::get(MS.IntptrTy, 0),
4212 ConstantInt::get(IRB.getInt64Ty(), OverflowOffset - AArch64VAEndOffset);
4223 Base = IRB.CreateAdd(Base, ConstantInt::get(MS.IntptrTy, ArgOffset));
4257 ConstantInt::get(MS.IntptrTy, offset)),
4267 ConstantInt::get(MS.IntptrTy, offset)),
4283 IRB.CreateAdd(ConstantInt::get(MS.IntptrTy, AArch64VAEndOffset),
4289 Value *GrArgSize = ConstantInt::get(MS.IntptrTy, kAArch64GrArgSize);
4290 Value *VrArgSize = ConstantInt::get(MS.IntptrTy, kAArch64VrArgSize);
4476 Constant *TotalVAArgSize = ConstantInt::get(IRB.getInt64Ty(),
4490 Base = IRB.CreateAdd(Base, ConstantInt::get(MS.IntptrTy, ArgOffset));
4525 Value *CopySize = IRB.CreateAdd(ConstantInt::get(MS.IntptrTy, 0),
lib/Transforms/Instrumentation/PGOInstrumentation.cpp 276 ConstantInt *CV = dyn_cast<ConstantInt>(RHS);
276 ConstantInt *CV = dyn_cast<ConstantInt>(RHS);
lib/Transforms/Instrumentation/PGOMemOPSizeOpt.cpp 166 if (dyn_cast<ConstantInt>(Length))
380 ConstantInt *CaseSizeId = ConstantInt::get(SizeType, SizeId);
380 ConstantInt *CaseSizeId = ConstantInt::get(SizeType, SizeId);
lib/Transforms/Instrumentation/PoisonChecking.cpp 86 if (auto *CI = dyn_cast<ConstantInt>(V))
86 if (auto *CI = dyn_cast<ConstantInt>(V))
158 ConstantInt::get(LHS->getType(), 0));
167 ConstantInt::get(LHS->getType(), 0));
177 ConstantInt::get(RHS->getType(),
203 ConstantInt::get(Idx->getType(), NumElts));
215 ConstantInt::get(Idx->getType(), NumElts));
228 return ConstantInt::getFalse(V->getContext());
234 return ConstantInt::getFalse(V->getContext());
239 if (auto *CI = dyn_cast<ConstantInt>(Cond))
239 if (auto *CI = dyn_cast<ConstantInt>(Cond))
lib/Transforms/Instrumentation/SanitizerCoverage.cpp 322 ConstantInt::get(IntptrTy, sizeof(uint64_t)));
677 ConstantInt::get(IntptrTy, 1), IntptrPtrTy));
682 ConstantInt::get(IntptrTy, 0), IntptrPtrTy));
754 Initializers.push_back(ConstantInt::get(Int64Ty, SI->getNumCases()));
756 ConstantInt::get(Int64Ty, Cond->getType()->getScalarSizeInBits()));
769 return cast<ConstantInt>(A)->getLimitedValue() <
770 cast<ConstantInt>(B)->getLimitedValue();
788 if (isa<ConstantInt>(A1)) continue;
806 if (!isa<ConstantInt>(*I) && (*I)->getType()->isIntegerTy())
829 bool FirstIsConst = isa<ConstantInt>(A0);
830 bool SecondIsConst = isa<ConstantInt>(A1);
873 ConstantInt::get(IntptrTy, Idx * 4)),
881 {ConstantInt::get(IntptrTy, 0), ConstantInt::get(IntptrTy, Idx)});
881 {ConstantInt::get(IntptrTy, 0), ConstantInt::get(IntptrTy, Idx)});
883 auto Inc = IRB.CreateAdd(Load, ConstantInt::get(Int8Ty, 1));
lib/Transforms/Instrumentation/ThreadSanitizer.cpp 543 StoredValue, ConstantInt::get(IRB.getInt32Ty(), 0));
575 static ConstantInt *createOrdering(IRBuilder<> *IRB, AtomicOrdering ord) {
lib/Transforms/Instrumentation/ValueProfilePlugins.inc 41 if (dyn_cast<ConstantInt>(Length))
lib/Transforms/Scalar/BDCE.cpp 129 U.set(ConstantInt::get(U->getType(), 0));
lib/Transforms/Scalar/ConstantHoisting.cpp 359 ConstantInt *ConstInt) {
426 ConstantInt::get(Type::getInt32Ty(*Ctx), Offset.getLimitedValue()),
439 if (auto ConstInt = dyn_cast<ConstantInt>(Opnd)) {
451 if (auto *ConstInt = dyn_cast<ConstantInt>(CastInst->getOperand(0))) {
451 if (auto *ConstInt = dyn_cast<ConstantInt>(CastInst->getOperand(0))) {
469 if (auto ConstInt = dyn_cast<ConstantInt>(ConstExpr->getOperand(0))) {
618 ConstantInt *ConstInt = MaxCostItr->ConstInt;
628 Constant *Offset = Diff == 0 ? nullptr : ConstantInt::get(Ty, Diff);
736 Offset = ConstantInt::get(Type::getInt32Ty(*Ctx), 0);
763 if (isa<ConstantInt>(Opnd)) {
lib/Transforms/Scalar/CorrelatedValuePropagation.cpp 132 ConstantInt *CI = dyn_cast<ConstantInt>(C);
132 ConstantInt *CI = dyn_cast<ConstantInt>(C);
323 Constant *TorF = ConstantInt::get(Type::getInt1Ty(Cmp->getContext()), Result);
362 ConstantInt *Case = CI->getCaseValue();
507 ConstantInt::getFalse(ST->getElementType(1)) });
608 Constant *Zero = ConstantInt::get(SDI->getType(), 0);
703 Constant *Zero = ConstantInt::get(SDI->getType(), 0);
725 Constant *Zero = ConstantInt::get(Base->getType(), 0);
791 ConstantInt *RHS = dyn_cast<ConstantInt>(BinOp->getOperand(1));
791 ConstantInt *RHS = dyn_cast<ConstantInt>(BinOp->getOperand(1));
825 ConstantInt::getTrue(C->getContext()) :
826 ConstantInt::getFalse(C->getContext());
lib/Transforms/Scalar/DeadStoreElimination.cpp 207 uint64_t Len = cast<ConstantInt>(II->getArgOperand(0))->getZExtValue();
941 ConstantInt::get(EarlierWriteLength->getType(), NewLength);
948 ConstantInt::get(EarlierWriteLength->getType(), OffsetMoved)};
1213 if (Earlier && isa<ConstantInt>(Earlier->getValueOperand()) &&
1216 Later && isa<ConstantInt>(Later->getValueOperand()) &&
1231 cast<ConstantInt>(Earlier->getValueOperand())->getValue();
1233 cast<ConstantInt>(Later->getValueOperand())->getValue();
1256 ConstantInt::get(Earlier->getValueOperand()->getType(), Merged),
lib/Transforms/Scalar/EarlyCSE.cpp 817 auto *TorF = (BI->getSuccessor(0) == BB)
818 ? ConstantInt::getTrue(BB->getContext())
819 : ConstantInt::getFalse(BB->getContext());
928 AvailableValues.insert(CondI, ConstantInt::getTrue(BB->getContext()));
972 if (isa<ConstantInt>(KnownCond) &&
973 cast<ConstantInt>(KnownCond)->isOne()) {
986 AvailableValues.insert(CondI, ConstantInt::getTrue(BB->getContext()));
lib/Transforms/Scalar/Float2Int.cpp 454 NewOperands.push_back(ConstantInt::get(ToTy, Val));
lib/Transforms/Scalar/GVN.cpp 1403 if (ConstantInt *Cond = dyn_cast<ConstantInt>(V)) {
1403 if (ConstantInt *Cond = dyn_cast<ConstantInt>(V)) {
1422 Constant *True = ConstantInt::getTrue(V->getContext());
1853 ConstantInt *CI = dyn_cast<ConstantInt>(RHS);
1853 ConstantInt *CI = dyn_cast<ConstantInt>(RHS);
1901 Constant *NotVal = ConstantInt::get(Cmp->getType(), isKnownFalse);
2000 Value *TrueVal = ConstantInt::getTrue(TrueSucc->getContext());
2004 Value *FalseVal = ConstantInt::getFalse(FalseSucc->getContext());
2621 ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
2621 ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
lib/Transforms/Scalar/GuardWidening.cpp 209 const ConstantInt *Offset;
214 explicit RangeCheck(const Value *Base, const ConstantInt *Offset,
219 void setOffset(const ConstantInt *NewOffset) { Offset = NewOffset; }
222 const ConstantInt *getOffset() const { return Offset; }
369 if (isa<ConstantInt>(getCondition(Instr)))
430 ? ConstantInt::getFalse(Instr->getContext())
431 : ConstantInt::getTrue(Instr->getContext());
540 ConstantInt *RHS0, *RHS1;
570 ConstantInt *NewRHS = ConstantInt::get(Cond0->getContext(), NewRHSAP);
570 ConstantInt *NewRHS = ConstantInt::get(Cond0->getContext(), NewRHSAP);
643 CmpLHS, cast<ConstantInt>(ConstantInt::getNullValue(CmpRHS->getType())),
643 CmpLHS, cast<ConstantInt>(ConstantInt::getNullValue(CmpRHS->getType())),
657 ConstantInt *OpRHS;
669 Check.setOffset(ConstantInt::get(Ctx, NewOffset));
677 Check.setOffset(ConstantInt::get(Ctx, NewOffset));
724 const ConstantInt *MinOffset = CurrentChecks.front().getOffset();
725 const ConstantInt *MaxOffset = CurrentChecks.back().getOffset();
lib/Transforms/Scalar/IndVarSimplify.cpp 459 NewPHI->addIncoming(ConstantInt::get(Int32Ty, InitValue),
463 BinaryOperator::CreateAdd(NewPHI, ConstantInt::get(Int32Ty, IncValue),
468 ConstantInt::get(Int32Ty, ExitValue),
2741 auto *NewCond = ConstantInt::get(OldCond->getType(),
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp 419 ConstantAsMetadata::get(ConstantInt::get(Type::getInt1Ty(Context), 0));
853 ConstantInt *StepCI = cast<SCEVConstant>(StepRec)->getValue();
868 ConstantInt *One = ConstantInt::get(IndVarTy, 1);
868 ConstantInt *One = ConstantInt::get(IndVarTy, 1);
1884 ConstantInt *FoldedRangeCheck = IRC.getPassingDirection()
1885 ? ConstantInt::getTrue(Context)
1886 : ConstantInt::getFalse(Context);
lib/Transforms/Scalar/JumpThreading.cpp 249 ConstantInt *CI = dyn_cast<ConstantInt>(PhiOpnd);
249 ConstantInt *CI = dyn_cast<ConstantInt>(PhiOpnd);
584 return dyn_cast<ConstantInt>(Val);
703 ConstantInt *InterestingVal;
705 InterestingVal = ConstantInt::getTrue(I->getContext());
707 InterestingVal = ConstantInt::getFalse(I->getContext());
731 isa<ConstantInt>(I->getOperand(1)) &&
732 cast<ConstantInt>(I->getOperand(1))->isOne()) {
749 if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->getOperand(1))) {
749 if (ConstantInt *CI = dyn_cast<ConstantInt>(BO->getOperand(1))) {
812 Res = ConstantInt::get(Type::getInt1Ty(LHS->getContext()), ResT);
842 Constant *ResC = ConstantInt::get(CmpType, Res);
856 ConstantInt *AddConst;
857 if (isa<ConstantInt>(CmpConst) &&
876 Pred, cast<ConstantInt>(CmpConst)->getValue());
880 ResC = ConstantInt::getTrue(CmpType);
882 ResC = ConstantInt::getFalse(CmpType);
925 if (ConstantInt *CI = dyn_cast<ConstantInt>(Cond)) {
925 if (ConstantInt *CI = dyn_cast<ConstantInt>(Cond)) {
1177 ConstantInt::getTrue(CondCmp->getType()) :
1178 ConstantInt::getFalse(CondCmp->getType());
1638 DestBB = BI->getSuccessor(cast<ConstantInt>(Val)->isZero());
1641 DestBB = SI->findCaseValue(cast<ConstantInt>(Val))->getCaseSuccessor();
1801 if (isa<ConstantInt>(BO->getOperand(0)) ||
1802 isa<ConstantInt>(BO->getOperand(1)))
1853 if (cast<ConstantInt>(XorOpValue.first)->isZero())
1860 ConstantInt *SplitVal = nullptr;
1862 SplitVal = ConstantInt::getTrue(BB->getContext());
1864 SplitVal = ConstantInt::getFalse(BB->getContext());
2572 [](Value *V) { return !isa<ConstantInt>(V); }))
2589 isa<ConstantInt>(Cmp->getOperand(1 - U.getOperandNo())))
lib/Transforms/Scalar/LICM.cpp 1016 cast<ConstantInt>(II->getArgOperand(0))->getSExtValue() * 8;
lib/Transforms/Scalar/LoopDataPrefetch.cpp 320 ConstantInt::get(I32, MemI->mayReadFromMemory() ? 0 : 1),
321 ConstantInt::get(I32, 3), ConstantInt::get(I32, 1)});
321 ConstantInt::get(I32, 3), ConstantInt::get(I32, 1)});
lib/Transforms/Scalar/LoopDeletion.cpp 107 ConstantInt *Cond;
lib/Transforms/Scalar/LoopDistribute.cpp 949 IsForced = mdconst::extract<ConstantInt>(*Op)->getZExtValue();
lib/Transforms/Scalar/LoopIdiomRecognize.cpp 809 if (MSI->isVolatile() || !isa<ConstantInt>(MSI->getLength()))
826 uint64_t SizeInBytes = cast<ConstantInt>(MSI->getLength())->getZExtValue();
1232 ConstantInt *CmpZero = dyn_cast<ConstantInt>(Cond->getOperand(1));
1232 ConstantInt *CmpZero = dyn_cast<ConstantInt>(Cond->getOperand(1));
1324 ConstantInt *Dec = dyn_cast<ConstantInt>(SubOneOp->getOperand(1));
1324 ConstantInt *Dec = dyn_cast<ConstantInt>(SubOneOp->getOperand(1));
1348 ConstantInt *Inc = dyn_cast<ConstantInt>(Inst->getOperand(1));
1348 ConstantInt *Inc = dyn_cast<ConstantInt>(Inst->getOperand(1));
1443 ConstantInt *Shft = dyn_cast<ConstantInt>(DefX->getOperand(1));
1443 ConstantInt *Shft = dyn_cast<ConstantInt>(DefX->getOperand(1));
1473 ConstantInt *Inc = dyn_cast<ConstantInt>(Inst->getOperand(1));
1473 ConstantInt *Inc = dyn_cast<ConstantInt>(Inst->getOperand(1));
1565 {InitX, ZeroCheck ? ConstantInt::getTrue(InitX->getContext())
1566 : ConstantInt::getFalse(InitX->getContext())};
1709 Builder.CreateAShr(InitX, ConstantInt::get(InitX->getType(), 1));
1712 Builder.CreateLShr(InitX, ConstantInt::get(InitX->getType(), 1));
1715 Builder.CreateShl(InitX, ConstantInt::get(InitX->getType(), 1));
1722 ConstantInt::get(FFS->getType(),
1729 ConstantInt::get(CountPrev->getType(), 1));
1738 ConstantInt *InitConst = dyn_cast<ConstantInt>(CntInitVal);
1738 ConstantInt *InitConst = dyn_cast<ConstantInt>(CntInitVal);
1759 Builder.CreateSub(TcPhi, ConstantInt::get(Ty, 1),
1769 LbCond->setOperand(1, ConstantInt::get(Ty, 0));
1810 ConstantInt *InitConst = dyn_cast<ConstantInt>(CntInitVal);
1810 ConstantInt *InitConst = dyn_cast<ConstantInt>(CntInitVal);
1825 Value *Opnd1 = ConstantInt::get(PopCntZext->getType(), 0);
1866 Builder.CreateSub(TcPhi, ConstantInt::get(Ty, 1),
1876 LbCond->setOperand(1, ConstantInt::get(Ty, 0));
2555 Builder.CreateCondBr(ConstantInt::getTrue(Context), SuccessorBB,
2657 CmpCall, ConstantInt::get(CmpCall->getType(), 0),
lib/Transforms/Scalar/LoopInterchange.cpp 139 const ConstantInt *CI = SCEVConst->getValue();
lib/Transforms/Scalar/LoopRerollPass.cpp 782 ConstantInt *CI = nullptr;
793 CI = dyn_cast<ConstantInt>(BO->getOperand(1));
796 CI = dyn_cast<ConstantInt>(LastOperand);
lib/Transforms/Scalar/LoopSimplifyCFG.cpp 63 ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
63 ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
70 auto *CI = dyn_cast<ConstantInt>(SI->getCondition());
70 auto *CI = dyn_cast<ConstantInt>(SI->getCondition());
lib/Transforms/Scalar/LoopStrengthReduce.cpp 427 const SCEV *NegOne = SE.getSCEV(ConstantInt::getAllOnesValue(
2136 ConstantInt *Init = dyn_cast<ConstantInt>(PH->getIncomingValue(Entry));
2136 ConstantInt *Init = dyn_cast<ConstantInt>(PH->getIncomingValue(Entry));
2150 ConstantInt *C = nullptr;
2152 C = dyn_cast<ConstantInt>(Incr->getOperand(1));
2154 C = dyn_cast<ConstantInt>(Incr->getOperand(0));
2316 if (ConstantInt *BO1 = dyn_cast<ConstantInt>(BO->getOperand(1)))
2316 if (ConstantInt *BO1 = dyn_cast<ConstantInt>(BO->getOperand(1)))
2320 if (ConstantInt *BO1 = dyn_cast<ConstantInt>(BO->getOperand(1)))
2320 if (ConstantInt *BO1 = dyn_cast<ConstantInt>(BO->getOperand(1)))
2441 const ConstantInt *C = D->getValue();
3894 !ConstantInt::isValueValidForType(IntTy, NewBaseOffset))
3906 !ConstantInt::isValueValidForType(IntTy, Offset))
3945 !ConstantInt::isValueValidForType(IntTy, F.UnfoldedOffset))
4191 const SCEV *NegImmS = SE.getSCEV(ConstantInt::get(IntTy, -(uint64_t)Imm));
4207 ConstantInt::get(IntTy, -(uint64_t)Offset))))
5236 ICmpScaledV = ConstantInt::get(IntTy, -(uint64_t)Offset);
5239 ICmpScaledV = ConstantInt::get(IntTy, Offset);
5244 Ops.push_back(SE.getUnknown(ConstantInt::getSigned(IntTy, Offset)));
5252 Ops.push_back(SE.getUnknown(ConstantInt::getSigned(IntTy,
5288 Constant *C = ConstantInt::getSigned(SE.getEffectiveSCEVType(OpTy),
lib/Transforms/Scalar/LoopUnrollAndJamPass.cpp 136 mdconst::extract<ConstantInt>(MD->getOperand(1))->getZExtValue();
lib/Transforms/Scalar/LoopUnrollPass.cpp 574 else if (ConstantInt *SimpleCondVal =
575 dyn_cast<ConstantInt>(SimpleCond))
585 else if (ConstantInt *SimpleCondVal =
586 dyn_cast<ConstantInt>(SimpleCond))
696 mdconst::extract<ConstantInt>(MD->getOperand(1))->getZExtValue();
lib/Transforms/Scalar/LoopUnswitch.cpp 572 if (!isa<ConstantInt>(Cond))
576 Cond == ConstantInt::getTrue(Cond->getContext())
702 UnswitchIfProfitable(LoopCond, ConstantInt::getTrue(Context))) {
744 UnswitchIfProfitable(LoopCond, ConstantInt::getTrue(Context), TI)) {
767 auto *AllZero = cast<ConstantInt>(Constant::getNullValue(SC->getType()));
767 auto *AllZero = cast<ConstantInt>(Constant::getNullValue(SC->getType()));
775 auto *AllOne = cast<ConstantInt>(Constant::getAllOnesValue(SC->getType()));
775 auto *AllOne = cast<ConstantInt>(Constant::getAllOnesValue(SC->getType()));
818 ConstantInt::getTrue(Context))) {
943 if (!isa<ConstantInt>(Val) ||
946 else if (Val != ConstantInt::getTrue(Val->getContext())) {
1096 } else if (BI->getCondition() == ConstantInt::getTrue(Context)) {
1098 } else if (BI->getCondition() == ConstantInt::getFalse(Context)) {
1107 ConstantInt *Cond = dyn_cast<ConstantInt>(SI->getCondition());
1107 ConstantInt *Cond = dyn_cast<ConstantInt>(SI->getCondition());
1145 CondVal = ConstantInt::getTrue(Context);
1148 CondVal = ConstantInt::getFalse(Context);
1185 ConstantInt *CaseVal = Case.getCaseValue();
1461 if (IsEqual || (isa<ConstantInt>(Val) &&
1467 Replacement = ConstantInt::get(Type::getInt1Ty(Val->getContext()),
1468 !cast<ConstantInt>(Val)->getZExtValue());
1514 if (!SI || !isa<ConstantInt>(Val)) continue;
1520 *SI->findCaseValue(cast<ConstantInt>(Val));
1559 ConstantInt::getTrue(Context), NewSISucc);
1665 return ConstantInt::getFalse(Ctx);
1667 return ConstantInt::getTrue(Ctx);
lib/Transforms/Scalar/LowerConstantIntrinsics.cpp 45 return isa<Constant>(Op) ? ConstantInt::getTrue(II->getType())
46 : ConstantInt::getFalse(II->getType());
lib/Transforms/Scalar/LowerExpectIntrinsic.cpp 67 ConstantInt *ExpectedValue = dyn_cast<ConstantInt>(CI->getArgOperand(1));
67 ConstantInt *ExpectedValue = dyn_cast<ConstantInt>(CI->getArgOperand(1));
101 ConstantInt *ExpectedValue = dyn_cast<ConstantInt>(Expect->getArgOperand(1));
101 ConstantInt *ExpectedValue = dyn_cast<ConstantInt>(Expect->getArgOperand(1));
135 ConstantInt *CInt = dyn_cast<ConstantInt>(BinOp->getOperand(1));
135 ConstantInt *CInt = dyn_cast<ConstantInt>(BinOp->getOperand(1));
149 Result ^= cast<ConstantInt>(Op->getOperand(1))->getValue();
188 ConstantInt *CI = dyn_cast<ConstantInt>(PhiOpnd);
188 ConstantInt *CI = dyn_cast<ConstantInt>(PhiOpnd);
253 ConstantInt *CmpConstOperand = nullptr;
262 CmpConstOperand = dyn_cast<ConstantInt>(CmpI->getOperand(1));
283 ConstantInt *ExpectedValue = dyn_cast<ConstantInt>(CI->getArgOperand(1));
283 ConstantInt *ExpectedValue = dyn_cast<ConstantInt>(CI->getArgOperand(1));
lib/Transforms/Scalar/LowerWidenableCondition.cpp 60 CI->replaceAllUsesWith(ConstantInt::getTrue(CI->getContext()));
lib/Transforms/Scalar/MemCpyOptimizer.cpp 180 int64_t Size = cast<ConstantInt>(MSI->getLength())->getZExtValue();
348 !isa<ConstantInt>(MSI->getLength()))
710 if (isa<ConstantInt>(MSI->getLength()) && !MSI->isVolatile())
753 ConstantInt *srcArraySize = dyn_cast<ConstantInt>(srcAlloca->getArraySize());
753 ConstantInt *srcArraySize = dyn_cast<ConstantInt>(srcAlloca->getArraySize());
769 ConstantInt *destArraySize = dyn_cast<ConstantInt>(A->getArraySize());
769 ConstantInt *destArraySize = dyn_cast<ConstantInt>(A->getArraySize());
944 ConstantInt *MDepLen = dyn_cast<ConstantInt>(MDep->getLength());
944 ConstantInt *MDepLen = dyn_cast<ConstantInt>(MDep->getLength());
945 ConstantInt *MLen = dyn_cast<ConstantInt>(M->getLength());
945 ConstantInt *MLen = dyn_cast<ConstantInt>(M->getLength());
1039 if (ConstantInt *SrcSizeC = dyn_cast<ConstantInt>(SrcSize))
1039 if (ConstantInt *SrcSizeC = dyn_cast<ConstantInt>(SrcSize))
1056 Ule, ConstantInt::getNullValue(DestSize->getType()), SizeDiff);
1069 static bool hasUndefContents(Instruction *I, ConstantInt *Size) {
1075 if (ConstantInt *LTSize = dyn_cast<ConstantInt>(II->getArgOperand(0)))
1075 if (ConstantInt *LTSize = dyn_cast<ConstantInt>(II->getArgOperand(0)))
1106 ConstantInt *MemSetSize = dyn_cast<ConstantInt>(MemSet->getLength());
1106 ConstantInt *MemSetSize = dyn_cast<ConstantInt>(MemSet->getLength());
1112 ConstantInt *CopySize = cast<ConstantInt>(MemCpy->getLength());
1112 ConstantInt *CopySize = cast<ConstantInt>(MemCpy->getLength());
1173 ConstantInt *CopySize = dyn_cast<ConstantInt>(M->getLength());
1173 ConstantInt *CopySize = dyn_cast<ConstantInt>(M->getLength());
1279 ConstantInt *C1 = dyn_cast<ConstantInt>(MDep->getLength());
1279 ConstantInt *C1 = dyn_cast<ConstantInt>(MDep->getLength());
lib/Transforms/Scalar/MergeICmps.cpp 374 const auto *const Const = dyn_cast<ConstantInt>(Val);
374 const auto *const Const = dyn_cast<ConstantInt>(Val);
654 ConstantInt::get(DL.getIntPtrType(Context), TotalSizeBits / 8), Builder,
657 MemCmpCall, ConstantInt::get(Type::getInt32Ty(Context), 0));
670 Phi.addIncoming(ConstantInt::getFalse(Context), BB);
818 if (isa<ConstantInt>(Phi.getIncomingValue(I))) continue;
lib/Transforms/Scalar/NaryReassociate.cpp 427 RHS, ConstantInt::get(IntPtrTy, IndexedSize / ElementSize));
lib/Transforms/Scalar/NewGVN.cpp 1553 return createConstantExpression(ConstantInt::getTrue(Cond->getType()));
1556 return createConstantExpression(ConstantInt::getTrue(Cond->getType()));
1557 return createConstantExpression(ConstantInt::getFalse(Cond->getType()));
1854 return createConstantExpression(ConstantInt::getTrue(CI->getType()));
1859 return createConstantExpression(ConstantInt::getTrue(CI->getType()));
1861 return createConstantExpression(ConstantInt::getFalse(CI->getType()));
1922 ConstantInt::getTrue(CI->getType()));
1929 ConstantInt::getFalse(CI->getType()));
1938 ConstantInt::getFalse(CI->getType()));
1944 ConstantInt::getTrue(CI->getType()));
2482 } else if (isa<ConstantInt>(Cond)) {
2486 ConstantInt *CI;
2487 if (CondEvaluated && (CI = dyn_cast<ConstantInt>(CondEvaluated))) {
2508 if (CondEvaluated && isa<ConstantInt>(CondEvaluated)) {
2509 auto *CondVal = cast<ConstantInt>(CondEvaluated);
2509 auto *CondVal = cast<ConstantInt>(CondEvaluated);
lib/Transforms/Scalar/Reassociate.cpp 275 ConstantInt::getAllOnesValue(Ty) : ConstantFP::get(Ty, -1.0);
976 Constant *MulCst = ConstantInt::get(Shl->getType(), 1);
1066 if (ConstantInt *FC1 = dyn_cast<ConstantInt>(Factor)) {
1066 if (ConstantInt *FC1 = dyn_cast<ConstantInt>(Factor)) {
1067 if (ConstantInt *FC2 = dyn_cast<ConstantInt>(Factors[i].Op))
1067 if (ConstantInt *FC2 = dyn_cast<ConstantInt>(Factors[i].Op))
1190 Opnd, ConstantInt::get(Opnd->getType(), ConstOpnd), "and.ra",
1415 Value *C = ConstantInt::get(Ty, ConstOpnd);
1424 return ConstantInt::get(Ty, ConstOpnd);
1461 ConstantInt::get(Ty, NumFound) : ConstantFP::get(Ty, NumFound);
1558 if (ConstantInt *CI = dyn_cast<ConstantInt>(Factor)) {
1558 if (ConstantInt *CI = dyn_cast<ConstantInt>(Factor)) {
1560 Factor = ConstantInt::get(CI->getContext(), -CI->getValue());
2076 if (I->getOpcode() == Instruction::Shl && isa<ConstantInt>(I->getOperand(1)))
2244 isa<ConstantInt>(Ops.back().Op) &&
2245 cast<ConstantInt>(Ops.back().Op)->isMinusOne()) {
lib/Transforms/Scalar/SCCP.cpp 158 ConstantInt *getConstantInt() const {
160 return dyn_cast<ConstantInt>(getConstant());
676 ConstantInt *CI = BCValue.getConstantInt();
702 ConstantInt *CI = SCValue.getConstantInt();
951 if (ConstantInt *CondCB = CondValue.getConstantInt()) {
1051 if (ConstantInt *CI = NonOverdefVal->getConstantInt())
1593 if (auto *ShiftAmt = Op1LV.getConstantInt())
1610 if (auto *ShiftAmt = Op1LV.getConstantInt())
1680 BI->setCondition(ConstantInt::getFalse(BI->getContext()));
1975 if (!isa<ConstantInt>(SI->getCondition())) {
1981 if (!isa<ConstantInt>(BI->getCondition())) {
1984 C = ConstantInt::getFalse(BI->getContext());
lib/Transforms/Scalar/SROA.cpp 626 if (ConstantInt *CI = dyn_cast<ConstantInt>(SI.getCondition()))
626 if (ConstantInt *CI = dyn_cast<ConstantInt>(SI.getCondition()))
740 ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand());
740 ConstantInt *OpC = dyn_cast<ConstantInt>(GTI.getOperand());
830 ConstantInt *Length = dyn_cast<ConstantInt>(II.getLength());
830 ConstantInt *Length = dyn_cast<ConstantInt>(II.getLength());
850 ConstantInt *Length = dyn_cast<ConstantInt>(II.getLength());
850 ConstantInt *Length = dyn_cast<ConstantInt>(II.getLength());
934 ConstantInt *Length = cast<ConstantInt>(II.getArgOperand(0));
934 ConstantInt *Length = cast<ConstantInt>(II.getArgOperand(0));
1404 if (Indices.size() == 1 && cast<ConstantInt>(Indices.back())->isZero())
2786 auto *C = cast<ConstantInt>(II.getLength());
2786 auto *C = cast<ConstantInt>(II.getLength());
2800 Constant *Size = ConstantInt::get(SizeTy, NewEndOffset - NewBeginOffset);
2936 II.setLength(ConstantInt::get(II.getLength()->getType(),
2972 Constant *Size = ConstantInt::get(SizeTy, NewEndOffset - NewBeginOffset);
3089 ConstantInt *Size =
3090 ConstantInt::get(cast<IntegerType>(II.getArgOperand(0)->getType()),
lib/Transforms/Scalar/Scalarizer.cpp 278 ConstantInt *Idx = dyn_cast<ConstantInt>(Insert->getOperand(2));
278 ConstantInt *Idx = dyn_cast<ConstantInt>(Insert->getOperand(2));
lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp 525 if (ConstantInt *ConstLHS = dyn_cast<ConstantInt>(LHS)) {
525 if (ConstantInt *ConstLHS = dyn_cast<ConstantInt>(LHS)) {
529 if (ConstantInt *ConstRHS = dyn_cast<ConstantInt>(RHS)) {
529 if (ConstantInt *ConstRHS = dyn_cast<ConstantInt>(RHS)) {
582 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
582 if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) {
653 return UserChain[ChainIndex] = cast<ConstantInt>(applyExts(U));
686 return ConstantInt::getNullValue(UserChain[ChainIndex]->getType());
702 if (ConstantInt *CI = dyn_cast<ConstantInt>(NextInChain)) {
702 if (ConstantInt *CI = dyn_cast<ConstantInt>(NextInChain)) {
801 uint64_t Field = cast<ConstantInt>(GEP->getOperand(I))->getZExtValue();
838 if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx))
838 if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx))
848 Idx, ConstantInt::get(IntPtrTy, ElementSize.logBase2()));
850 Idx = Builder.CreateMul(Idx, ConstantInt::get(IntPtrTy, ElementSize));
863 Value *Offset = ConstantInt::get(IntPtrTy, AccumulativeByteOffset);
899 if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx))
899 if (ConstantInt *CI = dyn_cast<ConstantInt>(Idx))
909 Idx, ConstantInt::get(IntPtrTy, ElementSize.logBase2()));
911 Idx = Builder.CreateMul(Idx, ConstantInt::get(IntPtrTy, ElementSize));
922 ResultPtr, ConstantInt::get(IntPtrTy, AccumulativeByteOffset));
1074 ConstantInt::get(IntPtrTy, Index, true),
1099 ConstantInt::get(IntPtrTy, AccumulativeByteOffset, true), "uglygep",
1264 isa<ConstantInt>(FirstOffsetDef->getOperand(1)))
1273 (isa<ConstantInt>(BO->getOperand(0)) ||
1274 isa<ConstantInt>(BO->getOperand(1))))
lib/Transforms/Scalar/SimpleLoopUnswitch.cpp 523 ConstantInt *Replacement = ExitDirection
524 ? ConstantInt::getFalse(BI.getContext())
525 : ConstantInt::getTrue(BI.getContext());
622 SmallVector<std::tuple<ConstantInt *, BasicBlock *,
735 ConstantInt *CaseVal = std::get<0>(ExitCase);
2214 ConstantInt *UnswitchedReplacement =
2215 Direction ? ConstantInt::getTrue(BI->getContext())
2216 : ConstantInt::getFalse(BI->getContext());
2217 ConstantInt *ContinueReplacement =
2218 Direction ? ConstantInt::getFalse(BI->getContext())
2219 : ConstantInt::getTrue(BI->getContext());
2411 GI->setArgOperand(0, ConstantInt::getFalse(GI->getContext()));
lib/Transforms/Scalar/SpeculateAroundPHIs.cpp 216 SmallDenseMap<ConstantInt *, CostsAndCount, 16> CostsAndCounts;
219 auto *IncomingC = dyn_cast<ConstantInt>(PN.getIncomingValue(i));
219 auto *IncomingC = dyn_cast<ConstantInt>(PN.getIncomingValue(i));
282 ConstantInt *IncomingC = IncomingConstantAndCostsAndCount.first;
lib/Transforms/Scalar/StraightLineStrengthReduce.cpp 110 Candidate(Kind CT, const SCEV *B, ConstantInt *Idx, Value *S,
121 ConstantInt *Index = nullptr;
204 void allocateCandidatesAndFindBasisForGEP(const SCEV *B, ConstantInt *Idx,
211 ConstantInt *Idx, Value *S,
282 static bool isAddFoldable(const SCEV *Base, ConstantInt *Index, Value *Stride,
304 ConstantInt *ConstIdx = dyn_cast<ConstantInt>(*I);
304 ConstantInt *ConstIdx = dyn_cast<ConstantInt>(*I);
336 Candidate::Kind CT, const SCEV *B, ConstantInt *Idx, Value *S,
402 ConstantInt *Idx = nullptr;
409 Idx = ConstantInt::get(Idx->getContext(), One << Idx->getValue());
413 ConstantInt *One = ConstantInt::get(cast<IntegerType>(I->getType()), 1);
413 ConstantInt *One = ConstantInt::get(cast<IntegerType>(I->getType()), 1);
420 static bool matchesAdd(Value *A, Value *&B, ConstantInt *&C) {
426 static bool matchesOr(Value *A, Value *&B, ConstantInt *&C) {
434 ConstantInt *Idx = nullptr;
447 ConstantInt *Zero = ConstantInt::get(cast<IntegerType>(I->getType()), 0);
447 ConstantInt *Zero = ConstantInt::get(cast<IntegerType>(I->getType()), 0);
470 const SCEV *B, ConstantInt *Idx, Value *S, uint64_t ElementSize,
477 ConstantInt *ScaledIdx = ConstantInt::get(
477 ConstantInt *ScaledIdx = ConstantInt::get(
488 Base, ConstantInt::get(cast<IntegerType>(ArrayIdx->getType()), 1),
491 ConstantInt *RHS = nullptr;
511 ConstantInt *PowerOf2 =
512 ConstantInt::get(RHS->getContext(), One << RHS->getValue());
608 ConstantInt *Exponent = ConstantInt::get(DeltaType, IndexOffset.logBase2());
608 ConstantInt *Exponent = ConstantInt::get(DeltaType, IndexOffset.logBase2());
613 ConstantInt *Exponent =
614 ConstantInt::get(DeltaType, (-IndexOffset).logBase2());
617 Constant *Delta = ConstantInt::get(DeltaType, IndexOffset);
lib/Transforms/Scalar/StructurizeCFG.cpp 184 ConstantInt *BoolTrue;
185 ConstantInt *BoolFalse;
305 BoolTrue = ConstantInt::getTrue(Context);
306 BoolFalse = ConstantInt::getFalse(Context);
lib/Transforms/Scalar/TailRecursionElimination.cpp 586 if (isa<ConstantInt>(AI->getArraySize()))
lib/Transforms/Utils/BuildLibCalls.cpp 865 {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, B, TLI);
1264 ConstantInt::get(DL.getIntPtrType(Context), 1), File});
lib/Transforms/Utils/BypassSlowDivision.cpp 204 ConstantInt *C = dyn_cast<ConstantInt>(Op1);
204 ConstantInt *C = dyn_cast<ConstantInt>(Op1);
206 C = dyn_cast<ConstantInt>(cast<BitCastInst>(Op1)->getOperand(0));
344 Value *ZeroV = ConstantInt::getSigned(getSlowType(), 0);
383 if (isa<ConstantInt>(Divisor)) {
396 isa<ConstantInt>(BCI->getOperand(0)))
417 Long.Quotient = ConstantInt::get(getSlowType(), 0);
lib/Transforms/Utils/CloneFunction.cpp 65 if (isa<ConstantInt>(AI->getArraySize()))
375 if (isa<ConstantInt>(AI->getArraySize()))
388 ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
388 ConstantInt *Cond = dyn_cast<ConstantInt>(BI->getCondition());
392 Cond = dyn_cast_or_null<ConstantInt>(V);
405 ConstantInt *Cond = dyn_cast<ConstantInt>(SI->getCondition());
405 ConstantInt *Cond = dyn_cast<ConstantInt>(SI->getCondition());
408 Cond = dyn_cast_or_null<ConstantInt>(V);
lib/Transforms/Utils/CodeExtractor.cpp 935 Idx[1] = ConstantInt::get(Type::getInt32Ty(header->getContext()), i);
1012 auto NegativeOne = ConstantInt::getSigned(Type::getInt64Ty(Ctx), -1);
1119 Idx[1] = ConstantInt::get(Type::getInt32Ty(Context), i);
1158 Idx[1] = ConstantInt::get(Type::getInt32Ty(Context), FirstOut + i);
1211 brVal = ConstantInt::get(Type::getInt1Ty(Context), !SuccNum);
1214 brVal = ConstantInt::get(Type::getInt16Ty(Context), SuccNum);
1221 TheSwitch->addCase(ConstantInt::get(Type::getInt16Ty(Context),
1261 Idx[1] = ConstantInt::get(Type::getInt32Ty(Context), FirstOut + i);
lib/Transforms/Utils/CtorUtils.cpp 106 ConstantInt *CI = cast<ConstantInt>(CS->getOperand(0));
106 ConstantInt *CI = cast<ConstantInt>(CS->getOperand(0));
lib/Transforms/Utils/EntryExitInstrumenter.cpp 47 ArrayRef<Value *>(ConstantInt::get(Type::getInt32Ty(C), 0)), "",
lib/Transforms/Utils/Evaluator.cpp 102 if (!isa<ConstantInt>(CE->getOperand(i)))
108 if (!isa<ConstantInt>(CE->getOperand(1)))
153 ConstantInt *CI = dyn_cast<ConstantInt>(*std::next(CE->op_begin()));
153 ConstantInt *CI = dyn_cast<ConstantInt>(*std::next(CE->op_begin()));
195 Constant *IdxZero = ConstantInt::get(IdxTy, 0, false);
526 ConstantInt *Size = cast<ConstantInt>(II->getArgOperand(0));
526 ConstantInt *Size = cast<ConstantInt>(II->getArgOperand(0));
614 ConstantInt *Cond =
615 dyn_cast<ConstantInt>(getVal(BI->getCondition()));
621 ConstantInt *Val =
622 dyn_cast<ConstantInt>(getVal(SI->getCondition()));
lib/Transforms/Utils/FunctionComparator.cpp 161 ConstantInt *LLow = mdconst::extract<ConstantInt>(L->getOperand(I));
161 ConstantInt *LLow = mdconst::extract<ConstantInt>(L->getOperand(I));
162 ConstantInt *RLow = mdconst::extract<ConstantInt>(R->getOperand(I));
162 ConstantInt *RLow = mdconst::extract<ConstantInt>(R->getOperand(I));
291 const APInt &LInt = cast<ConstantInt>(L)->getValue();
292 const APInt &RInt = cast<ConstantInt>(R)->getValue();
lib/Transforms/Utils/InlineFunction.cpp 1052 bool IsNonPtrConst = isa<ConstantInt>(V) || isa<ConstantFP>(V) ||
1970 ConstantInt *AllocaSize = nullptr;
1971 if (ConstantInt *AIArraySize =
1972 dyn_cast<ConstantInt>(AI->getArraySize())) {
1987 AllocaSize = ConstantInt::get(Type::getInt64Ty(AI->getContext()),
lib/Transforms/Utils/IntegerDivision.cpp 36 ConstantInt *Shift;
108 ConstantInt *Shift;
160 ConstantInt *Zero;
161 ConstantInt *One;
162 ConstantInt *NegOne;
163 ConstantInt *MSB;
168 NegOne = ConstantInt::getSigned(DivTy, -1);
174 NegOne = ConstantInt::getSigned(DivTy, -1);
178 ConstantInt *True = Builder.getTrue();
lib/Transforms/Utils/Local.cpp 121 if (auto *Cond = dyn_cast<ConstantInt>(BI->getCondition())) {
121 if (auto *Cond = dyn_cast<ConstantInt>(BI->getCondition())) {
162 auto *CI = dyn_cast<ConstantInt>(SI->getCondition());
162 auto *CI = dyn_cast<ConstantInt>(SI->getCondition());
192 auto *CI = mdconst::extract<ConstantInt>(MD->getOperand(MD_i));
192 auto *CI = mdconst::extract<ConstantInt>(MD->getOperand(MD_i));
277 ConstantInt *SICase =
278 mdconst::dyn_extract<ConstantInt>(MD->getOperand(2));
279 ConstantInt *SIDef =
280 mdconst::dyn_extract<ConstantInt>(MD->getOperand(1));
415 if (ConstantInt *Cond = dyn_cast<ConstantInt>(II->getArgOperand(0)))
415 if (ConstantInt *Cond = dyn_cast<ConstantInt>(II->getArgOperand(0)))
708 ConstantInt::get(Type::getInt32Ty(BA->getContext()), 1);
1687 auto *ConstInt = dyn_cast<ConstantInt>(I.getOperand(1));
1687 auto *ConstInt = dyn_cast<ConstantInt>(I.getOperand(1));
2561 auto *NonNullInt = ConstantExpr::getAdd(NullInt, ConstantInt::get(ITy, 1));
2723 if (I->isLogicalShift() && isa<ConstantInt>(I->getOperand(1))) {
2725 cast<ConstantInt>(I->getOperand(1))->getLimitedValue(~0U);
2752 isa<ConstantInt>(I->getOperand(1))) {
2754 const APInt &AndMask = cast<ConstantInt>(I->getOperand(1))->getValue();
lib/Transforms/Utils/LoopRotationUtils.cpp 446 if (!isa<ConstantInt>(PHBI->getCondition()) ||
447 PHBI->getSuccessor(cast<ConstantInt>(PHBI->getCondition())->isZero()) !=
lib/Transforms/Utils/LoopSimplify.cpp 528 BI->setCondition(ConstantInt::get(Cond->getType(),
lib/Transforms/Utils/LoopUnroll.cpp 190 if (isa<ConstantInt>(PN.getIncomingValueForBlock(PreHeader)))
lib/Transforms/Utils/LoopUnrollRuntime.cpp 158 B.CreateICmpULT(BECount, ConstantInt::get(BECount->getType(), Count - 1));
361 Builder.CreateSub(NewIdx, ConstantInt::get(NewIdx->getType(), 1),
737 ConstantInt::get(BECount->getType(),
740 ConstantInt::get(ModValTmp->getType(), 1));
744 ConstantInt::get(BECount->getType(), Count),
749 ConstantInt::get(BECount->getType(),
901 B2.CreateSub(NewIdx, ConstantInt::get(NewIdx->getType(), 1),
lib/Transforms/Utils/LoopUtils.cpp 204 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), V))};
223 ConstantInt *IntMD =
224 mdconst::extract_or_null<ConstantInt>(Node->getOperand(1));
276 if (ConstantInt *IntMD =
277 mdconst::extract_or_null<ConstantInt>(MD->getOperand(1).get()))
295 ConstantInt *IntMD = mdconst::extract_or_null<ConstantInt>(AttrMD->get());
295 ConstantInt *IntMD = mdconst::extract_or_null<ConstantInt>(AttrMD->get());
lib/Transforms/Utils/LoopVersioning.cpp 71 auto *CI = dyn_cast<ConstantInt>(SCEVRuntimeCheck);
71 auto *CI = dyn_cast<ConstantInt>(SCEVRuntimeCheck);
lib/Transforms/Utils/LowerMemIntrinsics.cpp 26 Value *DstAddr, ConstantInt *CopyLen,
71 LoopIndex->addIncoming(ConstantInt::get(TypeOfCopyLen, 0U), PreLoopBB);
81 LoopBuilder.CreateAdd(LoopIndex, ConstantInt::get(TypeOfCopyLen, 1U));
85 Constant *LoopEndCI = ConstantInt::get(TypeOfCopyLen, LoopEndCount);
116 OpTy, CastedSrc, ConstantInt::get(TypeOfCopyLen, GepIndex));
125 OpTy, CastedDst, ConstantInt::get(TypeOfCopyLen, GepIndex));
172 ConstantInt *CILoopOpSize = ConstantInt::get(ILengthType, LoopOpSize);
172 ConstantInt *CILoopOpSize = ConstantInt::get(ILengthType, LoopOpSize);
181 LoopIndex->addIncoming(ConstantInt::get(CopyLenType, 0U), PreLoopBB);
189 LoopBuilder.CreateAdd(LoopIndex, ConstantInt::get(CopyLenType, 1U));
210 ConstantInt *Zero = ConstantInt::get(ILengthType, 0U);
210 ConstantInt *Zero = ConstantInt::get(ILengthType, 0U);
243 ResBuilder.CreateAdd(ResidualIndex, ConstantInt::get(CopyLenType, 1U));
255 ConstantInt *Zero = ConstantInt::get(ILengthType, 0U);
255 ConstantInt *Zero = ConstantInt::get(ILengthType, 0U);
325 ConstantInt::get(TypeOfCopyLen, 0), "compare_n_to_0");
333 LoopPhi, ConstantInt::get(TypeOfCopyLen, 1), "index_ptr");
340 LoopBuilder.CreateICmpEQ(IndexPtr, ConstantInt::get(TypeOfCopyLen, 0)),
358 FwdCopyPhi, ConstantInt::get(TypeOfCopyLen, 1), "index_increment");
362 FwdCopyPhi->addIncoming(ConstantInt::get(TypeOfCopyLen, 0), CopyForwardBB);
387 Builder.CreateICmpEQ(ConstantInt::get(TypeOfCopyLen, 0), CopyLen), NewBB,
393 LoopIndex->addIncoming(ConstantInt::get(TypeOfCopyLen, 0), OrigBB);
401 LoopBuilder.CreateAdd(LoopIndex, ConstantInt::get(TypeOfCopyLen, 1));
410 if (ConstantInt *CI = dyn_cast<ConstantInt>(Memcpy->getLength())) {
410 if (ConstantInt *CI = dyn_cast<ConstantInt>(Memcpy->getLength())) {
lib/Transforms/Utils/LowerSwitch.cpp 89 ConstantInt* Low;
90 ConstantInt* High;
93 CaseRange(ConstantInt *low, ConstantInt *high, BasicBlock *bb)
93 CaseRange(ConstantInt *low, ConstantInt *high, BasicBlock *bb)
106 ConstantInt *LowerBound, ConstantInt *UpperBound,
106 ConstantInt *LowerBound, ConstantInt *UpperBound,
111 ConstantInt *LowerBound, ConstantInt *UpperBound,
111 ConstantInt *LowerBound, ConstantInt *UpperBound,
121 const ConstantInt* CI1 = cast<const ConstantInt>(C1.Low);
121 const ConstantInt* CI1 = cast<const ConstantInt>(C1.Low);
122 const ConstantInt* CI2 = cast<const ConstantInt>(C2.High);
122 const ConstantInt* CI2 = cast<const ConstantInt>(C2.High);
248 LowerSwitch::switchConvert(CaseItr Begin, CaseItr End, ConstantInt *LowerBound,
249 ConstantInt *UpperBound, Value *Val,
285 ConstantInt *NewLowerBound = Pivot.Low;
289 ConstantInt *NewUpperBound = ConstantInt::get(NewLowerBound->getContext(),
289 ConstantInt *NewUpperBound = ConstantInt::get(NewLowerBound->getContext(),
333 ConstantInt *LowerBound,
334 ConstantInt *UpperBound,
472 ConstantInt *LowerBound = nullptr;
473 ConstantInt *UpperBound = nullptr;
509 LowerBound = ConstantInt::get(SI->getContext(), Min);
510 UpperBound = ConstantInt::get(SI->getContext(), Max);
lib/Transforms/Utils/MisExpect.cpp 110 const auto *IndexCint =
111 mdconst::dyn_extract<ConstantInt>(MisExpectData->getOperand(1));
112 const auto *LikelyCInt =
113 mdconst::dyn_extract<ConstantInt>(MisExpectData->getOperand(2));
114 const auto *UnlikelyCInt =
115 mdconst::dyn_extract<ConstantInt>(MisExpectData->getOperand(3));
165 ConstantInt *Value =
166 mdconst::dyn_extract<ConstantInt>(MD->getOperand(i));
lib/Transforms/Utils/SanitizerStats.cpp 53 ConstantInt::get(IntPtrTy, uint64_t(SK) << (IntPtrTy->getBitWidth() -
65 ConstantInt::get(IntPtrTy, 0), ConstantInt::get(B.getInt32Ty(), 2),
65 ConstantInt::get(IntPtrTy, 0), ConstantInt::get(B.getInt32Ty(), 2),
66 ConstantInt::get(IntPtrTy, Inits.size() - 1),
87 ConstantInt::get(Int32Ty, Inits.size()),
lib/Transforms/Utils/SimplifyCFG.cpp 155 SmallVector<std::pair<Constant *, SmallVector<ConstantInt *, 4>>, 2>;
164 ConstantInt *Value;
167 ValueEqualityComparisonCase(ConstantInt *Value, BasicBlock *Dest)
290 !isa<ConstantInt>(PN->getIncomingValueForBlock(SI2BB)))
409 static ConstantInt *GetConstantInt(Value *V, const DataLayout &DL) {
411 ConstantInt *CI = dyn_cast<ConstantInt>(V);
411 ConstantInt *CI = dyn_cast<ConstantInt>(V);
421 return ConstantInt::get(PtrTy, 0);
426 if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(0))) {
426 if (ConstantInt *CI = dyn_cast<ConstantInt>(CE->getOperand(0))) {
431 return cast<ConstantInt>(
459 SmallVector<ConstantInt *, 8> Vals;
493 ConstantInt *C;
556 ConstantInt::get(C->getContext(),
578 Vals.push_back(ConstantInt::get(C->getContext(),
623 Vals.push_back(ConstantInt::get(I->getContext(), Tmp));
765 ConstantInt *TheVal = (*V1)[0].Value;
891 ConstantInt *TIV = nullptr;
940 bool operator()(const ConstantInt *LHS, const ConstantInt *RHS) const {
940 bool operator()(const ConstantInt *LHS, const ConstantInt *RHS) const {
947 static int ConstantIntSortPredicate(ConstantInt *const *P1,
948 ConstantInt *const *P2) {
949 const ConstantInt *LHS = *P1;
950 const ConstantInt *RHS = *P2;
973 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(i));
973 ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(i));
1066 std::set<ConstantInt *, ConstantIntOrdering> PTIHandled;
1121 std::set<ConstantInt *, ConstantIntOrdering> PTIHandled;
1122 std::map<ConstantInt *, uint64_t> WeightsForHandled;
1154 for (ConstantInt *I : PTIHandled) {
2203 ConstantInt *CB = dyn_cast<ConstantInt>(PN->getIncomingValue(i));
2203 ConstantInt *CB = dyn_cast<ConstantInt>(PN->getIncomingValue(i));
2310 isa<ConstantInt>(IfCond))
2815 ConstantInt *PBI_C = cast<ConstantInt>(
2815 ConstantInt *PBI_C = cast<ConstantInt>(
3236 ConstantInt::get(Type::getInt1Ty(BB->getContext()), CondIsTrue));
3258 ConstantInt::get(Type::getInt1Ty(BB->getContext()), CondIsTrue),
3523 ConstantInt *TrueVal = dyn_cast<ConstantInt>(Select->getTrueValue());
3523 ConstantInt *TrueVal = dyn_cast<ConstantInt>(Select->getTrueValue());
3524 ConstantInt *FalseVal = dyn_cast<ConstantInt>(Select->getFalseValue());
3524 ConstantInt *FalseVal = dyn_cast<ConstantInt>(Select->getFalseValue());
3600 ConstantInt *Cst = cast<ConstantInt>(ICI->getOperand(1));
3600 ConstantInt *Cst = cast<ConstantInt>(ICI->getOperand(1));
3617 ConstantInt *VVal = SI->findCaseDest(BB);
3635 V = ConstantInt::getFalse(BB->getContext());
3637 V = ConstantInt::getTrue(BB->getContext());
3655 Constant *DefaultCst = ConstantInt::getTrue(BB->getContext());
3656 Constant *NewCst = ConstantInt::getFalse(BB->getContext());
3705 SmallVectorImpl<ConstantInt *> &Values = ConstantCompare.Vals;
4313 static bool CasesAreContiguous(SmallVectorImpl<ConstantInt *> &Cases) {
4346 SmallVector<ConstantInt *, 16> CasesA;
4347 SmallVector<ConstantInt *, 16> CasesB;
4374 SmallVectorImpl<ConstantInt *> *ContiguousCases = nullptr;
4392 ConstantInt::get(Offset->getType(), ContiguousCases->size());
4401 Cmp = ConstantInt::getTrue(SI->getContext());
4469 SmallVector<ConstantInt *, 8> DeadCases;
4500 for (ConstantInt *DeadCase : DeadCases) {
4517 static PHINode *FindPHIForConditionForwarding(ConstantInt *CaseValue,
4555 ConstantInt *CaseValue = Case.getCaseValue();
4611 if (!isa<ConstantFP>(C) && !isa<ConstantInt>(C) &&
4678 GetCaseResults(SwitchInst *SI, ConstantInt *CaseVal, BasicBlock *CaseDest,
4749 static uintptr_t MapCaseToResult(ConstantInt *CaseVal,
4774 ConstantInt *CaseVal = I.getCaseValue();
4840 ConstantInt *const FirstCase = ResultVector[0].second[0];
4841 ConstantInt *const SecondCase = ResultVector[1].second[0];
4922 Module &M, uint64_t TableSize, ConstantInt *Offset,
4923 const SmallVectorImpl<std::pair<ConstantInt *, Constant *>> &Values,
4962 ConstantInt *BitMap = nullptr;
4966 ConstantInt *LinearOffset = nullptr;
4967 ConstantInt *LinearMultiplier = nullptr;
4976 Module &M, uint64_t TableSize, ConstantInt *Offset,
4977 const SmallVectorImpl<std::pair<ConstantInt *, Constant *>> &Values,
4990 ConstantInt *CaseVal = Values[I].first;
5031 ConstantInt *ConstVal = dyn_cast<ConstantInt>(TableContents[I]);
5031 ConstantInt *ConstVal = dyn_cast<ConstantInt>(TableContents[I]);
5051 LinearOffset = cast<ConstantInt>(TableContents[0]);
5052 LinearMultiplier = ConstantInt::get(M.getContext(), DistToPrev);
5067 ConstantInt *Val = cast<ConstantInt>(TableContents[I - 1]);
5067 ConstantInt *Val = cast<ConstantInt>(TableContents[I - 1]);
5071 BitMap = ConstantInt::get(M.getContext(), TableInt);
5117 ShiftAmt, ConstantInt::get(MapTy, BitMapElementTy->getBitWidth()),
5228 const SmallVectorImpl<std::pair<ConstantInt *, Constant *>> &Values) {
5243 Constant *TrueConst = ConstantInt::getTrue(RangeCmp->getType());
5244 Constant *FalseConst = ConstantInt::getFalse(RangeCmp->getType());
5281 RangeCmp, ConstantInt::get(RangeCmp->getType(), 1), "inverted.cmp",
5319 ConstantInt *MinCaseVal = CI->getCaseValue();
5320 ConstantInt *MaxCaseVal = CI->getCaseValue();
5324 using ResultListTy = SmallVector<std::pair<ConstantInt *, Constant *>, 4>;
5332 ConstantInt *CaseVal = CI->getCaseValue();
5426 TableIndex, ConstantInt::get(MinCaseVal->getType(), TableSize));
5454 ConstantInt *TableMask = ConstantInt::get(Mod.getContext(), MaskInt);
5454 ConstantInt *TableMask = ConstantInt::get(Mod.getContext(), MaskInt);
5617 auto *ShiftC = ConstantInt::get(Ty, Shift);
5617 auto *ShiftC = ConstantInt::get(Ty, Shift);
5618 auto *Sub = Builder.CreateSub(SI->getCondition(), ConstantInt::get(Ty, Base));
5625 auto *Orig = Case.getCaseValue();
5628 cast<ConstantInt>(ConstantInt::get(Ty, Sub.lshr(ShiftC->getValue()))));
5628 cast<ConstantInt>(ConstantInt::get(Ty, Sub.lshr(ShiftC->getValue()))));
5823 if (ICI->isEquality() && isa<ConstantInt>(ICI->getOperand(1))) {
5898 ConstantInt *TorF = *Imp ? ConstantInt::getTrue(BB->getContext())
5898 ConstantInt *TorF = *Imp ? ConstantInt::getTrue(BB->getContext())
5899 : ConstantInt::getFalse(BB->getContext());
lib/Transforms/Utils/SimplifyIndVar.cpp 121 !isa<ConstantInt>(UseInst->getOperand(1)))
127 || !isa<ConstantInt>(IVOperand->getOperand(1)))
134 ConstantInt *D = cast<ConstantInt>(UseInst->getOperand(1));
134 ConstantInt *D = cast<ConstantInt>(UseInst->getOperand(1));
141 D = ConstantInt::get(UseInst->getContext(),
265 ICmp->replaceAllUsesWith(ConstantInt::getTrue(ICmp->getContext()));
269 ICmp->replaceAllUsesWith(ConstantInt::getFalse(ICmp->getContext()));
346 SelectInst::Create(ICmp, ConstantInt::get(T, 0), N, "iv.rem", Rem);
463 EVI->replaceAllUsesWith(ConstantInt::getFalse(WO->getContext()));
lib/Transforms/Utils/SimplifyLibCalls.cpp 138 return ConstantInt::get(CI->getType(), Result);
237 if (ConstantInt *LenC = dyn_cast<ConstantInt>(Size)) {
237 if (ConstantInt *LenC = dyn_cast<ConstantInt>(Size)) {
292 ConstantInt::get(DL.getIntPtrType(Src->getContext()), Len + 1));
307 ConstantInt *LengthArg = dyn_cast<ConstantInt>(Size);
307 ConstantInt *LengthArg = dyn_cast<ConstantInt>(Size);
347 ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
347 ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
358 ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len),
386 ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
386 ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
415 return ConstantInt::get(CI->getType(), 0);
423 return ConstantInt::get(CI->getType(), Str1.compare(Str2));
443 ConstantInt::get(DL.getIntPtrType(CI->getContext()),
453 ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len2), B, DL,
459 ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len1), B, DL,
472 return ConstantInt::get(CI->getType(), 0);
478 if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(Size))
478 if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(Size))
484 return ConstantInt::get(CI->getType(), 0);
497 return ConstantInt::get(CI->getType(), SubStr1.compare(SubStr2));
521 ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len2), B, DL,
528 ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len1), B, DL,
537 ConstantInt *Size = dyn_cast<ConstantInt>(CI->getArgOperand(1));
537 ConstantInt *Size = dyn_cast<ConstantInt>(CI->getArgOperand(1));
565 ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len));
586 Value *LenV = ConstantInt::get(DL.getIntPtrType(PT), Len);
588 ConstantInt::get(DL.getIntPtrType(PT), Len - 1));
607 if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(Size))
607 if (ConstantInt *LengthArg = dyn_cast<ConstantInt>(Size))
640 CallInst *NewCI = B.CreateMemCpy(Dst, 1, Src, 1, ConstantInt::get(DL.getIntPtrType(PT), Len));
651 return ConstantInt::get(CI->getType(), Len - 1);
704 return B.CreateSub(ConstantInt::get(CI->getType(), NullTermIdx),
722 ConstantInt::get(CI->getType(), LenTrue - 1),
723 ConstantInt::get(CI->getType(), LenFalse - 1));
806 return ConstantInt::get(CI->getType(), Pos);
826 return ConstantInt::get(CI->getType(), Pos);
854 ConstantInt::getNullValue(StrNCmp->getType()), "cmp");
903 ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
903 ConstantInt *CharC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
904 ConstantInt *LenC = dyn_cast<ConstantInt>(Size);
904 ConstantInt *LenC = dyn_cast<ConstantInt>(Size);
1057 return ConstantInt::get(CI->getType(), Ret);
1074 ConstantInt *LenC = dyn_cast<ConstantInt>(Size);
1074 ConstantInt *LenC = dyn_cast<ConstantInt>(Size);
1147 auto *FillValue = dyn_cast<ConstantInt>(Memset->getArgOperand(1));
1147 auto *FillValue = dyn_cast<ConstantInt>(Memset->getArgOperand(1));
1178 if (Value *Calloc = emitCalloc(ConstantInt::get(SizeType, 1),
1747 Base, ConstantInt::get(B.getInt32Ty(), IntExpo), M, B);
2112 Sin = B.CreateExtractElement(SinCos, ConstantInt::get(B.getInt32Ty(), 0),
2114 Cos = B.CreateExtractElement(SinCos, ConstantInt::get(B.getInt32Ty(), 1),
2207 V = B.CreateAdd(V, ConstantInt::get(V->getType(), 1));
2221 V = B.CreateSub(ConstantInt::get(V->getType(), ArgType->getIntegerBitWidth()),
2253 ConstantInt::get(CI->getType(), 0x7F));
2272 if (ConstantInt *CInt = dyn_cast<ConstantInt>(CI->getArgOperand(2))) {
2272 if (ConstantInt *CInt = dyn_cast<ConstantInt>(CI->getArgOperand(2))) {
2333 return CI->use_empty() ? (Value *)CI : ConstantInt::get(CI->getType(), 0);
2430 ConstantInt::get(DL.getIntPtrType(CI->getContext()),
2432 return ConstantInt::get(CI->getType(), FormatStr.size());
2452 return ConstantInt::get(CI->getType(), 1);
2465 B.CreateAdd(Len, ConstantInt::get(Len->getType(), 1), "leninc");
2512 ConstantInt *Size = dyn_cast<ConstantInt>(CI->getArgOperand(1));
2512 ConstantInt *Size = dyn_cast<ConstantInt>(CI->getArgOperand(1));
2530 return ConstantInt::get(CI->getType(), FormatStr.size());
2538 ConstantInt::get(DL.getIntPtrType(CI->getContext()),
2540 return ConstantInt::get(CI->getType(), FormatStr.size());
2551 return ConstantInt::get(CI->getType(), 1);
2564 return ConstantInt::get(CI->getType(), 1);
2574 return ConstantInt::get(CI->getType(), Str.size());
2579 ConstantInt::get(CI->getType(), Str.size() + 1));
2582 return ConstantInt::get(CI->getType(), Str.size());
2620 ConstantInt::get(DL.getIntPtrType(CI->getContext()), FormatStr.size()),
2686 ConstantInt *SizeC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
2686 ConstantInt *SizeC = dyn_cast<ConstantInt>(CI->getArgOperand(1));
2687 ConstantInt *CountC = dyn_cast<ConstantInt>(CI->getArgOperand(2));
2687 ConstantInt *CountC = dyn_cast<ConstantInt>(CI->getArgOperand(2));
2693 return ConstantInt::get(CI->getType(), 0);
2701 return NewCI ? ConstantInt::get(CI->getType(), 1) : nullptr;
2741 ConstantInt::get(DL.getIntPtrType(CI->getContext()), Len - 1),
3188 ConstantInt *Flag = dyn_cast<ConstantInt>(CI->getArgOperand(*FlagOp));
3188 ConstantInt *Flag = dyn_cast<ConstantInt>(CI->getArgOperand(*FlagOp));
3196 if (ConstantInt *ObjSizeCI =
3197 dyn_cast<ConstantInt>(CI->getArgOperand(ObjSizeOp))) {
3215 if (ConstantInt *SizeCI =
3216 dyn_cast<ConstantInt>(CI->getArgOperand(*SizeOp)))
3295 Value *LenV = ConstantInt::get(SizeTTy, Len);
3300 return B.CreateGEP(B.getInt8Ty(), Dst, ConstantInt::get(SizeTTy, Len - 1));
lib/Transforms/Utils/VNCoercion.cpp 121 StoredVal, ConstantInt::get(StoredVal->getType(), ShiftAmt));
286 ConstantInt *SizeCst = dyn_cast<ConstantInt>(MI->getLength());
286 ConstantInt *SizeCst = dyn_cast<ConstantInt>(MI->getLength());
295 auto *CI = dyn_cast<ConstantInt>(cast<MemSetInst>(MI)->getValue());
295 auto *CI = dyn_cast<ConstantInt>(cast<MemSetInst>(MI)->getValue());
334 ConstantInt::get(Type::getInt64Ty(Src->getContext()), (unsigned)Offset);
375 ConstantInt::get(SrcVal->getType(), ShiftAmt));
485 Val, ConstantInt::get(Val->getType(), NumBytesSet * 8));
492 T *ShVal = Helper.CreateShl(Val, ConstantInt::get(Val->getType(), 1 * 8));
510 ConstantInt::get(Type::getInt64Ty(Src->getContext()), (unsigned)Offset);
lib/Transforms/Vectorize/LoadStoreVectorizer.cpp 452 isa<ConstantInt>(OpB->getOperand(1)) &&
453 IdxDiff.sle(cast<ConstantInt>(OpB->getOperand(1))->getSExtValue())) {
789 return EEI && isa<ConstantInt>(EEI->getOperand(1));
835 return EEI && isa<ConstantInt>(EEI->getOperand(1));
1208 unsigned Idx = cast<ConstantInt>(UI->getOperand(1))->getZExtValue();
lib/Transforms/Vectorize/LoopVectorizationLegality.cpp 99 ConstantAsMetadata::get(ConstantInt::get(Context, APInt(32, 1)))});
222 const ConstantInt *C = mdconst::dyn_extract<ConstantInt>(Arg);
222 const ConstantInt *C = mdconst::dyn_extract<ConstantInt>(Arg);
lib/Transforms/Vectorize/LoopVectorize.cpp 355 return Ty->isIntegerTy() ? ConstantInt::getSigned(Ty, C)
1907 Indices.push_back(ConstantInt::get(STy, StartIdx + i));
1996 V = ConstantInt::get(V->getType(), 1);
2609 Constant *Step = ConstantInt::get(Ty, VF * UF);
2620 TC = Builder.CreateAdd(TC, ConstantInt::get(Ty, VF * UF - 1), "n.rnd.up");
2638 auto *IsZero = Builder.CreateICmpEQ(R, ConstantInt::get(R->getType(), 0));
2695 P, Count, ConstantInt::get(Count->getType(), VF * UF),
2721 if (auto *C = dyn_cast<ConstantInt>(SCEVCheck))
2721 if (auto *C = dyn_cast<ConstantInt>(SCEVCheck))
2813 if (auto *CX = dyn_cast<ConstantInt>(X))
2813 if (auto *CX = dyn_cast<ConstantInt>(X))
2816 if (auto *CY = dyn_cast<ConstantInt>(Y))
2816 if (auto *CY = dyn_cast<ConstantInt>(Y))
2824 if (auto *CX = dyn_cast<ConstantInt>(X))
2824 if (auto *CX = dyn_cast<ConstantInt>(X))
2827 if (auto *CY = dyn_cast<ConstantInt>(Y))
2827 if (auto *CY = dyn_cast<ConstantInt>(Y))
2963 Value *StartIdx = ConstantInt::get(IdxTy, 0);
2985 Constant *Step = ConstantInt::get(IdxTy, VF * UF);
3141 CountRoundDown, ConstantInt::get(CountRoundDown->getType(), 1));
4031 Constant *Idx = ConstantInt::get(PtrInd->getType(), Lane + Part * VF);
4058 auto *CInt = dyn_cast<ConstantInt>(Divisor);
4058 auto *CInt = dyn_cast<ConstantInt>(Divisor);
6576 Constant *C = ConstantInt::get(Ty, StartIdx);
lib/Transforms/Vectorize/SLPVectorizer.cpp 278 auto *Idx = dyn_cast<ConstantInt>(EI->getIndexOperand());
278 auto *Idx = dyn_cast<ConstantInt>(EI->getIndexOperand());
426 auto *CI = dyn_cast<ConstantInt>(E->getOperand(1));
426 auto *CI = dyn_cast<ConstantInt>(E->getOperand(1));
2642 if (!isa<ConstantInt>(Op)) {
2949 auto *IO = cast<ConstantInt>(
2949 auto *IO = cast<ConstantInt>(
2974 auto *IO = cast<ConstantInt>(
2974 auto *IO = cast<ConstantInt>(
2988 auto *IO = cast<ConstantInt>(
2988 auto *IO = cast<ConstantInt>(
3115 ConstantInt *CInt0 = nullptr;
3119 ConstantInt *CInt = dyn_cast<ConstantInt>(I->getOperand(OpIdx));
3119 ConstantInt *CInt = dyn_cast<ConstantInt>(I->getOperand(OpIdx));
6632 if (auto *CI = dyn_cast<ConstantInt>(LastInsertElem->getOperand(2))) {
6632 if (auto *CI = dyn_cast<ConstantInt>(LastInsertElem->getOperand(2))) {
lib/Transforms/Vectorize/VPlan.cpp 378 auto *TCMO = Builder.CreateSub(TC, ConstantInt::get(TC->getType(), 1),
tools/bugpoint/CrashDebugger.cpp 590 BR->setCondition(ConstantInt::getTrue(BR->getContext()));
592 BR->setCondition(ConstantInt::getFalse(BR->getContext()));
tools/bugpoint/ExtractFunction.cpp 235 Constant *Elts[] = {ConstantInt::get(Int32Ty, TorList[i].second),
267 ConstantInt *CI = dyn_cast<ConstantInt>(CS->getOperand(0));
267 ConstantInt *CI = dyn_cast<ConstantInt>(CS->getOperand(0));
tools/clang/include/clang/CodeGen/ConstantInitBuilder.h 199 add(llvm::ConstantInt::get(intTy, value, isSigned));
239 llvm::ConstantInt::get(type, tag));
285 fillPlaceholder(position, llvm::ConstantInt::get(type, value, isSigned));
tools/clang/lib/CodeGen/Address.h 108 template <class U> inline U cast(CodeGen::Address addr) {
tools/clang/lib/CodeGen/CGAtomic.cpp 351 addr, llvm::ConstantInt::get(CGF.Int8Ty, 0),
415 if (llvm::ConstantInt *FO = dyn_cast<llvm::ConstantInt>(FailureOrderVal)) {
415 if (llvm::ConstantInt *FO = dyn_cast<llvm::ConstantInt>(FailureOrderVal)) {
516 if (llvm::ConstantInt *IsWeakC = dyn_cast<llvm::ConstantInt>(IsWeak)) {
516 if (llvm::ConstantInt *IsWeakC = dyn_cast<llvm::ConstantInt>(IsWeak)) {
679 if (auto SC = dyn_cast<llvm::ConstantInt>(Scope)) {
964 Args.add(RValue::get(llvm::ConstantInt::get(SizeTy, Size)),
1214 if (isa<llvm::ConstantInt>(Order)) {
1215 auto ord = cast<llvm::ConstantInt>(Order)->getZExtValue();
1437 RValue::get(llvm::ConstantInt::get(CGF.IntTy, (int)llvm::toCABI(AO))),
1636 llvm::ConstantInt::get(CGF.IntTy, (int)llvm::toCABI(Success))),
1639 llvm::ConstantInt::get(CGF.IntTy, (int)llvm::toCABI(Failure))),
1947 RValue::get(llvm::ConstantInt::get(IntTy, (int)llvm::toCABI(AO))),
tools/clang/lib/CodeGen/CGBlocks.cpp 1000 addHeaderField(llvm::ConstantInt::get(IntTy, flags.getBitMask()),
1002 addHeaderField(llvm::ConstantInt::get(IntTy, 0), getIntSize(),
1006 llvm::ConstantInt::get(IntTy, blockInfo.BlockSize.getQuantity()),
1009 llvm::ConstantInt::get(IntTy, blockInfo.BlockAlign.getQuantity()),
2108 dstAddr, srcValue, llvm::ConstantInt::get(Int32Ty, flags.getBitMask())
2281 llvm::Value *flagsVal = llvm::ConstantInt::get(CGF.Int32Ty, flags);
2904 storeHeaderField(llvm::ConstantInt::get(IntTy, flags.getBitMask()),
2908 V = llvm::ConstantInt::get(IntTy, byrefSize.getQuantity());
2929 llvm::ConstantInt::get(Int32Ty, flags.getBitMask())
tools/clang/lib/CodeGen/CGBuilder.h 60 llvm::ConstantInt *getSize(CharUnits N) {
61 return llvm::ConstantInt::get(TypeCache.SizeTy, N.getQuantity());
63 llvm::ConstantInt *getSize(uint64_t N) {
64 return llvm::ConstantInt::get(TypeCache.SizeTy, N);
tools/clang/lib/CodeGen/CGBuiltin.cpp 49 ConstantInt *Byte;
59 Byte = llvm::dyn_cast<llvm::ConstantInt>(
206 llvm::ConstantInt::get(IntType, -1));
303 ConstantInt::get(IntTy, 1),
305 return CGF.Builder.CreateAdd(Result, ConstantInt::get(IntTy, 1));
316 ConstantInt::get(IntTy, 1),
318 return CGF.Builder.CreateSub(Result, ConstantInt::get(IntTy, 1));
433 Value *ShiftCst = llvm::ConstantInt::get(IntTy, Width);
551 return ConstantInt::get(ResType, (Type & 2) ? 0 : -1, /*isSigned=*/true);
562 return ConstantInt::get(ResType, ObjectSize, /*isSigned=*/true);
761 BitPos, llvm::ConstantInt::get(BitPos->getType(), 3), "bittest.byteidx");
768 llvm::ConstantInt::get(CGF.Int8Ty, 0x7));
773 Mask = CGF.Builder.CreateShl(llvm::ConstantInt::get(CGF.Int8Ty, 1), PosLow,
817 ShiftedByte, llvm::ConstantInt::get(CGF.Int8Ty, 1), "bittest.res");
840 Arg1 = llvm::ConstantInt::get(CGF.IntTy, 0);
851 llvm::ConstantInt::get(CGF.Int32Ty, 0));
925 Value *ResOne = llvm::ConstantInt::get(ResultType, 1);
948 Value *ArgTypeLastIndex = llvm::ConstantInt::get(IndexType, ArgWidth - 1);
1107 llvm::ConstantInt::get(Builder.getInt8Ty(), Kind)},
1357 CGF.Builder.CreateAdd(llvm::ConstantInt::get(OpTy, IntMax),
1377 UnsignedResult, llvm::ConstantInt::get(OpTy, IntMax));
1540 return RValue::get(llvm::ConstantInt::get(getLLVMContext(),
1910 Value *Result = Builder.CreateSub(Ctlz, llvm::ConstantInt::get(ArgType, 1));
1961 llvm::ConstantInt::get(ArgType, 1));
1981 Value *Result = Builder.CreateAnd(Tmp, llvm::ConstantInt::get(ArgType, 1));
2049 ConstantInt *AlignmentCI = cast<ConstantInt>(AlignmentValue);
2049 ConstantInt *AlignmentCI = cast<ConstantInt>(AlignmentValue);
2051 AlignmentCI = ConstantInt::get(AlignmentCI->getType(),
2112 return RValue::get(ConstantInt::get(ResultType, 0));
2117 return RValue::get(ConstantInt::get(ResultType, 0));
2149 llvm::ConstantInt::get(Int32Ty, 0);
2151 llvm::ConstantInt::get(Int32Ty, 3);
2152 Value *Data = llvm::ConstantInt::get(Int32Ty, 1);
2261 Value *One = ConstantInt::get(IntTy, 1);
2262 Value *NegativeOne = ConstantInt::get(IntTy, -1);
2374 auto *AlignmentInBitsCI = cast<ConstantInt>(AlignmentInBitsValue);
2374 auto *AlignmentInBitsCI = cast<ConstantInt>(AlignmentInBitsValue);
2422 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
2448 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
2489 Value *SizeVal = llvm::ConstantInt::get(Builder.getContext(), Size);
2510 Value *SizeEq0 = Builder.CreateICmpEQ(Size, ConstantInt::get(SizeTy, 0));
2534 Value *NextSize = Builder.CreateSub(SizePhi, ConstantInt::get(SizeTy, 1));
2536 Builder.CreateICmpEQ(NextSize, ConstantInt::get(SizeTy, 0));
2544 Ret->addIncoming(ConstantInt::get(IntTy, 0), Entry);
2545 Ret->addIncoming(ConstantInt::get(IntTy, 1), CmpGT);
2546 Ret->addIncoming(ConstantInt::get(IntTy, -1), CmpLT);
2547 Ret->addIncoming(ConstantInt::get(IntTy, 0), Next);
2563 llvm::ConstantInt::get(Int32Ty, Offset)));
2599 return RValue::get(llvm::ConstantInt::get(Ty, Column, true));
2661 ConstantInt::get(Int32Ty, 0));
2904 if (isa<llvm::ConstantInt>(Order)) {
2905 int ord = cast<llvm::ConstantInt>(Order)->getZExtValue();
2987 if (isa<llvm::ConstantInt>(Order)) {
2988 int ord = cast<llvm::ConstantInt>(Order)->getZExtValue();
3045 if (isa<llvm::ConstantInt>(Order)) {
3046 int ord = cast<llvm::ConstantInt>(Order)->getZExtValue();
3380 return RValue::get(ConstantInt::get(IntTy, 0));
3800 auto *Zero = llvm::ConstantInt::get(IntTy, 0);
3800 auto *Zero = llvm::ConstantInt::get(IntTy, 0);
3802 auto *Index = llvm::ConstantInt::get(IntTy, I - First);
3802 auto *Index = llvm::ConstantInt::get(IntTy, I - First);
3830 Kernel, Block, ConstantInt::get(IntTy, NumArgs - 4),
3903 Args.push_back(ConstantInt::get(Int32Ty, NumArgs - 7));
4171 ArgValue = llvm::ConstantInt::get(getLLVMContext(), Result);
4357 int SV = cast<ConstantInt>(V)->getSExtValue();
4358 return ConstantInt::get(Ty, neg ? -SV : SV);
4367 int ShiftAmt = cast<ConstantInt>(Shift)->getSExtValue();
4382 Shift = ConstantInt::get(VTy->getElementType(), ShiftAmt);
5209 ConstantInt *C0 = ConstantInt::get(CGF.SizeTy, 0);
5209 ConstantInt *C0 = ConstantInt::get(CGF.SizeTy, 0);
5290 ConstantInt::get(SrcTy, SrcTy->getScalarSizeInBits() / 2);
5460 int CV = cast<ConstantInt>(Ops[2])->getSExtValue();
5526 llvm::Constant *CI = ConstantInt::get(SizeTy, 0);
5692 ConstantInt::get(SrcTy, SrcTy->getScalarSizeInBits() / 2);
5904 llvm::ConstantInt::get(Int32Ty, Value));
6046 Value *Locality = llvm::ConstantInt::get(Int32Ty, 3);
6106 Value *C1 = llvm::ConstantInt::get(Int64Ty, 32);
6141 Value *ShiftCast = llvm::ConstantInt::get(Int64Ty, 32);
6176 Value *ShiftCst = llvm::ConstantInt::get(Int64Ty, 32);
6289 Value *C1 = llvm::ConstantInt::get(Int64Ty, 32);
6424 Ops.push_back(llvm::ConstantInt::get(getLLVMContext(), Result));
6677 uint32_t Lane = cast<ConstantInt>(Ops[2])->getZExtValue();
6678 Value *SV = llvm::ConstantVector::get(ConstantInt::get(Int32Ty, 1-Lane));
6880 Ops.push_back(llvm::ConstantInt::get(Int32Ty, i));
6972 llvm::Constant *EightV = ConstantInt::get(Ty, 8);
6990 llvm::Constant *TwentyFourV = ConstantInt::get(Ty, 24);
7042 llvm::Constant *CI = ConstantInt::get(SizeTy, 0);
7080 return Builder.CreateCall(F, llvm::ConstantInt::get(Int32Ty, HintID));
7091 if (cast<llvm::ConstantInt>(RetentionPolicy)->isZero()) {
7093 Locality = llvm::ConstantInt::get(Int32Ty,
7094 -cast<llvm::ConstantInt>(CacheLevel)->getValue() + 3);
7097 Locality = llvm::ConstantInt::get(Int32Ty, 0);
7169 Value *ShiftCst = llvm::ConstantInt::get(Int128Ty, 64);
7476 Ops.push_back(llvm::ConstantInt::get(getLLVMContext(), Result));
7701 llvm::Value *Idx0 = llvm::ConstantInt::get(SizeTy, 0);
7702 llvm::Value *Idx1 = llvm::ConstantInt::get(SizeTy, 1);
7714 llvm::Value *Idx0 = llvm::ConstantInt::get(SizeTy, 0);
7715 llvm::Value *Idx1 = llvm::ConstantInt::get(SizeTy, 1);
7727 llvm::Value *Idx0 = llvm::ConstantInt::get(SizeTy, 0);
7728 llvm::Value *Idx1 = llvm::ConstantInt::get(SizeTy, 1);
8018 Constant *CI = ConstantInt::get(SizeTy, 0);
8047 int SV = cast<ConstantInt>(Ops[1])->getSExtValue();
8048 Ops[1] = ConstantInt::get(Int64Ty, -SV);
8064 llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
8064 llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
8066 Ops[0], ConstantInt::get(Int64Ty, Amt->getZExtValue()), "shld_n");
8069 llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
8069 llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
8071 Ops[0], ConstantInt::get(Int64Ty, std::min(static_cast<uint64_t>(63),
8076 llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
8076 llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
8080 return ConstantInt::get(Int64Ty, 0);
8081 return Builder.CreateLShr(Ops[0], ConstantInt::get(Int64Ty, ShiftAmt),
8085 llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(2)));
8085 llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(2)));
8087 Ops[1], ConstantInt::get(Int64Ty, std::min(static_cast<uint64_t>(63),
8093 llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(2)));
8093 llvm::ConstantInt *Amt = cast<ConstantInt>(EmitScalarExpr(E->getArg(2)));
8099 Ops[1] = Builder.CreateLShr(Ops[1], ConstantInt::get(Int64Ty, ShiftAmt),
8115 Constant *CI = ConstantInt::get(SizeTy, 0);
8394 cast<ConstantInt>(Ops[3]));
8405 Ops[2] = EmitNeonSplat(Ops[2], cast<ConstantInt>(Ops[3]));
9155 llvm::Constant *CI = ConstantInt::get(Int32Ty, 0);
9453 ConstantInt *C = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
9453 ConstantInt *C = cast<ConstantInt>(EmitScalarExpr(E->getArg(1)));
9454 Value *InfoKind = ConstantInt::get(Int64Ty, C->getSExtValue());
9620 uint64_t Imm = cast<llvm::ConstantInt>(Ops[2])->getZExtValue() & 0x7;
9747 unsigned Rnd = cast<llvm::ConstantInt>(Ops[3])->getZExtValue();
9834 cast<llvm::ConstantInt>(Ops.back())->getZExtValue() != (uint64_t)4) {
9894 Rnd = cast<llvm::ConstantInt>(Ops[4])->getZExtValue();
9940 Constant *ShiftAmt = ConstantInt::get(Ty, 32);
9947 Constant *Mask = ConstantInt::get(Ty, 0xffffffff);
10057 llvm::Value *Idxs[] = {ConstantInt::get(Int32Ty, 0),
10058 ConstantInt::get(Int32Ty, Index)};
10064 llvm::ConstantInt::get(Int32Ty, Value));
10185 Ops.push_back(llvm::ConstantInt::get(getLLVMContext(), Result));
10195 Ops.push_back(llvm::ConstantInt::get(Int8Ty, Imm));
10217 ConstantInt *C = cast<ConstantInt>(Ops[1]);
10217 ConstantInt *C = cast<ConstantInt>(Ops[1]);
10218 Value *RW = ConstantInt::get(Int32Ty, (C->getZExtValue() >> 2) & 0x1);
10219 Value *Locality = ConstantInt::get(Int32Ty, C->getZExtValue() & 0x3);
10220 Value *Data = ConstantInt::get(Int32Ty, 1);
10286 uint64_t Index = cast<ConstantInt>(Ops[1])->getZExtValue();
10301 unsigned Index = cast<ConstantInt>(Ops[2])->getZExtValue();
10361 Builder.CreateLShr(Ops[1], ConstantInt::get(Int64Ty, 32)), Int32Ty);
10866 unsigned Index = cast<ConstantInt>(Ops[1])->getZExtValue();
10904 unsigned Index = cast<ConstantInt>(Ops[2])->getZExtValue();
10967 unsigned Imm = cast<llvm::ConstantInt>(Ops[2])->getZExtValue();
10982 uint32_t Imm = cast<llvm::ConstantInt>(Ops[1])->getZExtValue();
11006 uint32_t Imm = cast<llvm::ConstantInt>(Ops[1])->getZExtValue();
11036 uint32_t Imm = cast<llvm::ConstantInt>(Ops[1])->getZExtValue();
11063 uint32_t Imm = cast<llvm::ConstantInt>(Ops[2])->getZExtValue();
11091 unsigned Imm = cast<llvm::ConstantInt>(Ops[1])->getZExtValue();
11108 unsigned ShiftVal = cast<llvm::ConstantInt>(Ops[2])->getZExtValue() & 0xff;
11148 unsigned ShiftVal = cast<llvm::ConstantInt>(Ops[2])->getZExtValue() & 0xff;
11169 unsigned Imm = cast<llvm::ConstantInt>(Ops[2])->getZExtValue();
11195 unsigned Imm = cast<llvm::ConstantInt>(Ops[2])->getZExtValue();
11233 unsigned ShiftVal = cast<llvm::ConstantInt>(Ops[1])->getZExtValue() & 0xff;
11263 unsigned ShiftVal = cast<llvm::ConstantInt>(Ops[1])->getZExtValue() & 0xff;
11294 unsigned ShiftVal = cast<llvm::ConstantInt>(Ops[1])->getZExtValue() & 0xff;
11316 unsigned ShiftVal = cast<llvm::ConstantInt>(Ops[1])->getZExtValue() & 0xff;
11432 unsigned CC = cast<llvm::ConstantInt>(Ops[2])->getZExtValue() & 0x7;
11447 unsigned CC = cast<llvm::ConstantInt>(Ops[2])->getZExtValue() & 0x7;
11639 unsigned CC = cast<llvm::ConstantInt>(Ops[4])->getZExtValue();
11662 unsigned CC = cast<llvm::ConstantInt>(Ops[1])->getZExtValue();
12050 unsigned CC = cast<llvm::ConstantInt>(Ops[2])->getZExtValue() & 0x1f;
12225 llvm::ConstantInt::get(Int128Ty, 0x3f));
12543 Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
12553 Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
12659 ConstantInt *ArgCI = dyn_cast<ConstantInt>(Ops[2]);
12659 ConstantInt *ArgCI = dyn_cast<ConstantInt>(Ops[2]);
12678 Constant *ShuffleElts[2] = { ConstantInt::get(Int32Ty, 1),
12679 ConstantInt::get(Int32Ty, 0)
12693 Ops[2] = ConstantInt::getSigned(Int32Ty, Index);
12705 ConstantInt *ArgCI = dyn_cast<ConstantInt>(Ops[1]);
12705 ConstantInt *ArgCI = dyn_cast<ConstantInt>(Ops[1]);
12714 Ops[1] = ConstantInt::getSigned(Int32Ty, Index);
12720 Constant *ShuffleElts[2] = { ConstantInt::get(Int32Ty, 1),
12721 ConstantInt::get(Int32Ty, 0)
12728 Ops[1] = ConstantInt::getSigned(Int32Ty, Index);
12734 ConstantInt *ArgCI = dyn_cast<ConstantInt>(Ops[2]);
12734 ConstantInt *ArgCI = dyn_cast<ConstantInt>(Ops[2]);
12747 Constant *ShuffleElts[2] = {ConstantInt::get(Int32Ty, ElemIdx0),
12748 ConstantInt::get(Int32Ty, ElemIdx1)};
12759 ConstantInt *ArgCI = dyn_cast<ConstantInt>(Ops[2]);
12759 ConstantInt *ArgCI = dyn_cast<ConstantInt>(Ops[2]);
12786 Constant *ShuffleElts[4] = {ConstantInt::get(Int32Ty, ElemIdx0),
12787 ConstantInt::get(Int32Ty, ElemIdx1),
12788 ConstantInt::get(Int32Ty, ElemIdx2),
12789 ConstantInt::get(Int32Ty, ElemIdx3)};
12811 ConstantInt *Index = cast<ConstantInt>(Ops[1]);
12811 ConstantInt *Index = cast<ConstantInt>(Ops[1]);
12816 Index = ConstantInt::get(Index->getType(), 1 - Index->getZExtValue());
13038 Value *Control = llvm::ConstantInt::get(Int32Ty, 0xff0c);
13044 Value *Control = llvm::ConstantInt::get(Int32Ty, 0xff0c);
13050 Value *Control = llvm::ConstantInt::get(Int32Ty, 0xff08);
13087 Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
13098 Value *Undef = ConstantInt::get(Builder.getInt1Ty(), false);
13207 Value *M4Value = llvm::ConstantInt::get(getLLVMContext(), M4);
13208 Value *M5Value = llvm::ConstantInt::get(getLLVMContext(), M5);
13238 Value *M4Value = llvm::ConstantInt::get(getLLVMContext(), M4);
13268 Value *M4Value = llvm::ConstantInt::get(getLLVMContext(), M4);
13624 {Ptr, ConstantInt::get(Builder.getInt32Ty(), Align.getQuantity())});
13933 llvm::ConstantInt::get(IntTy, i)),
13968 Builder.CreateGEP(Src.getPointer(), llvm::ConstantInt::get(IntTy, i)),
14028 llvm::ConstantInt::get(IntTy, i)),
14037 llvm::ConstantInt::get(IntTy, i)),
14047 llvm::ConstantInt::get(IntTy, i)),
14056 Builder.CreateGEP(Dst.getPointer(), llvm::ConstantInt::get(IntTy, i)),
14092 Value *Args[] = {llvm::ConstantInt::get(getLLVMContext(), SegConst),
14093 llvm::ConstantInt::get(getLLVMContext(), MemConst),
14103 Value *Arg = llvm::ConstantInt::get(getLLVMContext(), SegConst);
14233 Value *Lane = llvm::ConstantInt::get(getLLVMContext(), LaneConst);
14261 Value *Lane = llvm::ConstantInt::get(getLLVMContext(), LaneConst);
tools/clang/lib/CodeGen/CGCUDANV.cpp 84 llvm::Constant *Zeros[] = {llvm::ConstantInt::get(SizeTy, 0),
85 llvm::ConstantInt::get(SizeTy, 0)};
257 llvm::ConstantInt::get(SizeTy, std::max<size_t>(1, Args.size())));
359 llvm::ConstantInt::get(SizeTy, TyWidth.getQuantity()),
360 llvm::ConstantInt::get(SizeTy, Offset.getQuantity()),
363 llvm::Constant *Zero = llvm::ConstantInt::get(IntTy, 0);
428 llvm::ConstantInt::get(IntTy, -1),
456 llvm::ConstantInt::get(IntTy, (Flags & ExternDeviceVar) ? 1 : 0),
457 llvm::ConstantInt::get(IntTy, VarSize),
458 llvm::ConstantInt::get(IntTy, (Flags & ConstantDeviceVar) ? 1 : 0),
459 llvm::ConstantInt::get(IntTy, 0)};
tools/clang/lib/CodeGen/CGCXXABI.cpp 227 return llvm::ConstantInt::get(CGF.SizeTy, 0);
tools/clang/lib/CodeGen/CGCall.cpp 1260 llvm::ConstantInt::get(CGF.IntPtrTy, SrcSize),
1338 llvm::ConstantInt::get(CGF.IntPtrTy, DstSize),
2329 auto SizeVal = llvm::ConstantInt::get(IntPtrTy, Size.getQuantity());
2407 llvm::ConstantInt *AlignmentCI =
2408 cast<llvm::ConstantInt>(AlignmentValue);
3398 llvm::ConstantInt::get(Int32Ty, ArgNo + 1),
4570 llvm::ConstantInt *AlignmentCI = cast<llvm::ConstantInt>(Alignment);
4570 llvm::ConstantInt *AlignmentCI = cast<llvm::ConstantInt>(Alignment);
tools/clang/lib/CodeGen/CGClass.cpp 190 return llvm::ConstantInt::get(PtrDiffTy, Offset.getQuantity());
238 baseOffset = llvm::ConstantInt::get(CGF.PtrDiffTy,
1641 llvm::ConstantInt::get(CGF.SizeTy, PoisonSize)};
1711 llvm::ConstantInt *OffsetSizePtr = llvm::ConstantInt::get(
1711 llvm::ConstantInt *OffsetSizePtr = llvm::ConstantInt::get(
1926 llvm::ConstantInt *constantCount
1927 = dyn_cast<llvm::ConstantInt>(numElements);
2002 Builder.CreateInBoundsGEP(cur, llvm::ConstantInt::get(SizeTy, 1),
2763 llvm::ConstantInt::get(Int8Ty, TCK),
2818 {CastedVTable, llvm::ConstantInt::get(Int32Ty, VTableByteOffset),
tools/clang/lib/CodeGen/CGCleanup.cpp 1083 llvm::ConstantInt *Index = Builder.getInt32(Dest.getDestIndex());
tools/clang/lib/CodeGen/CGCleanup.h 256 SmallVector<std::pair<llvm::BasicBlock*,llvm::ConstantInt*>, 4>
372 void addBranchAfter(llvm::ConstantInt *Index,
389 llvm::ConstantInt *getBranchAfterIndex(unsigned I) const {
tools/clang/lib/CodeGen/CGDebugInfo.cpp 1358 C = llvm::ConstantInt::get(CGM.getLLVMContext(), Value->getInt());
1764 llvm::ConstantInt::get(CGM.getLLVMContext(), TA.getAsIntegral())));
1819 V = llvm::ConstantInt::get(CGM.Int8Ty, 0);
tools/clang/lib/CodeGen/CGDecl.cpp 734 llvm::ConstantInt::get(Int8Ty, 0), // The LogAlignment info is unused.
735 llvm::ConstantInt::get(Int8Ty, TCK_NonnullAssign)};
866 if (isa<llvm::ConstantInt>(Init) || isa<llvm::ConstantFP>(Init) ||
903 if (isa<llvm::ConstantInt>(Init) || isa<llvm::ConstantFP>(Init) ||
1156 auto *SizeVal = llvm::ConstantInt::get(CGM.IntPtrTy, ConstantSize);
1156 auto *SizeVal = llvm::ConstantInt::get(CGM.IntPtrTy, ConstantSize);
1161 Builder.CreateMemSet(Loc, llvm::ConstantInt::get(CGM.Int8Ty, 0), SizeVal,
1179 const llvm::APInt &AP = cast<llvm::ConstantInt>(Pattern)->getValue();
1183 Builder.CreateMemSet(Loc, llvm::ConstantInt::get(CGM.Int8Ty, Value), SizeVal,
1294 llvm::Value *SizeV = llvm::ConstantInt::get(Int64Ty, Size);
1323 if (auto *C = dyn_cast<llvm::ConstantInt>(VlaSize.NumElts))
1323 if (auto *C = dyn_cast<llvm::ConstantInt>(VlaSize.NumElts))
1350 if (auto *C = dyn_cast<llvm::ConstantInt>(VlaSize.NumElts))
1350 if (auto *C = dyn_cast<llvm::ConstantInt>(VlaSize.NumElts))
1699 Builder.CreateMemSet(Loc, llvm::ConstantInt::get(Int8Ty, 0), SizeVal,
1712 SizeVal, llvm::ConstantInt::get(SizeVal->getType(), 0),
1719 llvm::ConstantInt::get(IntPtrTy, EltSize.getQuantity());
2118 if (llvm::ConstantInt *constLength = dyn_cast<llvm::ConstantInt>(length)) {
2118 if (llvm::ConstantInt *constLength = dyn_cast<llvm::ConstantInt>(length)) {
2168 llvm::Value *negativeOne = llvm::ConstantInt::get(SizeTy, -1, true);
2207 llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0);
tools/clang/lib/CodeGen/CGDeclCXX.cpp 167 llvm::Value *Args[2] = { llvm::ConstantInt::getSigned(Int64Ty, Width),
694 Builder.CreateStore(llvm::ConstantInt::get(GuardVal->getType(),1), Guard);
tools/clang/lib/CodeGen/CGException.cpp 1638 llvm::ConstantInt::get(CGF.ConvertType(ArgTys[0]), F.isForEHCleanup());
1729 llvm::ConstantInt::get(Int32Ty, FrameEscapeIdx)});
tools/clang/lib/CodeGen/CGExpr.cpp 617 return cast<llvm::ConstantInt>(Elts->getAggregateElement(Idx))
682 llvm::Value *True = llvm::ConstantInt::getTrue(getLLVMContext());
715 llvm::Value *Size = llvm::ConstantInt::get(IntPtrTy, TySize);
752 PtrAsInt, llvm::ConstantInt::get(IntPtrTy, AlignVal - 1));
754 Builder.CreateICmpEQ(Align, llvm::ConstantInt::get(IntPtrTy, 0));
766 llvm::ConstantInt::get(Int8Ty, AlignVal ? llvm::Log2_64(AlignVal) : 1),
767 llvm::ConstantInt::get(Int8Ty, TCK)};
810 llvm::Value *Low = llvm::ConstantInt::get(Int64Ty, TypeHash);
825 llvm::ConstantInt::get(IntPtrTy,
841 llvm::ConstantInt::get(Int8Ty, TCK)
921 llvm::ConstantInt::get(SizeInBytes->getType(), EltSize);
995 NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true);
1617 Check = Builder.CreateICmpULE(Value, llvm::ConstantInt::get(Ctx, End));
1620 Builder.CreateICmpSLE(Value, llvm::ConstantInt::get(Ctx, End));
1622 Builder.CreateICmpSGE(Value, llvm::ConstantInt::get(Ctx, Min));
1863 llvm::Value *Elt = llvm::ConstantInt::get(SizeTy, InIdx);
2153 llvm::Value *Elt = llvm::ConstantInt::get(SizeTy, InIdx);
3116 SanitizerMask Kind, llvm::Value *Cond, llvm::ConstantInt *TypeId,
3257 Builder.CreateICmpNE(CheckKind, llvm::ConstantInt::get(Int8Ty, Kind));
3386 if (auto constantIdx = dyn_cast<llvm::ConstantInt>(idx)) {
3430 auto LastIndex = dyn_cast<llvm::ConstantInt>(indices.back());
3542 llvm::ConstantInt::get(Idx->getType(), InterfaceSize.getQuantity());
3664 Idx = llvm::ConstantInt::getNullValue(IntPtrTy);
3695 : llvm::ConstantInt::get(IntPtrTy, ConstLowerBound);
3701 : llvm::ConstantInt::get(IntPtrTy, ConstLength);
3707 Idx, llvm::ConstantInt::get(IntPtrTy, /*V=*/1), "idx_sub_1",
3711 Idx = llvm::ConstantInt::get(IntPtrTy, ConstLength + ConstLowerBound);
3730 LengthVal, llvm::ConstantInt::get(IntPtrTy, /*V=*/1), "len_sub_1",
3735 Idx = llvm::ConstantInt::get(IntPtrTy, ConstLength);
4862 llvm::ConstantInt::get(Int8Ty, CFITCK_ICall),
tools/clang/lib/CodeGen/CGExprAgg.cpp 363 llvm::Value *size = llvm::ConstantInt::get(CGF.SizeTy, sz.getQuantity());
414 llvm::Value *Zero = llvm::ConstantInt::get(CGF.PtrDiffTy, 0);
481 llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0);
538 llvm::Value *one = llvm::ConstantInt::get(CGF.SizeTy, 1);
586 llvm::ConstantInt::get(CGF.SizeTy, NumArrayElements),
729 llvm::Value *SizeVal = llvm::ConstantInt::get(
1649 llvm::Value *zero = llvm::ConstantInt::get(CGF.SizeTy, 0);
1714 index, llvm::ConstantInt::get(CGF.SizeTy, 1), "arrayinit.next");
1719 nextIndex, llvm::ConstantInt::get(CGF.SizeTy, numElements),
1969 llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity()));
1973 SizeVal = llvm::ConstantInt::get(SizeTy, TypeInfo.first.getQuantity());
tools/clang/lib/CodeGen/CGExprCXX.cpp 683 = llvm::ConstantInt::get(CGF.SizeTy, typeSize.getQuantity());
732 if (llvm::ConstantInt *numElementsC =
733 dyn_cast<llvm::ConstantInt>(numElements)) {
760 numElements = llvm::ConstantInt::get(CGF.SizeTy,
773 sizeWithoutCookie = llvm::ConstantInt::get(CGF.SizeTy, allocationSize);
783 size = llvm::ConstantInt::get(CGF.SizeTy, allocationSize);
811 = llvm::ConstantInt::get(numElementsType, threshold);
828 llvm::ConstantInt::get(CGF.SizeTy, minElements));
841 llvm::ConstantInt::get(CGF.SizeTy, minElements));
848 llvm::ConstantInt::get(CGF.SizeTy, minElements)));
866 llvm::ConstantInt::get(CGF.SizeTy, typeSizeMultiplier);
889 llvm::ConstantInt::get(CGF.SizeTy, arraySizeMultiplier);
905 llvm::Value *cookieSizeV = llvm::ConstantInt::get(CGF.SizeTy, cookieSize);
1000 auto *InitializedSize = llvm::ConstantInt::get(
1042 llvm::ConstantInt *ConstNum = dyn_cast<llvm::ConstantInt>(NumElements);
1042 llvm::ConstantInt *ConstNum = dyn_cast<llvm::ConstantInt>(NumElements);
1120 llvm::ConstantInt *ConstNum = dyn_cast<llvm::ConstantInt>(NumElements);
1120 llvm::ConstantInt *ConstNum = dyn_cast<llvm::ConstantInt>(NumElements);
1155 llvm::ConstantInt::get(NumElements->getType(), InitListElements));
1448 DeleteArgs.add(RValue::get(llvm::ConstantInt::get(
1615 RValue::get(llvm::ConstantInt::get(SizeTy, allocAlign.getQuantity())),
1783 llvm::Value *Size = llvm::ConstantInt::get(ConvertType(SizeType),
1793 Size, llvm::ConstantInt::get(SizeTy, CookieSize.getQuantity()));
1803 llvm::Value *Align = llvm::ConstantInt::get(ConvertType(AlignValType),
tools/clang/lib/CodeGen/CGExprConstant.cpp 218 add(llvm::ConstantInt::get(CGM.getLLVMContext(), BitsThisChar),
247 add(llvm::ConstantInt::get(CGM.getLLVMContext(), BitsThisChar),
253 auto *CI = dyn_cast<llvm::ConstantInt>(ToUpdate);
253 auto *CI = dyn_cast<llvm::ConstantInt>(ToUpdate);
262 ToUpdate = llvm::ConstantInt::get(CGM.getLLVMContext(), BitsThisChar);
564 llvm::ConstantInt *InitExpr, bool AllowOverwrite = false);
589 const FieldDecl *Field, uint64_t FieldOffset, llvm::ConstantInt *CI,
731 if (auto *CI = dyn_cast<llvm::ConstantInt>(EltInit)) {
731 if (auto *CI = dyn_cast<llvm::ConstantInt>(EltInit)) {
833 cast<llvm::ConstantInt>(EltInit), AllowOverwrite))
1550 IndexValues[i] = llvm::ConstantInt::get(CGM.Int32Ty, Indices[i]);
1781 return llvm::ConstantInt::get(CGM.Int64Ty,
2021 return llvm::ConstantInt::get(CGM.getLLVMContext(), Value.getInt());
2023 return llvm::ConstantInt::get(CGM.getLLVMContext(),
2028 Complex[0] = llvm::ConstantInt::get(CGM.getLLVMContext(),
2030 Complex[1] = llvm::ConstantInt::get(CGM.getLLVMContext(),
2043 return llvm::ConstantInt::get(CGM.getLLVMContext(),
2068 Inits[I] = llvm::ConstantInt::get(CGM.getLLVMContext(), Elt.getInt());
tools/clang/lib/CodeGen/CGExprScalar.cpp 55 bool mayHaveIntegerOverflow(llvm::ConstantInt *LHS, llvm::ConstantInt *RHS,
55 bool mayHaveIntegerOverflow(llvm::ConstantInt *LHS, llvm::ConstantInt *RHS,
97 auto *LHSCI = dyn_cast<llvm::ConstantInt>(LHS);
97 auto *LHSCI = dyn_cast<llvm::ConstantInt>(LHS);
98 auto *RHSCI = dyn_cast<llvm::ConstantInt>(RHS);
98 auto *RHSCI = dyn_cast<llvm::ConstantInt>(RHS);
116 if (auto *CI = dyn_cast<llvm::ConstantInt>(RHS))
116 if (auto *CI = dyn_cast<llvm::ConstantInt>(RHS))
296 llvm::ConstantInt *AlignmentCI = cast<llvm::ConstantInt>(AlignmentValue);
296 llvm::ConstantInt *AlignmentCI = cast<llvm::ConstantInt>(AlignmentValue);
465 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
468 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
471 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
487 return llvm::ConstantInt::get(ConvertType(E->getType()),E->getPackLength());
538 return llvm::ConstantInt::get(Builder.getInt1Ty(), 1);
542 llvm::ConstantInt::get(CGF.CGM.Int32Ty, Version.getMajor()),
543 llvm::ConstantInt::get(CGF.CGM.Int32Ty, Min ? *Min : 0),
544 llvm::ConstantInt::get(CGF.CGM.Int32Ty, SMin ? *SMin : 0),
673 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
681 return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue());
685 return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue());
1022 llvm::ConstantInt::get(Builder.getInt8Ty(), Check.first)};
1060 return llvm::ConstantInt::getFalse(VTy->getContext());
1063 llvm::Constant *Zero = llvm::ConstantInt::get(VTy, 0);
1162 llvm::ConstantInt::get(Builder.getInt8Ty(), CheckKind)};
1446 Value *LowBits = ConstantInt::get(
1477 Value *Max = ConstantInt::get(
1487 Value *Min = ConstantInt::get(
1606 llvm::ConstantInt::get(MTy, llvm::NextPowerOf2(LHSElts - 1) - 1);
1619 Value *IIndx = llvm::ConstantInt::get(CGF.SizeTy, i);
1762 return llvm::ConstantInt::get(I32Ty, Off+MV);
1765 static llvm::Constant *getAsInt32(llvm::ConstantInt *C, llvm::Type *I32Ty) {
1770 return llvm::ConstantInt::get(I32Ty, C->getZExtValue());
1821 llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand());
1821 llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand());
2321 BinOp.RHS = llvm::ConstantInt::get(InVal->getType(), 1, false);
2332 llvm::ConstantInt::get(InVal->getType(), IsInc ? 1 : -1, true);
2389 llvm::ConstantInt::get(ConvertType(type), 1, true), type);
2431 llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount, true);
2478 llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount);
2548 llvm::ConstantInt::get(CGF.SizeTy, size.getQuantity());
2664 llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType,
2691 Offset = llvm::ConstantInt::get(ResultType, OffsetInt);
2717 Offset = llvm::ConstantInt::get(ResultType, OffsetInt.getQuantity());
2760 return llvm::ConstantInt::get(CGF.SizeTy, Alignment);
2980 llvm::Value *NegOne = llvm::ConstantInt::get(Ty, -1ULL);
3587 return llvm::ConstantInt::get(RHS->getType(), Ty->getBitWidth() - 1);
3639 llvm::Value *One = llvm::ConstantInt::get(BitsShiftedOff->getType(), 1);
3642 llvm::Value *Zero = llvm::ConstantInt::get(BitsShiftedOff->getType(), 0);
4016 PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI);
4081 return llvm::ConstantInt::get(ResTy, 1);
4101 PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI);
4585 auto *Zero = llvm::ConstantInt::getNullValue(IntPtrTy);
4600 if (auto *LHSCI = dyn_cast<llvm::ConstantInt>(LHS)) {
4600 if (auto *LHSCI = dyn_cast<llvm::ConstantInt>(LHS)) {
4601 if (auto *RHSCI = dyn_cast<llvm::ConstantInt>(RHS)) {
4601 if (auto *RHSCI = dyn_cast<llvm::ConstantInt>(RHS)) {
4607 return llvm::ConstantInt::get(VMContext, N);
4628 unsigned FieldNo = cast<llvm::ConstantInt>(Index)->getZExtValue();
4629 LocalOffset = llvm::ConstantInt::get(
4634 auto *ElementSize = llvm::ConstantInt::get(
4687 auto *Zero = llvm::ConstantInt::getNullValue(IntPtrTy);
tools/clang/lib/CodeGen/CGGPUBuiltin.cpp 89 return RValue::get(llvm::ConstantInt::get(IntTy, 0));
tools/clang/lib/CodeGen/CGLoopInfo.cpp 51 ConstantAsMetadata::get(ConstantInt::get(
66 ConstantAsMetadata::get(ConstantInt::get(
121 ConstantAsMetadata::get(ConstantInt::get(
185 ConstantAsMetadata::get(ConstantInt::get(llvm::Type::getInt32Ty(Ctx),
231 ConstantAsMetadata::get(ConstantInt::get(
266 ConstantAsMetadata::get(ConstantInt::get(llvm::Type::getInt1Ty(Ctx),
275 ConstantAsMetadata::get(ConstantInt::get(llvm::Type::getInt32Ty(Ctx),
284 ConstantAsMetadata::get(ConstantInt::get(llvm::Type::getInt32Ty(Ctx),
294 ConstantAsMetadata::get(ConstantInt::get(
331 ConstantAsMetadata::get(ConstantInt::get(
349 ConstantAsMetadata::get(ConstantInt::get(
tools/clang/lib/CodeGen/CGNonTrivialStruct.cpp 352 llvm::ConstantInt::get(NumElts->getType(), BaseEltSize);
522 llvm::ConstantInt::get(this->CGF->SizeTy, Size.getQuantity());
tools/clang/lib/CodeGen/CGObjC.cpp 210 llvm::ConstantInt::get(CGM.getTypes().ConvertType(ArgQT), NumElements);
1700 llvm::Constant *Count = llvm::ConstantInt::get(NSUIntegerTy, NumItems);
1862 Builder.CreateAdd(index, llvm::ConstantInt::get(NSUIntegerTy, 1));
tools/clang/lib/CodeGen/CGObjCGNU.cpp 995 llvm::ConstantInt::get(Int64Ty, str), IdTy);
1390 llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
1626 auto i32Zero = llvm::ConstantInt::get(Int32Ty, 0);
1836 llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset);
2145 Zeros[0] = llvm::ConstantInt::get(LongTy, 0);
2430 llvm::Constant *Two = llvm::ConstantInt::get(IntTy, 2);
2599 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
2675 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
3054 llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
3123 llvm::ConstantInt::get(Int32Ty, ProtocolVersion), IdTy));
3193 return llvm::ConstantInt::get(IntPtrTy, val);
3203 values.push_back(llvm::ConstantInt::get(Int32Ty, word));
3395 symbol->setInitializer(llvm::ConstantInt::get(LongTy, 0));
3399 llvm::ConstantInt::get(LongTy, 0),
3435 IvarAligns.push_back(llvm::ConstantInt::get(IntTy,
3443 llvm::Constant *OffsetValue = llvm::ConstantInt::get(IntTy, Offset);
3541 llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 2 : 1), nullptr,
3542 llvm::ConstantInt::get(IndexTy, ClassABIVersion > 1 ? 3 : 2) };
3548 offsetPointerIndexes[2] = llvm::ConstantInt::get(IndexTy, ivarIndex);
3567 llvm::Constant *ZeroPtr = llvm::ConstantInt::get(IntPtrTy, 0);
3580 llvm::ConstantInt::get(LongTy, instanceSize), IvarList, MethodList,
3709 llvm::ConstantInt::get(Int32Ty, i)
4099 return llvm::ConstantInt::get(PtrDiffTy, Offset, /*isSigned*/true);
tools/clang/lib/CodeGen/CGObjCMac.cpp 1831 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1832 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
2807 return llvm::ConstantInt::get(CGM.IntPtrTy, Result);
2977 if (isa<llvm::ConstantInt>(Result))
4514 llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Builder.getInt32Ty(), 0);
4912 return llvm::ConstantInt::get(
5003 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
6760 llvm::ConstantInt::get(ObjCTypes.IvarOffsetVarTy, Offset));
7067 IvarOffsetValue = llvm::ConstantInt::get(
7298 auto *Idx = llvm::ConstantInt::get(CGM.Int32Ty, 1);
7298 auto *Idx = llvm::ConstantInt::get(CGM.Int32Ty, 1);
7721 llvm::Value *VTableIdx = llvm::ConstantInt::get(CGM.Int32Ty, 2);
tools/clang/lib/CodeGen/CGOpenCLRuntime.cpp 105 return llvm::ConstantInt::get(Int32Ty, TypeSize, false);
115 return llvm::ConstantInt::get(Int32Ty, TypeSize, false);
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 1017 Size, llvm::ConstantInt::get(Size->getType(), /*V=*/1));
1585 llvm::ConstantInt::getNullValue(CGM.Int32Ty),
1586 llvm::ConstantInt::get(CGM.Int32Ty, Flags),
1587 llvm::ConstantInt::get(CGM.Int32Ty, Reserved2Flags),
1588 llvm::ConstantInt::getNullValue(CGM.Int32Ty), DefaultOpenMPPSource};
3250 llvm::ConstantInt::get(CGM.IntTy, /*V=*/0, /*isSigned=*/true)};
3840 llvm::ConstantInt::get(CGM.IntTy, RuntimeProcBind, /*isSigned=*/true)};
4034 llvm::ConstantInt::get(CGM.SizeTy, Size),
4035 llvm::ConstantInt::get(CGM.Int32Ty, Flags),
4036 llvm::ConstantInt::get(CGM.Int32Ty, 0)};
4073 llvm::ConstantInt::get(CGM.Int32Ty, V));
4258 return cast<llvm::ConstantInt>(V->getValue())->getZExtValue();
5279 CGF.EmitStoreOfScalar(llvm::ConstantInt::get(LLVMFlagsTy, DepKind),
5398 IfVal = llvm::ConstantInt::getSigned(CGF.IntTy, /*V=*/1);
5441 llvm::ConstantInt::getSigned(
5443 llvm::ConstantInt::getSigned(
5450 : llvm::ConstantInt::get(CGF.Int64Ty, /*V=*/0),
6223 llvm::Value *Idxs[] = {llvm::ConstantInt::get(CGM.SizeTy, /*V=*/0),
6224 llvm::ConstantInt::get(CGM.SizeTy, Cnt)};
6274 llvm::ConstantInt::get(CGM.Int32Ty, /*V=*/1, /*isSigned=*/true),
6284 llvm::ConstantInt::get(CGM.IntTy, Size, /*isSigned=*/true),
7225 Cmp, TrueVal, llvm::ConstantInt::get(CGF.SizeTy, 0));
8216 Sizes.push_back(llvm::ConstantInt::get(CGF.Int64Ty, 0));
9889 llvm::ConstantInt::get(CGM.Int64Ty, Flags));
10852 CGF.EmitStoreOfScalar(llvm::ConstantInt::getSigned(CGM.Int64Ty, /*V=*/1),
10861 llvm::ConstantInt::getSigned(CGM.Int32Ty, NumIterations.size()),
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 1386 llvm::ConstantInt::get(CGM.Int8Ty, Mode ? 0 : 1),
1851 llvm::ConstantInt::get(llvm::Type::getInt32Ty(Ctx), 1))};
2164 llvm::Value *Size = llvm::ConstantInt::get(CGM.SizeTy, GlobalRecordSize);
2180 IsTTD, llvm::ConstantInt::get(CGM.SizeTy, GlobalRecordSize), Size);
2246 llvm::ConstantInt::get(
2274 llvm::ConstantInt::get(CGM.SizeTy, GlobalRecordSize),
2366 Size, llvm::ConstantInt::get(CGF.SizeTy, Align.getQuantity() - 1));
2368 llvm::ConstantInt::get(CGF.SizeTy, Align.getQuantity());
2437 llvm::ConstantInt::get(
2555 llvm::ConstantInt::get(CGM.SizeTy, CapturedVars.size())};
2721 llvm::ConstantInt::get(CGF.Int32Ty, /*V=*/0, /*isSigned=*/true)};
3135 ScratchpadBasePtr, llvm::ConstantInt::get(CGM.SizeTy, 1));
3138 llvm::ConstantInt::get(CGM.SizeTy, GlobalMemoryAlignment));
3140 ScratchpadBasePtr, llvm::ConstantInt::get(CGM.SizeTy, 1));
3143 llvm::ConstantInt::get(CGM.SizeTy, GlobalMemoryAlignment));
3271 Bld.CreateICmpULT(Cnt, llvm::ConstantInt::get(CGM.IntTy, NumIters));
3378 Cnt = Bld.CreateNSWAdd(Cnt, llvm::ConstantInt::get(CGM.IntTy, /*V=*/1));
3669 llvm::Value *Idxs[] = {llvm::ConstantInt::getNullValue(CGF.Int32Ty),
3774 llvm::Value *Idxs[] = {llvm::ConstantInt::getNullValue(CGF.Int32Ty),
3870 llvm::Value *Idxs[] = {llvm::ConstantInt::getNullValue(CGF.Int32Ty),
3974 llvm::Value *Idxs[] = {llvm::ConstantInt::getNullValue(CGF.Int32Ty),
4405 Res, llvm::ConstantInt::get(CGM.Int32Ty, /*V=*/1));
5101 Records.RecSize->setInitializer(llvm::ConstantInt::get(CGM.SizeTy, Size));
5103 llvm::ConstantInt::get(CGM.Int16Ty, UseSharedMemory ? 1 : 0));
tools/clang/lib/CodeGen/CGStmt.cpp 748 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
748 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
836 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
836 if (llvm::ConstantInt *C = dyn_cast<llvm::ConstantInt>(BoolCondVal))
1269 llvm::ConstantInt *CaseVal =
1317 llvm::ConstantInt *CaseVal =
1862 return llvm::ConstantInt::get(getLLVMContext(), IntResult);
1867 return llvm::ConstantInt::get(getLLVMContext(), Result.Val.getInt());
1889 Locs.push_back(llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
1905 llvm::ConstantInt::get(CGF.Int32Ty, LineLoc.getRawEncoding())));
1936 llvm::Constant *Loc = llvm::ConstantInt::get(CGF.Int32Ty,
tools/clang/lib/CodeGen/CGStmtOpenMP.cpp 279 return llvm::ConstantInt::get(SizeTy, /*V=*/0);
1524 auto *AlignmentCI =
1525 cast<llvm::ConstantInt>(CGF.EmitScalarExpr(AlignmentExpr));
1546 llvm::ConstantInt::get(CGF.getLLVMContext(), Alignment));
1683 auto *Val = cast<llvm::ConstantInt>(Len.getScalarVal());
1683 auto *Val = cast<llvm::ConstantInt>(Len.getScalarVal());
1693 auto *Val = cast<llvm::ConstantInt>(Len.getScalarVal());
1693 auto *Val = cast<llvm::ConstantInt>(Len.getScalarVal());
2619 llvm::ConstantInt *GlobalUBVal = CS != nullptr
3758 !X.isSimple() || (!isa<llvm::ConstantInt>(Update.getScalarVal()) &&
3831 if (auto *IC = dyn_cast<llvm::ConstantInt>(UpdateVal)) {
3831 if (auto *IC = dyn_cast<llvm::ConstantInt>(UpdateVal)) {
tools/clang/lib/CodeGen/CGVTT.cpp 77 llvm::ConstantInt::get(Int32Ty, 0),
78 llvm::ConstantInt::get(Int32Ty, AddressPoint.VTableIndex),
79 llvm::ConstantInt::get(Int32Ty, AddressPoint.AddressPointIndex),
tools/clang/lib/CodeGen/CGVTables.cpp 625 llvm::ConstantInt::get(CGM.PtrDiffTy, offset.getQuantity()),
tools/clang/lib/CodeGen/CodeGenFunction.cpp 555 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
811 llvm::ConstantInt::getTrue(getLLVMContext());
1581 = llvm::ConstantInt::get(CGF.IntPtrTy, baseSize.getQuantity());
1754 llvm::ConstantInt *zero = Builder.getInt32(0);
1801 = llvm::ConstantInt::get(SizeTy, countFromCLAs);
tools/clang/lib/CodeGen/CodeGenFunction.h 4118 llvm::ConstantInt *TypeId, llvm::Value *Ptr,
tools/clang/lib/CodeGen/CodeGenModule.cpp 500 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
574 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
576 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
636 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
638 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
752 llvm::ConstantInt *CodeGenModule::getSize(CharUnits size) {
753 return llvm::ConstantInt::get(SizeTy, size.getQuantity());
1209 llvm::ConstantInt *CodeGenModule::CreateCrossDsoCfiTypeId(llvm::Metadata *MD) {
1213 return llvm::ConstantInt::get(Int64Ty, llvm::MD5Hash(MDS->getString()));
2202 return llvm::ConstantInt::get(Int32Ty, LineNo);
5557 return llvm::ConstantInt::get(i64, PtrInt);
5717 Field3[Idx] = llvm::ConstantInt::get(
5721 llvm::ConstantInt::get(Int32Ty, Uuid.substr(0, 8), 16),
5722 llvm::ConstantInt::get(Int16Ty, Uuid.substr(9, 4), 16),
5723 llvm::ConstantInt::get(Int16Ty, Uuid.substr(14, 4), 16),
tools/clang/lib/CodeGen/CodeGenModule.h 764 llvm::ConstantInt *getSize(CharUnits numChars);
1307 llvm::ConstantInt *CreateCrossDsoCfiTypeId(llvm::Metadata *MD);
tools/clang/lib/CodeGen/ConstantInitBuilder.cpp 171 indices.push_back(llvm::ConstantInt::get(Builder.CGM.Int32Ty, 0));
177 indices.push_back(llvm::ConstantInt::get(Builder.CGM.Int32Ty,
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp 589 llvm::Constant *ptrdiff_1 = llvm::ConstantInt::get(CGM.PtrDiffTy, 1);
680 {VFPAddr, llvm::ConstantInt::get(CGM.Int32Ty, 0), TypeId});
707 llvm::ConstantInt::get(CGF.Int8Ty, CodeGenFunction::CFITCK_VMFCall),
744 llvm::ConstantInt::get(CGF.Int8Ty, CodeGenFunction::CFITCK_NVMFCall),
871 uint64_t offset = cast<llvm::ConstantInt>(adj)->getZExtValue();
873 adj = llvm::ConstantInt::get(adj->getType(), offset);
919 uint64_t offset = cast<llvm::ConstantInt>(adj)->getZExtValue();
921 adj = llvm::ConstantInt::get(adj->getType(), offset);
939 return llvm::ConstantInt::get(CGM.PtrDiffTy, -1ULL, /*isSigned=*/true);
941 llvm::Constant *Zero = llvm::ConstantInt::get(CGM.PtrDiffTy, 0);
952 return llvm::ConstantInt::get(CGM.PtrDiffTy, offset.getQuantity());
983 MemPtr[0] = llvm::ConstantInt::get(CGM.PtrDiffTy, VTableOffset);
984 MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
991 MemPtr[0] = llvm::ConstantInt::get(CGM.PtrDiffTy, VTableOffset + 1);
992 MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
1010 MemPtr[1] = llvm::ConstantInt::get(CGM.PtrDiffTy,
1096 llvm::Value *One = llvm::ConstantInt::get(LPtr->getType(), 1);
1130 llvm::Constant *Zero = llvm::ConstantInt::get(Ptr->getType(), 0);
1136 llvm::Constant *One = llvm::ConstantInt::get(Ptr->getType(), 1);
1253 AllocExceptionFn, llvm::ConstantInt::get(SizeTy, TypeSize), "exception");
1413 llvm::Value *OffsetHint = llvm::ConstantInt::get(
1706 llvm::ConstantInt::get(CGM.Int32Ty, 0),
1707 llvm::ConstantInt::get(CGM.Int32Ty, AddressPoint.VTableIndex),
1708 llvm::ConstantInt::get(CGM.Int32Ty, AddressPoint.AddressPointIndex),
2090 llvm::Value *elementSize = llvm::ConstantInt::get(CGF.SizeTy,
2226 llvm::ConstantInt::get(guardTy, 0),
2308 ? Builder.CreateAnd(LI, llvm::ConstantInt::get(CGM.Int8Ty, 1))
2349 Builder.CreateStore(llvm::ConstantInt::get(guardTy, 1), guardAddr);
2581 llvm::ConstantInt::get(CGM.Int8Ty, 0), "__tls_guard");
3266 llvm::Constant *Two = llvm::ConstantInt::get(PtrDiffTy, 2);
3397 llvm::ConstantInt::get(CGM.Int64Ty, ((uint64_t)1) << 63);
3657 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3662 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, RD->getNumBases()));
3728 Fields.push_back(llvm::ConstantInt::get(OffsetFlagsLTy, OffsetFlags));
3771 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
3798 Fields.push_back(llvm::ConstantInt::get(UnsignedIntLTy, Flags));
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp 332 Map[0] = llvm::ConstantInt::get(CGM.IntTy, 0);
341 Map[SrcVBIndex] = llvm::ConstantInt::get(CGM.IntTy, DstVBIndex * 4);
557 return llvm::ConstantInt::get(CGM.IntTy, 0);
585 llvm::Value *VBPOffset = llvm::ConstantInt::get(CGM.IntTy, VBPtrOffset),
586 *VBTOffset = llvm::ConstantInt::get(CGM.IntTy, VBTableOffset);
902 return std::make_tuple(Value, llvm::ConstantInt::get(CGF.Int32Ty, 0),
995 llvm::ConstantInt::get(CGF.Int32Ty, DestTy->isReferenceType())};
1027 llvm::Value *VBPtrOffset = llvm::ConstantInt::get(CGM.PtrDiffTy, VBPtrChars);
1033 llvm::ConstantInt::get(CGM.IntTy, VBTableChars.getQuantity());
1190 VBaseOffset, llvm::ConstantInt::get(CGM.PtrDiffTy, ConstantVBaseOffset),
1559 MostDerivedArg = llvm::ConstantInt::get(CGM.Int32Ty, Type == Ctor_Complete);
1822 llvm::Value *GEPIndices[] = {llvm::ConstantInt::get(CGM.Int32Ty, 0),
1823 llvm::ConstantInt::get(CGM.Int32Ty, 0),
1824 llvm::ConstantInt::get(CGM.Int32Ty, 1)};
1921 llvm::Value *ImplicitParam = llvm::ConstantInt::get(
2094 Offsets[0] = llvm::ConstantInt::get(CGM.IntTy, -VBPtrOffset.getQuantity());
2111 Offsets[VBIndex] = llvm::ConstantInt::get(CGM.IntTy, Offset.getQuantity());
2410 llvm::ConstantInt *Mask =
2411 llvm::ConstantInt::get(CGF.IntTy, ~(1ULL << GuardNum));
2450 llvm::ConstantInt *Zero = llvm::ConstantInt::get(GuardTy, 0);
2450 llvm::ConstantInt *Zero = llvm::ConstantInt::get(GuardTy, 0);
2524 llvm::ConstantInt *Bit = llvm::ConstantInt::get(GuardTy, 1ULL << GuardNum);
2524 llvm::ConstantInt *Bit = llvm::ConstantInt::get(GuardTy, 1ULL << GuardNum);
2685 fields.push_back(llvm::ConstantInt::get(
2692 fields.push_back(llvm::ConstantInt::get(CGM.IntTy, Offs.getQuantity()));
2697 fields.push_back(llvm::ConstantInt::get(CGM.IntTy, VBTableIndex));
2710 llvm::ConstantInt::get(CGM.IntTy, offset.getQuantity());
2954 if (auto CI = dyn_cast<llvm::ConstantInt>(VBPtrOffset)) {
2965 VBTableOffset, llvm::ConstantInt::get(VBTableOffset->getType(), 2),
3014 VBPtrOffset = llvm::ConstantInt::get(CGM.IntTy, offs.getQuantity());
3192 llvm::ConstantInt::get(CGM.IntTy, SrcOffsetToFirstVBase),
3205 llvm::Constant *BaseClassOffset = llvm::ConstantInt::get(
3226 VirtualBaseAdjustmentOffset, llvm::ConstantInt::get(CGM.IntTy, 4));
3246 llvm::Value *DstVBPtrOffset = llvm::ConstantInt::get(
3261 llvm::ConstantInt::get(CGM.IntTy, DstOffsetToFirstVBase),
3590 llvm::Value *GEPIndices[] = {llvm::ConstantInt::get(CGM.IntTy, 0),
3591 llvm::ConstantInt::get(CGM.IntTy, 0)};
3605 llvm::ConstantInt::get(CGM.IntTy, 0), // reserved by the runtime
3606 llvm::ConstantInt::get(CGM.IntTy, Flags),
3607 llvm::ConstantInt::get(CGM.IntTy, Classes.size()),
3685 llvm::ConstantInt::get(CGM.IntTy, Class.NumBases),
3686 llvm::ConstantInt::get(CGM.IntTy, Class.OffsetInVBase),
3687 llvm::ConstantInt::get(CGM.IntTy, VBPtrOffset),
3688 llvm::ConstantInt::get(CGM.IntTy, OffsetInVBTable),
3689 llvm::ConstantInt::get(CGM.IntTy, Class.Flags),
3727 llvm::ConstantInt::get(CGM.IntTy, ABI.isImageRelative()),
3728 llvm::ConstantInt::get(CGM.IntTy, OffsetToTop),
3729 llvm::ConstantInt::get(CGM.IntTy, VFPtrOffset),
4066 llvm::ConstantInt::get(CGM.IntTy, Flags), // Flags
4068 llvm::ConstantInt::get(CGM.IntTy, NVOffset), // NonVirtualAdjustment
4069 llvm::ConstantInt::get(CGM.IntTy, VBPtrOffset), // OffsetToVBPtr
4070 llvm::ConstantInt::get(CGM.IntTy, VBIndex), // VBTableIndex
4071 llvm::ConstantInt::get(CGM.IntTy, Size), // Size
4183 llvm::ConstantInt::get(CGM.IntTy, NumEntries), // NumEntries
4215 cast<llvm::ConstantInt>(CTA->getInitializer()->getAggregateElement(0U))
4257 llvm::ConstantInt::get(CGM.IntTy, Flags), // Flags
tools/clang/lib/CodeGen/PatternInit.cpp 40 return llvm::ConstantInt::get(Ty, IntValue);
41 return llvm::ConstantInt::get(
52 auto *Int = llvm::ConstantInt::get(IntTy, IntValue);
tools/clang/lib/CodeGen/SanitizerMetadata.cpp 52 llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), IsDynInit)),
53 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
97 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
99 llvm::ConstantAsMetadata::get(llvm::ConstantInt::get(
tools/clang/lib/CodeGen/TargetInfo.cpp 264 llvm::ConstantInt::get(CGF.IntPtrTy, Align.getQuantity() - 1));
266 llvm::ConstantInt::get(CGF.IntPtrTy, -Align.getQuantity()));
1145 return llvm::ConstantInt::get(CGM.Int32Ty, Sig);
2001 llvm::Value *Four8 = llvm::ConstantInt::get(CGF.Int8Ty, 4);
2012 llvm::Value *Sixteen8 = llvm::ConstantInt::get(CGF.Int8Ty, 16);
2025 llvm::Value *Twelve8 = llvm::ConstantInt::get(CGF.Int8Ty, 12);
2304 llvm::Value *Eight8 = llvm::ConstantInt::get(CGF.Int8Ty, 8);
2349 return llvm::ConstantInt::get(CGM.Int32Ty, Sig);
2441 llvm::Value *Eight8 = llvm::ConstantInt::get(CGF.Int8Ty, 8);
3710 llvm::ConstantInt::get(CGF.Int32Ty, (SizeInBytes + 7) & ~7);
3756 InRegs = llvm::ConstantInt::get(CGF.Int32Ty, 48 - neededInt * 8);
3764 llvm::ConstantInt::get(CGF.Int32Ty, 176 - neededSSE * 16);
3881 llvm::Value *Offset = llvm::ConstantInt::get(CGF.Int32Ty, neededInt * 8);
3886 llvm::Value *Offset = llvm::ConstantInt::get(CGF.Int32Ty, neededSSE * 16);
4343 llvm::Value *Four8 = llvm::ConstantInt::get(i8, 4);
4344 llvm::Value *Eight8 = llvm::ConstantInt::get(i8, 8);
4345 llvm::Value *Sixteen8 = llvm::ConstantInt::get(i8, 16);
4916 llvm::Value *Four8 = llvm::ConstantInt::get(i8, 4);
4917 llvm::Value *Eight8 = llvm::ConstantInt::get(i8, 8);
4918 llvm::Value *Sixteen8 = llvm::ConstantInt::get(i8, 16);
5365 reg_offs, llvm::ConstantInt::get(CGF.Int32Ty, 0));
5380 reg_offs, llvm::ConstantInt::get(CGF.Int32Ty, Align - 1),
5383 reg_offs, llvm::ConstantInt::get(CGF.Int32Ty, -Align),
5393 reg_offs, llvm::ConstantInt::get(CGF.Int32Ty, RegSize), "new_reg_offs");
5400 NewOffset, llvm::ConstantInt::get(CGF.Int32Ty, 0), "inreg");
5494 OnStackPtr, llvm::ConstantInt::get(CGF.Int64Ty, Align - 1),
5497 OnStackPtr, llvm::ConstantInt::get(CGF.Int64Ty, -Align),
5695 llvm::Value *Four8 = llvm::ConstantInt::get(CGF.Int8Ty, 4);
6525 llvm::ConstantInt::get(llvm::Type::getInt32Ty(Ctx), Operand))};
6717 llvm::ConstantInt::get(IndexTy, PaddedSize.getQuantity());
6759 llvm::Value *MaxRegsV = llvm::ConstantInt::get(IndexTy, MaxRegs);
6775 llvm::ConstantInt::get(IndexTy, RegSaveIndex * PaddedSize.getQuantity()
6790 llvm::Value *One = llvm::ConstantInt::get(IndexTy, 1);
7316 llvm::Value *Four8 = llvm::ConstantInt::get(CGF.Int8Ty, 4);
7418 llvm::ConstantAsMetadata::get(llvm::ConstantInt::getTrue(Context)));
8436 llvm::Value *Four8 = llvm::ConstantInt::get(i8, 4);
8437 llvm::Value *Eight8 = llvm::ConstantInt::get(i8, 8);
tools/clang/tools/clang-offload-wrapper/ClangOffloadWrapper.cpp 198 auto *Zero = ConstantInt::get(getSizeTTy(), 0u);
198 auto *Zero = ConstantInt::get(getSizeTTy(), 0u);
211 auto *Size = ConstantInt::get(getSizeTTy(), Buf.size());
211 auto *Size = ConstantInt::get(getSizeTTy(), Buf.size());
239 ConstantInt::get(Type::getInt32Ty(C), ImagesInits.size()), ImagesB,
tools/clang/unittests/CodeGen/IRMatchers.h 216 if (const auto *CI = dyn_cast<ConstantInt>(V))
216 if (const auto *CI = dyn_cast<ConstantInt>(V))
222 if (const auto *C = dyn_cast<ConstantInt>(MT->getValue()))
222 if (const auto *C = dyn_cast<ConstantInt>(MT->getValue()))
tools/lldb/source/Expression/IRInterpreter.cpp 245 if (const ConstantInt *constant_int = dyn_cast<ConstantInt>(constant)) {
245 if (const ConstantInt *constant_int = dyn_cast<ConstantInt>(constant)) {
1042 ConstantInt *constant_index = dyn_cast<ConstantInt>(*ii);
1042 ConstantInt *constant_index = dyn_cast<ConstantInt>(*ii);
1057 constant_index = cast<ConstantInt>(ConstantInt::get(
1057 constant_index = cast<ConstantInt>(ConstantInt::get(
tools/lldb/source/Plugins/ExpressionParser/Clang/IRDynamicChecks.cpp 251 ConstantInt::get(GetIntptrTy(), start_address, false);
275 ConstantInt::get(GetIntptrTy(), start_address, false);
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp 140 ConstantInt *constant_int =
141 mdconst::dyn_extract<ConstantInt>(metadata_node->getOperand(1));
356 ConstantInt *new_constant_int =
357 ConstantInt::get(llvm::Type::getInt64Ty(m_module->getContext()),
482 ConstantInt::get(m_intptr_ty, CFStringCreateWithBytes_addr, false);
495 Constant *numBytes_arg = ConstantInt::get(
514 Constant *encoding_arg = ConstantInt::get(i32_ty, encoding_flags, false);
516 ConstantInt::get(i8_ty, 0x0, false); /* 0x0 is false */
866 ConstantInt::get(m_intptr_ty, sel_registerName_addr, false);
1017 ConstantInt::get(m_intptr_ty, objc_getClass_addr, false);
1082 ConstantInt *constant_int =
1083 mdconst::dyn_extract<ConstantInt>(alloc_md->getOperand(0));
1298 Constant *symbol_addr_int = ConstantInt::get(m_intptr_ty, symbol_addr, false);
1372 Constant *class_addr = ConstantInt::get(m_intptr_ty, (uint64_t)class_ptr);
1792 ConstantInt *offset_int(
1793 ConstantInt::get(offset_type, offset, true));
tools/lli/lli.cpp 326 Value *ReturnVal = ConstantInt::get(ReturnTy, 0);
tools/llvm-diff/DifferenceEngine.cpp 336 DenseMap<ConstantInt*,BasicBlock*> LCases;
341 ConstantInt *CaseValue = Case.getCaseValue();
354 for (DenseMap<ConstantInt*,BasicBlock*>::iterator
tools/llvm-stress/llvm-stress.cpp 212 return ConstantInt::getAllOnesValue(Tp);
213 return ConstantInt::getNullValue(Tp);
234 return ConstantInt::getAllOnesValue(Tp);
235 return ConstantInt::getNullValue(Tp);
450 return PT->push_back(ConstantInt::get(
453 return PT->push_back(ConstantInt::get(
460 PT->push_back(ConstantInt::get(Ty, getRandom()));
485 ConstantInt::get(Type::getInt32Ty(BB->getContext()),
505 Constant *CI = ConstantInt::get(I32, getRandom() % (Width*2));
529 ConstantInt::get(Type::getInt32Ty(BB->getContext()),
tools/opt/Debugify.cpp 154 Ctx, ValueAsMetadata::getConstant(ConstantInt::get(IntTy, N))));
221 return mdconst::extract<ConstantInt>(NMD->getOperand(Idx)->getOperand(0))
tools/polly/lib/Analysis/ScopBuilder.cpp 404 ConstantInt *CaseValue = Case.getCaseValue();
444 auto *Unique = dyn_cast<ConstantInt>(
444 auto *Unique = dyn_cast<ConstantInt>(
451 } else if (auto *CCond = dyn_cast<ConstantInt>(Condition)) {
451 } else if (auto *CCond = dyn_cast<ConstantInt>(Condition)) {
1666 ConstantInt::get(IntegerType::getInt64Ty(BasePtr->getContext()), V)));
tools/polly/lib/Analysis/ScopDetection.cpp 560 if (isa<ConstantInt>(Condition))
574 auto *Unique = dyn_cast_or_null<ConstantInt>(
574 auto *Unique = dyn_cast_or_null<ConstantInt>(
tools/polly/lib/Analysis/ScopInfo.cpp 1484 ConstantInt *Op = cast<ConstantInt>(&Operand);
1484 ConstantInt *Op = cast<ConstantInt>(&Operand);
tools/polly/lib/CodeGen/BlockGenerators.cpp 601 IsInSetExpr, ConstantInt::get(IsInSetExpr->getType(), 0));
626 if (auto *Const = dyn_cast<ConstantInt>(Cond))
626 if (auto *Const = dyn_cast<ConstantInt>(Cond))
1069 Indices.push_back(ConstantInt::get(Builder.getInt32Ty(), i));
tools/polly/lib/CodeGen/CodeGeneration.cpp 250 auto *FalseI1 = Builder.getFalse();
tools/polly/lib/CodeGen/IRBuilder.cpp 131 auto *FalseValue = ConstantInt::get(Type::getInt1Ty(Ctx), 0);
131 auto *FalseValue = ConstantInt::get(Type::getInt1Ty(Ctx), 0);
tools/polly/lib/CodeGen/IslExprBuilder.cpp 189 return createSub(ConstantInt::getNullValue(MaxType), V);
417 if (auto *Const = dyn_cast<ConstantInt>(RHS)) {
417 if (auto *Const = dyn_cast<ConstantInt>(RHS)) {
428 Value *One = ConstantInt::get(MaxType, 1);
429 Value *Zero = ConstantInt::get(MaxType, 0);
764 V = ConstantInt::get(T, APValue);
tools/polly/lib/CodeGen/IslNodeBuilder.cpp 1156 ConstantInt::get(endType, 1, /* signed = */ true),
1483 ConstantInt::get(Type::getInt64Ty(Ctx), Size),
1484 ConstantInt::get(Type::getInt64Ty(Ctx), ArraySizeInt), nullptr,
1613 if (!isa<ConstantInt>(RTC))
tools/polly/lib/CodeGen/LoopGenerators.cpp 193 UB = Builder.CreateAdd(UB, ConstantInt::get(LongType, 1));
tools/polly/lib/CodeGen/LoopGeneratorsGOMP.cpp 150 UB = Builder.CreateSub(UB, ConstantInt::get(LongType, 1),
tools/polly/lib/CodeGen/LoopGeneratorsKMP.cpp 190 Value *AdjustedUB = Builder.CreateAdd(UB, ConstantInt::get(LongType, -1),
194 ConstantInt::get(LongType, std::max<int>(PollyChunkSize, 1));
350 ConstantInt::get(LongType, 1),
tools/polly/lib/CodeGen/RuntimeDebugBuilder.cpp 177 auto *Zero = Builder.getInt64(0);
tools/polly/lib/Support/SCEVAffinator.cpp 242 ConstantInt *Value = Expr->getValue();
tools/polly/lib/Support/SCEVValidator.cpp 125 if (!isa<ConstantInt>(&Operand))
421 auto *CI = dyn_cast<ConstantInt>(Divisor);
421 auto *CI = dyn_cast<ConstantInt>(Divisor);
tools/polly/lib/Support/ScopHelper.cpp 453 return ConstantInt::getTrue(Type::getInt1Ty(TI->getContext()));
unittests/Analysis/AliasAnalysisTest.cpp 174 auto *Value = ConstantInt::get(IntType, 42);
174 auto *Value = ConstantInt::get(IntType, 42);
182 Addr, ConstantInt::get(IntType, 0), ConstantInt::get(IntType, 1),
182 Addr, ConstantInt::get(IntType, 0), ConstantInt::get(IntType, 1),
186 new AtomicRMWInst(AtomicRMWInst::Xchg, Addr, ConstantInt::get(IntType, 1),
unittests/Analysis/BranchProbabilityInfoTest.cpp 75 Switch->addCase(ConstantInt::get(I32, I), PreExitBB);
unittests/Analysis/DomTreeUpdaterTest.cpp 273 BranchInst::Create(BB1, BB2, ConstantInt::getTrue(F->getContext()), BB0);
371 BranchInst::Create(BB1, BB3, ConstantInt::getTrue(F->getContext()), BB0);
490 BranchInst::Create(BB1, BB2, ConstantInt::getTrue(F->getContext()), BB0);
unittests/Analysis/LoopInfoTest.cpp 274 ConstantInt *InitialIVValue =
275 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
278 ConstantInt *StepValue =
279 dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
332 ConstantInt *InitialIVValue =
333 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
336 ConstantInt *StepValue =
337 dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
390 ConstantInt *InitialIVValue =
391 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
394 ConstantInt *StepValue =
395 dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
448 ConstantInt *InitialIVValue =
449 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
452 ConstantInt *StepValue =
453 dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
506 ConstantInt *InitialIVValue =
507 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
510 ConstantInt *StepValue =
511 dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
565 ConstantInt *InitialIVValue =
566 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
569 ConstantInt *StepValue =
570 dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
623 ConstantInt *InitialIVValue =
624 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
678 ConstantInt *InitialIVValue =
679 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
682 ConstantInt *StepValue =
683 dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
738 ConstantInt *StepValue =
739 dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
741 ConstantInt *FinalIVValue =
742 dyn_cast<ConstantInt>(&Bounds->getFinalIVValue());
795 ConstantInt *InitialIVValue =
796 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
854 ConstantInt *InitialIVValue =
855 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
858 ConstantInt *StepValue =
859 dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
914 ConstantInt *InitialIVValue =
915 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
918 ConstantInt *StepValue =
919 dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
974 ConstantInt *InitialIVValue =
975 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
978 ConstantInt *StepValue =
979 dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
1026 ConstantInt *InitialIVValue =
1027 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
1030 ConstantInt *StepValue =
1031 dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
1083 ConstantInt *InitialIVValue =
1084 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
1087 ConstantInt *StepValue =
1088 dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
1153 ConstantInt *InitialIVValue =
1154 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
1157 ConstantInt *StepValue =
1158 dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
1179 dyn_cast<ConstantInt>(&InnerBounds->getInitialIVValue());
1182 StepValue = dyn_cast_or_null<ConstantInt>(InnerBounds->getStepValue());
1244 ConstantInt *InitialIVValue =
1245 dyn_cast<ConstantInt>(&Bounds->getInitialIVValue());
1248 ConstantInt *StepValue =
1249 dyn_cast_or_null<ConstantInt>(Bounds->getStepValue());
unittests/Analysis/MemoryBuiltinsTest.cpp 36 CallInst::Create(AllocSizeFn, {ConstantInt::get(ArgTy, 100)}));
unittests/Analysis/MemorySSATest.cpp 601 Value *Alloca = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
602 StoreInst *S1 = B.CreateStore(ConstantInt::get(Int8, 0), Alloca);
603 StoreInst *S2 = B.CreateStore(ConstantInt::get(Int8, 1), Alloca);
604 StoreInst *S3 = B.CreateStore(ConstantInt::get(Int8, 2), Alloca);
632 Value *Alloca = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
633 Instruction *SI = B.CreateStore(ConstantInt::get(Int8, 0), Alloca);
662 Value *Alloca = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
663 StoreInst *SI = B.CreateStore(ConstantInt::get(Int8, 0), Alloca);
706 Constant *One = ConstantInt::get(Int8, 1);
707 Constant *Zero = ConstantInt::get(Int8, 0);
770 Constant *One = ConstantInt::get(Int8, 1);
799 Value *AllocaA = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
800 Instruction *SIA = B.CreateStore(ConstantInt::get(Int8, 0), AllocaA);
801 Value *AllocaB = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "B");
802 Instruction *SIB = B.CreateStore(ConstantInt::get(Int8, 0), AllocaB);
831 Value *A = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
832 Value *B_ = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "B");
833 Value *C = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "C");
835 StoreInst *StoreA0 = B.CreateStore(ConstantInt::get(Int8, 0), A);
836 StoreInst *StoreB = B.CreateStore(ConstantInt::get(Int8, 0), B_);
838 StoreInst *StoreA1 = B.CreateStore(ConstantInt::get(Int8, 4), A);
839 StoreInst *StoreC = B.CreateStore(ConstantInt::get(Int8, 4), C);
840 StoreInst *StoreA2 = B.CreateStore(ConstantInt::get(Int8, 4), A);
1008 Value *AllocaA = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
1009 Value *AllocaB = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "B");
1011 B.CreateStore(ConstantInt::get(Int8, 1), AllocaB);
1017 B.CreateStore(ConstantInt::get(Int8, 1), AllocaA);
1051 Value *AllocaA = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
1052 Value *AllocaB = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "B");
1053 StoreInst *SA1 = B.CreateStore(ConstantInt::get(Int8, 1), AllocaA);
1054 StoreInst *SB1 = B.CreateStore(ConstantInt::get(Int8, 1), AllocaB);
1055 StoreInst *SA2 = B.CreateStore(ConstantInt::get(Int8, 2), AllocaA);
1056 StoreInst *SB2 = B.CreateStore(ConstantInt::get(Int8, 2), AllocaB);
1057 StoreInst *SA3 = B.CreateStore(ConstantInt::get(Int8, 3), AllocaA);
1058 StoreInst *SB3 = B.CreateStore(ConstantInt::get(Int8, 3), AllocaB);
1105 B.CreateStore(ConstantInt::get(Int8, 1), PointerB);
1107 B.CreateStore(ConstantInt::get(Int8, 0), PointerA);
1109 B.CreateStore(ConstantInt::get(Int8, 0), PointerA);
1111 B.CreateStore(ConstantInt::get(Int8, 0), PointerB);
1147 Value *AllocaC = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "C");
1149 StoreInst *SA1 = B.CreateStore(ConstantInt::get(Int8, 0), PointerA);
1151 StoreInst *SB1 = B.CreateStore(ConstantInt::get(Int8, 1), PointerB);
1153 StoreInst *SC1 = B.CreateStore(ConstantInt::get(Int8, 2), AllocaC);
1155 StoreInst *SA2 = B.CreateStore(ConstantInt::get(Int8, 3), PointerA);
1157 StoreInst *SB2 = B.CreateStore(ConstantInt::get(Int8, 4), PointerB);
1159 StoreInst *SC2 = B.CreateStore(ConstantInt::get(Int8, 5), AllocaC);
1161 StoreInst *SB3 = B.CreateStore(ConstantInt::get(Int8, 6), PointerB);
1289 Value *Alloca = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "alloc");
1339 Value *AllocA = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
1340 Value *AllocB = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "B");
1342 StoreInst *StoreA = B.CreateStore(ConstantInt::get(Int8, 0), AllocA);
1343 StoreInst *StoreB = B.CreateStore(ConstantInt::get(Int8, 1), AllocB);
1344 StoreInst *StoreA2 = B.CreateStore(ConstantInt::get(Int8, 2), AllocA);
1478 Value *Alloca = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
1486 B.CreateStore(ConstantInt::get(Int8, 0), Alloca);
unittests/Analysis/ScalarEvolutionTest.cpp 177 ConstantInt *Ci32 = ConstantInt::get(Context, APInt(32, 1));
177 ConstantInt *Ci32 = ConstantInt::get(Context, APInt(32, 1));
695 PN->addIncoming(ConstantInt::get(Context, APInt(64, 100)), PrevBB);
697 ConstantInt::get(Context, APInt(64, 90)), "cmp",
706 PN, ConstantInt::get(Context, APInt(64, -1)), "dec", IncBB);
775 Value *Add = Builder.CreateAdd(Phi, ConstantInt::get(T_int64, 1), "add");
777 Phi->addIncoming(ConstantInt::get(T_int64, 0), LPh);
782 Builder.CreateGEP(T_int64, Arg, ConstantInt::get(T_int64, 1));
848 Builder.CreateAdd(Phi, ConstantInt::get(T_int64, 1), "add"));
849 auto *Limit = ConstantInt::get(T_int64, 1000);
853 Phi->addIncoming(ConstantInt::get(T_int64, 0), LPh);
883 ICmpInst::ICMP_SLT, Add, ConstantInt::get(T_int64, 2000), "new.cond");
949 Builder.CreateAdd(Phi, ConstantInt::get(T_int64, 1), "add"));
953 Phi->addIncoming(ConstantInt::get(T_int64, 0), LPh);
972 ICmpInst::ICMP_SLT, Add, ConstantInt::get(T_int64, 2000), "new.cond");
1013 auto *MinInt64 =
1014 ConstantInt::get(Context, APInt(64, 0x8000000000000000U, true));
1015 auto *Int64_32 = ConstantInt::get(Context, APInt(64, 32));
1015 auto *Int64_32 = ConstantInt::get(Context, APInt(64, 32));
1071 auto *MinInt32 = ConstantInt::get(Context, APInt(32, 0x80000000U, true));
1071 auto *MinInt32 = ConstantInt::get(Context, APInt(32, 0x80000000U, true));
1072 auto *Int32_16 = ConstantInt::get(Context, APInt(32, 16));
1072 auto *Int32_16 = ConstantInt::get(Context, APInt(32, 16));
1174 Builder.CreateAdd(Phi, ConstantInt::get(T_int64, 1), "add"));
1175 auto *Limit = ConstantInt::get(T_int64, 1000);
1179 Phi->addIncoming(ConstantInt::get(T_int64, 0), LPh);
1221 ConstantInt *C = ConstantInt::get(Context, APInt(64, -1));
1221 ConstantInt *C = ConstantInt::get(Context, APInt(64, -1));
1228 ConstantInt *Cond = ConstantInt::get(Context, APInt(1, 0));
1228 ConstantInt *Cond = ConstantInt::get(Context, APInt(1, 0));
1273 ConstantInt *C = ConstantInt::get(Context, APInt(64, -1));
1273 ConstantInt *C = ConstantInt::get(Context, APInt(64, -1));
1280 ConstantInt *Cond = ConstantInt::get(Context, APInt(1, 0));
1280 ConstantInt *Cond = ConstantInt::get(Context, APInt(1, 0));
1323 ConstantInt *C = ConstantInt::get(Context, APInt(64, -1));
1323 ConstantInt *C = ConstantInt::get(Context, APInt(64, -1));
1374 ConstantInt *C = ConstantInt::get(Context, APInt(64, -1));
1374 ConstantInt *C = ConstantInt::get(Context, APInt(64, -1));
1425 ConstantInt *C = ConstantInt::get(Context, APInt(64, 1));
1425 ConstantInt *C = ConstantInt::get(Context, APInt(64, 1));
unittests/Analysis/TBAATest.cpp 40 auto *SI = new StoreInst(ConstantInt::get(IntType, 42),
unittests/Analysis/ValueLatticeTest.cpp 33 auto *C1 = ConstantInt::get(I32Ty, 1);
33 auto *C1 = ConstantInt::get(I32Ty, 1);
48 auto *C1 = ConstantInt::get(I32Ty, 1);
48 auto *C1 = ConstantInt::get(I32Ty, 1);
93 auto *C1 = ConstantInt::get(I32Ty, 1);
93 auto *C1 = ConstantInt::get(I32Ty, 1);
unittests/CodeGen/GlobalISel/MachineIRBuilderTest.cpp 59 ConstantInt *CI = ConstantInt::get(Ctx, APV32);
59 ConstantInt *CI = ConstantInt::get(Ctx, APV32);
unittests/CodeGen/MachineOperandTest.cpp 89 ConstantInt *CImm = ConstantInt::get(Context, Int);
89 ConstantInt *CImm = ConstantInt::get(Context, Int);
unittests/ExecutionEngine/MCJIT/MCJITTest.cpp 169 endFunctionWithRet(Inner, ConstantInt::get(Context, APInt(32, innerRetVal)));
unittests/ExecutionEngine/MCJIT/MCJITTestBase.h 83 Value *ReturnVal = ConstantInt::get(Context, APInt(32, returnCode));
132 Constant *IV = ConstantInt::get(Context, APInt(32, InitialValue));
168 Value *Zero = ConstantInt::get(Context, APInt(32, 0));
179 Value *One = ConstantInt::get(Context, APInt(32, 1));
unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp 83 ConstantInt::get(Int32Ty, 42), "foo");
164 Value *FourtyTwo = ConstantInt::getSigned(Int32Ty, 42);
250 Value *FourtyTwo = ConstantInt::getSigned(Int32Ty, 42);
264 Value *Seven = ConstantInt::getSigned(Int32Ty, 7);
unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp 79 ConstantInt::get(Int32Ty, 42), "foo");
unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp 105 B.CreateRet(ConstantInt::getSigned(Type::getInt32Ty(Ctx), 42));
unittests/FuzzMutate/OperationsTest.cpp 82 Constant *i1 = ConstantInt::getFalse(Ctx);
83 Constant *i8 = ConstantInt::get(Type::getInt8Ty(Ctx), 3);
84 Constant *i16 = ConstantInt::get(Type::getInt16Ty(Ctx), 1 << 15);
85 Constant *i32 = ConstantInt::get(Type::getInt32Ty(Ctx), 0);
86 Constant *i64 = ConstantInt::get(Type::getInt64Ty(Ctx),
197 Value *Cond = ConstantInt::getFalse(Ctx);
238 Descr.BuilderFunc({ConstantInt::getTrue(Ctx)},&*BB.getFirstInsertionPt());
257 BranchInst::Create(BB2, BB3, ConstantInt::getFalse(Ctx), BB1);
262 PHI1->addIncoming(ConstantInt::get(Int8Ty, 0), BB1);
263 PHI1->addIncoming(ConstantInt::get(Int8Ty, 1), BB2);
265 PHI2->addIncoming(ConstantInt::get(Int8Ty, 1), BB1);
266 PHI2->addIncoming(ConstantInt::get(Int8Ty, 0), BB2);
270 Value *Cond = ConstantInt::getFalse(Ctx);
297 GEPOp.BuilderFunc({UndefValue::get(Int8PtrTy), ConstantInt::get(Int32Ty, 0)},
unittests/FuzzMutate/RandomIRBuilderTest.cpp 122 Srcs[1] = ConstantInt::get(T, 5);
unittests/IR/AsmWriterTest.cpp 30 "", MDNode::get(Ctx, {ConstantAsMetadata::get(ConstantInt::get(Ty, 1))}));
unittests/IR/CFGBuilder.cpp 47 IRB.CreateSwitch(ConstantInt::get(IntTy, 0), To);
54 auto *IntVal = ConstantInt::get(IntTy, Last);
54 auto *IntVal = ConstantInt::get(IntTy, Last);
unittests/IR/ConstantsTest.cpp 26 Constant* One = ConstantInt::get(Int1, 1, true);
27 Constant* Zero = ConstantInt::get(Int1, 0);
28 Constant* NegOne = ConstantInt::get(Int1, static_cast<uint64_t>(-1), true);
159 ConstantInt *K = ConstantInt::get(Type::getInt64Ty(C), 1234);
159 ConstantInt *K = ConstantInt::get(Type::getInt64Ty(C), 1234);
215 Constant *One = ConstantInt::get(Int32Ty, 1);
216 Constant *Two = ConstantInt::get(Int64Ty, 2);
217 Constant *Big = ConstantInt::get(Context, APInt{256, uint64_t(-1), true});
218 Constant *Elt = ConstantInt::get(Int16Ty, 2015);
309 Constant *One = ConstantInt::get(Int32Ty, 1);
330 Constant *A01Vals[2] = {ConstantInt::get(IntTy, 0),
331 ConstantInt::get(IntTy, 1)};
337 Constant *A0GVals[2] = {ConstantInt::get(IntTy, 0), GlobalInt};
345 GlobalInt->replaceAllUsesWith(ConstantInt::get(IntTy, 1));
378 auto *C1 = ConstantInt::get(IntTy, 1);
425 Constant *Vals[] = {ConstantInt::get(T, 0), ConstantInt::get(T, 1)};
425 Constant *Vals[] = {ConstantInt::get(T, 0), ConstantInt::get(T, 1)};
447 Constant *Vals[] = {ConstantInt::get(T, 0), ConstantInt::get(T, 1)};
447 Constant *Vals[] = {ConstantInt::get(T, 0), ConstantInt::get(T, 1)};
490 ConstantInt *TheConstant(ConstantInt::get(ConstantIntType, AndValue));
490 ConstantInt *TheConstant(ConstantInt::get(ConstantIntType, AndValue));
579 ConstantInt *TheConstant(ConstantInt::get(IntType, 2));
579 ConstantInt *TheConstant(ConstantInt::get(IntType, 2));
unittests/IR/DominatorTreeTest.cpp 241 BranchInst::Create(BB4, BB3, ConstantInt::getTrue(F.getContext()), BB1);
unittests/IR/InstructionsTest.cpp 49 Constant* One = ConstantInt::get(Int1, 1, true);
84 Value *Args[] = {ConstantInt::get(Type::getInt8Ty(Ctx), 20),
85 ConstantInt::get(Type::getInt32Ty(Ctx), 9999),
86 ConstantInt::get(Type::getInt64Ty(Ctx), 42)};
102 Value *Args[] = {ConstantInt::get(Type::getInt8Ty(Ctx), 20),
103 ConstantInt::get(Type::getInt32Ty(Ctx), 9999),
104 ConstantInt::get(Type::getInt64Ty(Ctx), 42)};
139 Constant* One = ConstantInt::get(Int1, 1, true);
319 ConstantInt *Ci32a = ConstantInt::get(C, APInt(32, 1492));
319 ConstantInt *Ci32a = ConstantInt::get(C, APInt(32, 1492));
320 ConstantInt *Ci32b = ConstantInt::get(C, APInt(32, 1948));
320 ConstantInt *Ci32b = ConstantInt::get(C, APInt(32, 1948));
510 ConstantInt::get(Int32Ty, 1),
511 ConstantInt::get(Int32Ty, 2),
512 ConstantInt::get(Int32Ty, 3)
543 Value *Args[] = {ConstantInt::get(Int32Ty, 42)};
553 OperandBundleDef NewBundle("after", ConstantInt::get(Int32Ty, 7));
570 Value *Args[] = {ConstantInt::get(Int32Ty, 42)};
583 OperandBundleDef NewBundle("after", ConstantInt::get(Int32Ty, 7));
709 SI->addCase(ConstantInt::get(Int32Ty, 1), BB1.get());
710 SI->addCase(ConstantInt::get(Int32Ty, 2), BB2.get());
711 SI->addCase(ConstantInt::get(Int32Ty, 3), BB3.get());
772 SI->addCase(ConstantInt::get(Int32Ty, 1), BB1.get());
773 SI->addCase(ConstantInt::get(Int32Ty, 2), BB2.get());
808 Constant *C0 = ConstantInt::get(Int32Ty, 0);
809 Constant *C1 = ConstantInt::get(Int32Ty, 1);
810 Constant *C2 = ConstantInt::get(Int32Ty, 2);
811 Constant *C3 = ConstantInt::get(Int32Ty, 3);
812 Constant *C4 = ConstantInt::get(Int32Ty, 4);
813 Constant *C5 = ConstantInt::get(Int32Ty, 5);
814 Constant *C6 = ConstantInt::get(Int32Ty, 6);
815 Constant *C7 = ConstantInt::get(Int32Ty, 7);
unittests/IR/MDBuilderTest.cpp 54 ConstantInt *C0 = mdconst::extract<ConstantInt>(R1->getOperand(0));
54 ConstantInt *C0 = mdconst::extract<ConstantInt>(R1->getOperand(0));
55 ConstantInt *C1 = mdconst::extract<ConstantInt>(R1->getOperand(1));
55 ConstantInt *C1 = mdconst::extract<ConstantInt>(R1->getOperand(1));
unittests/IR/MetadataTest.cpp 109 return ConstantInt::get(Type::getInt32Ty(Context), Counter++);
180 ConstantAsMetadata::get(ConstantInt::get(Context, APInt(8, 0)));
211 Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 1);
262 Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 7);
321 Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 7);
2512 auto *C = ConstantInt::getTrue(Context);
2512 auto *C = ConstantInt::getTrue(Context);
2545 ConstantAsMetadata::get(ConstantInt::get(Context, APInt(8, 0)));
2562 ConstantAsMetadata::get(ConstantInt::get(Context, APInt(8, 0)));
2621 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 1));
2623 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 2));
unittests/IR/PatternMatch.cpp 72 Value *Zero = ConstantInt::get(IntTy, 0);
73 Value *One = ConstantInt::get(IntTy, 1);
74 Value *NegOne = ConstantInt::get(IntTy, -1);
111 Value *Zero = ConstantInt::get(IntTy, 0);
112 Value *One = ConstantInt::get(IntTy, 1);
113 Value *NegOne = ConstantInt::get(IntTy, -1);
150 Value *Zero = ConstantInt::get(IntTy, 0);
151 Value *One = ConstantInt::get(IntTy, 1);
152 Value *NegOne = ConstantInt::get(IntTy, -1);
189 Value *Zero = ConstantInt::get(IntTy, 0);
190 Value *One = ConstantInt::get(IntTy, 1);
191 Value *NegOne = ConstantInt::get(IntTy, -1);
228 Value *Zero = ConstantInt::get(IntTy, 0);
229 Value *One = ConstantInt::get(IntTy, 1);
230 Value *NegOne = ConstantInt::get(IntTy, -1);
267 Value *Zero = ConstantInt::get(IntTy, 0);
268 Value *One = ConstantInt::get(IntTy, 1);
269 Value *NegOne = ConstantInt::get(IntTy, -1);
306 Value *Zero = ConstantInt::get(IntTy, 0);
307 Value *One = ConstantInt::get(IntTy, 1);
308 Value *NegOne = ConstantInt::get(IntTy, -1);
345 Value *Zero = ConstantInt::get(IntTy, 0);
346 Value *One = ConstantInt::get(IntTy, 1);
347 Value *NegOne = ConstantInt::get(IntTy, -1);
384 Value *Zero = ConstantInt::get(IntTy, 0);
385 Value *One = ConstantInt::get(IntTy, 1);
386 Value *NegOne = ConstantInt::get(IntTy, -1);
423 Value *Zero = ConstantInt::get(IntTy, 0);
424 Value *One = ConstantInt::get(IntTy, 1);
425 Value *NegOne = ConstantInt::get(IntTy, -1);
916 VecElemIdxs.push_back(ConstantInt::get(i32, 0));
917 VecElemIdxs.push_back(ConstantInt::get(i32, 2));
unittests/IR/ValueHandleTest.cpp 27 : ConstantV(ConstantInt::get(Type::getInt32Ty(Context), 0)),
unittests/IR/ValueMapTest.cpp 30 : ConstantV(ConstantInt::get(Type::getInt32Ty(Context), 0)),
unittests/IR/VerifierTest.cpp 37 Constant *False = ConstantInt::getFalse(C);
42 Constant *Zero32 = ConstantInt::get(IntegerType::get(C, 32), 0);
84 Constant *ConstZero = ConstantInt::get(Type::getInt32Ty(C), 0);
unittests/IR/WaymarkTest.cpp 26 return ConstantInt::get(Type::getInt8Ty(Context), c);
unittests/Linker/LinkModulesTest.cpp 53 ConstantInt *One = ConstantInt::get(Type::getInt32Ty(Ctx), 1);
53 ConstantInt *One = ConstantInt::get(Type::getInt32Ty(Ctx), 1);
82 GEPIndices.push_back(ConstantInt::get(Type::getInt32Ty(Ctx), 0));
unittests/Transforms/Utils/CloningTest.cpp 727 ConstantInt::get(Type::getInt32Ty(C), 1), "gv");
unittests/Transforms/Utils/LocalTest.cpp 526 const auto &CI = *cast<ConstantInt>(DI.getValue());
526 const auto &CI = *cast<ConstantInt>(DI.getValue());
536 const auto &CI = *cast<ConstantInt>(DI.getValue());
536 const auto &CI = *cast<ConstantInt>(DI.getValue());
unittests/Transforms/Utils/SSAUpdaterBulkTest.cpp 56 Value *AddOp1 = B.CreateAdd(FirstArg, ConstantInt::get(I32Ty, 1));
57 Value *SubOp1 = B.CreateSub(FirstArg, ConstantInt::get(I32Ty, 2));
61 Value *AddOp2 = B.CreateAdd(FirstArg, ConstantInt::get(I32Ty, 3));
62 Value *SubOp2 = B.CreateSub(FirstArg, ConstantInt::get(I32Ty, 4));
66 auto *I1 = cast<Instruction>(B.CreateAdd(AddOp1, ConstantInt::get(I32Ty, 5)));
67 auto *I2 = cast<Instruction>(B.CreateAdd(AddOp2, ConstantInt::get(I32Ty, 6)));
140 Value *AddOp1 = B.CreateAdd(FirstArg, ConstantInt::get(I32Ty, 1));
144 Value *AddOp2 = B.CreateAdd(FirstArg, ConstantInt::get(I32Ty, 2));
148 auto *I1 = cast<Instruction>(B.CreateAdd(AddOp1, ConstantInt::get(I32Ty, 3)));
152 auto *I2 = cast<Instruction>(B.CreateAdd(AddOp2, ConstantInt::get(I32Ty, 4)));
unittests/Transforms/Utils/ValueMapperTest.cpp 336 Constant &C = *ConstantInt::get(Int8, 42);
usr/include/c++/7.4.0/bits/unique_ptr.h 68 default_delete(const default_delete<_Up>&) noexcept { }
72 operator()(_Tp* __ptr) const
74 static_assert(!is_void<_Tp>::value,
76 static_assert(sizeof(_Tp)>0,
122 using type = _Up*;
137 using pointer = typename _Ptr<_Tp, _Dp>::type;
161 typename __uniq_ptr_impl<_Tp, _Up>::_DeleterConstraint::type;
163 __uniq_ptr_impl<_Tp, _Dp> _M_t;
166 using pointer = typename __uniq_ptr_impl<_Tp, _Dp>::pointer;
167 using element_type = _Tp;
252 unique_ptr(unique_ptr<_Up, _Ep>&& __u) noexcept
297 __safe_conversion_up<_Up, _Ep>,
301 operator=(unique_ptr<_Up, _Ep>&& __u) noexcept
usr/include/c++/7.4.0/type_traits 215 : public __is_void_helper<typename remove_cv<_Tp>::type>::type
581 : public __or_<is_lvalue_reference<_Tp>,
582 is_rvalue_reference<_Tp>>::type
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
601 : public __not_<__or_<is_function<_Tp>, is_reference<_Tp>,
602 is_void<_Tp>>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
638 : public __or_<is_object<_Tp>, is_reference<_Tp>>::type
1554 { typedef _Tp type; };
1563 { typedef _Tp type; };
1574 remove_const<typename remove_volatile<_Tp>::type>::type type;
1645 { typedef _Tp& type; };
1650 : public __add_lvalue_reference_helper<_Tp>
1983 { typedef _Up type; };
utils/unittest/googletest/include/gtest/gtest-printers.h 407 T* p, ::std::ostream* os) {
416 if (IsTrue(ImplicitlyConvertible<T*, const void*>::value)) {