|
|
reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced
|
Derived Classes
include/llvm/IR/DerivedTypes.h 40 class IntegerType : public Type {
108 class FunctionType : public Type {
199 class CompositeType : public Type {
579 class PointerType : public Type {
Declarations
include/llvm/Analysis/ConstantFolding.h 34 class Type;
include/llvm/Analysis/InstructionSimplify.h 52 class Type;
include/llvm/Analysis/MemoryBuiltins.h 52 class Type;
include/llvm/Analysis/ScalarEvolution.h 70 class Type;
include/llvm/Analysis/ScalarEvolutionExpressions.h 36 class Type;
include/llvm/Analysis/TargetTransformInfo.h 54 class Type;
include/llvm/Analysis/VectorUtils.h 142 class Type;
include/llvm/AsmParser/Parser.h 26 class Type;
include/llvm/AsmParser/SlotMapping.h 24 class Type;
include/llvm/CodeGen/FastISel.h 59 class Type;
include/llvm/CodeGen/GCStrategy.h 59 class Type;
include/llvm/CodeGen/GlobalISel/CallLowering.h 38 class Type;
include/llvm/CodeGen/LowLevelType.h 24 class Type;
include/llvm/CodeGen/MachineConstantPool.h 30 class Type;
include/llvm/CodeGen/SelectionDAGNodes.h 67 class Type;
include/llvm/CodeGen/StackProtector.h 35 class Type;
include/llvm/CodeGen/ValueTypes.h 28 class Type;
include/llvm/ExecutionEngine/ExecutionEngine.h 54 class Type;
include/llvm/IR/Attributes.h 43 class Type;
include/llvm/IR/AutoUpgrade.h 26 class Type;
include/llvm/IR/DerivedUser.h 16 class Type;
include/llvm/IR/Function.h 56 class Type;
include/llvm/IR/Intrinsics.h 25 class Type;
include/llvm/IR/Metadata.h 48 class Type;
include/llvm/IR/TypeFinder.h 25 class Type;
include/llvm/IR/Value.h 52 class Type;
include/llvm/Linker/IRMover.h 23 class Type;
include/llvm/Linker/Linker.h 18 class Type;
include/llvm/Support/LowLevelTypeImpl.h 36 class Type;
include/llvm/Support/MachineValueType.h 25 class Type;
include/llvm/Target/TargetIntrinsicInfo.h 24 class Type;
include/llvm/Transforms/Scalar/GVNExpression.h 38 class Type;
include/llvm/Transforms/Scalar/NaryReassociate.h 99 class Type;
include/llvm/Transforms/Utils/CodeExtractor.h 37 class Type;
include/llvm/Transforms/Utils/FunctionComparator.h 39 class Type;
include/llvm/Transforms/Utils/ModuleUtils.h 30 class Type;
include/llvm/Transforms/Utils/SSAUpdater.h 28 class Type;
include/llvm/Transforms/Utils/SSAUpdaterBulk.h 26 class Type;
include/llvm/Transforms/Utils/VNCoercion.h 32 class Type;
include/llvm/Transforms/Utils/ValueMapper.h 30 class Type;
lib/AsmParser/LLLexer.h 24 class Type;
lib/Bitcode/Reader/MetadataLoader.h 32 class Type;
lib/Bitcode/Reader/ValueList.h 25 class Type;
lib/Bitcode/Writer/ValueEnumerator.h 40 class Type;
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h 85 class Type;
lib/IR/AttributeImpl.h 32 class Type;
lib/IR/ConstantFold.h 27 class Type;
lib/IR/LLVMContextImpl.h 58 class Type;
lib/Target/AArch64/AArch64CallLowering.h 30 class Type;
lib/Target/AArch64/AArch64TargetTransformInfo.h 37 class Type;
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.h 33 class Type;
lib/Target/AMDGPU/AMDGPUTargetTransformInfo.h 38 class Type;
lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h 29 class Type;
lib/Target/ARM/ARMConstantPoolValue.h 33 class Type;
lib/Target/ARM/ARMTargetTransformInfo.h 38 class Type;
tools/clang/include/clang/CodeGen/CodeGenABITypes.h 35 class Type;
tools/clang/include/clang/CodeGen/SwiftCallingConv.h 24 class Type;
tools/clang/lib/CodeGen/ABIInfo.h 21 class Type;
tools/clang/lib/CodeGen/CGCXXABI.h 22 class Type;
tools/clang/lib/CodeGen/CGCall.h 30 class Type;
tools/clang/lib/CodeGen/CGObjCRuntime.h 30 class Type;
tools/clang/lib/CodeGen/CGOpenMPRuntime.h 34 class Type;
tools/clang/lib/CodeGen/CodeGenTypeCache.h 21 class Type;
tools/clang/lib/CodeGen/CodeGenTypes.h 25 class Type;
tools/clang/lib/CodeGen/PatternInit.h 14 class Type;
tools/clang/lib/CodeGen/TargetInfo.h 28 class Type;
tools/lldb/include/lldb/Target/ABI.h 21 class Type;
References
examples/BrainF/BrainF.cpp 70 Type *Tys[] = { Type::getInt8PtrTy(C), Type::getInt32Ty(C) };
70 Type *Tys[] = { Type::getInt8PtrTy(C), Type::getInt32Ty(C) };
70 Type *Tys[] = { Type::getInt8PtrTy(C), Type::getInt32Ty(C) };
85 brainf_func = Function::Create(FunctionType::get(Type::getVoidTy(C), false),
93 Type* IntPtrTy = IntegerType::getInt32Ty(C);
94 Type* Int8Ty = IntegerType::getInt8Ty(C);
examples/BrainF/BrainFDriver.cpp 76 Type::getInt32Ty(mod->getContext()),
77 {Type::getInt32Ty(mod->getContext()),
78 Type::getInt8Ty(mod->getContext())->getPointerTo()->getPointerTo()},
examples/Fibonacci/fibonacci.cpp 54 FunctionType *FibFTy = FunctionType::get(Type::getInt32Ty(Context),
55 {Type::getInt32Ty(Context)}, false);
63 Value *One = ConstantInt::get(Type::getInt32Ty(Context), 1);
64 Value *Two = ConstantInt::get(Type::getInt32Ty(Context), 2);
examples/HowToUseJIT/HowToUseJIT.cpp 72 Function::Create(FunctionType::get(Type::getInt32Ty(Context),
73 {Type::getInt32Ty(Context)}, false),
103 Function::Create(FunctionType::get(Type::getInt32Ty(Context), {}, false),
examples/HowToUseLLJIT/HowToUseLLJIT.cpp 29 Function::Create(FunctionType::get(Type::getInt32Ty(*Context),
30 {Type::getInt32Ty(*Context)}, false),
examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp 733 return TmpB.CreateAlloca(Type::getDoubleTy(*TheContext), nullptr, VarName);
801 return Builder->CreateUIToFP(L, Type::getDoubleTy(*TheContext), "booltmp");
880 PHINode *PN = Builder->CreatePHI(Type::getDoubleTy(*TheContext), 2, "iftmp");
984 return Constant::getNullValue(Type::getDoubleTy(*TheContext));
1037 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(*TheContext));
1037 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(*TheContext));
1039 FunctionType::get(Type::getDoubleTy(*TheContext), Doubles, false);
examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp 733 return TmpB.CreateAlloca(Type::getDoubleTy(*TheContext), nullptr, VarName);
801 return Builder->CreateUIToFP(L, Type::getDoubleTy(*TheContext), "booltmp");
880 PHINode *PN = Builder->CreatePHI(Type::getDoubleTy(*TheContext), 2, "iftmp");
984 return Constant::getNullValue(Type::getDoubleTy(*TheContext));
1037 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(*TheContext));
1037 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(*TheContext));
1039 FunctionType::get(Type::getDoubleTy(*TheContext), Doubles, false);
examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp 732 return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), nullptr, VarName);
800 return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp");
879 PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp");
983 return Constant::getNullValue(Type::getDoubleTy(TheContext));
1036 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
1036 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
1038 FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp 718 return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), nullptr, VarName);
786 return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp");
865 PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp");
969 return Constant::getNullValue(Type::getDoubleTy(TheContext));
1022 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
1022 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
1024 FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/BuildingAJIT/Chapter5/toy.cpp 742 return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), nullptr, VarName);
810 return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp");
889 PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp");
993 return Constant::getNullValue(Type::getDoubleTy(TheContext));
1046 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
1046 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
1048 FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/Chapter3/toy.cpp 440 return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp");
468 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
468 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
470 FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/Chapter4/toy.cpp 468 return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp");
496 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
496 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
498 FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/Chapter5/toy.cpp 595 return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp");
666 PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp");
708 Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, VarName);
765 return Constant::getNullValue(Type::getDoubleTy(TheContext));
770 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
770 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
772 FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/Chapter6/toy.cpp 699 return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp");
778 PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp");
820 Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, VarName);
877 return Constant::getNullValue(Type::getDoubleTy(TheContext));
882 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
882 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
884 FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/Chapter7/toy.cpp 738 return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), nullptr, VarName);
806 return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp");
885 PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp");
989 return Constant::getNullValue(Type::getDoubleTy(TheContext));
1042 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
1042 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
1044 FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/Chapter8/toy.cpp 737 return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), nullptr, VarName);
805 return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp");
884 PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp");
988 return Constant::getNullValue(Type::getDoubleTy(TheContext));
1041 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
1041 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
1043 FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/Chapter9/toy.cpp 890 return TmpB.CreateAlloca(Type::getDoubleTy(TheContext), nullptr,
964 return Builder.CreateUIToFP(L, Type::getDoubleTy(TheContext), "booltmp");
1047 PHINode *PN = Builder.CreatePHI(Type::getDoubleTy(TheContext), 2, "iftmp");
1153 return Constant::getNullValue(Type::getDoubleTy(TheContext));
1208 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
1208 std::vector<Type *> Doubles(Args.size(), Type::getDoubleTy(TheContext));
1210 FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/ModuleMaker/ModuleMaker.cpp 39 FunctionType::get(Type::getInt32Ty(Context), /*not vararg*/false);
50 Value *Two = ConstantInt::get(Type::getInt32Ty(Context), 2);
51 Value *Three = ConstantInt::get(Type::getInt32Ty(Context), 3);
examples/ParallelJIT/ParallelJIT.cpp 54 Function::Create(FunctionType::get(Type::getInt32Ty(Context),
55 {Type::getInt32Ty(Context)}, false),
63 Value *One = ConstantInt::get(Type::getInt32Ty(Context), 1);
84 FunctionType *FibFTy = FunctionType::get(Type::getInt32Ty(Context),
85 {Type::getInt32Ty(Context)}, false);
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 4 llvm::Type * Param0;
106 llvm::Type * Param1;
107 llvm::Type * Param2;
365 llvm::Type * Param0;
367 llvm::Type * Param2;
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)
127 ArrayRef(const std::vector<U *, A> &Vec,
129 std::is_convertible<U *const *, T const *>::value>::type* = 0)
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;
1014 std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;
1014 std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;
1014 std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;
include/llvm/Analysis/CmpInstAnalysis.h 54 Constant *getPredForICmpCode(unsigned Code, bool Sign, Type *OpTy,
include/llvm/Analysis/ConstantFolding.h 94 Constant *ConstantFoldCastOperand(unsigned Opcode, Constant *C, Type *DestTy,
130 Constant *ConstantFoldLoadFromConstPtr(Constant *C, Type *Ty, const DataLayout &DL);
157 Constant *ConstantFoldLoadThroughBitcast(Constant *C, Type *DestTy,
include/llvm/Analysis/DependenceAnalysis.h 579 const SCEV *collectUpperBound(const Loop *l, Type *T) const;
584 const SCEVConstant *collectConstantUpperBound(const Loop *l, Type *T) const;
include/llvm/Analysis/IVDescriptors.h 93 Instruction *UAI, Type *RT, bool Signed,
160 static Constant *getRecurrenceIdentity(RecurrenceKind K, Type *Tp);
227 Type *getRecurrenceType() { return RecurrenceType; }
252 Type *RecurrenceType = nullptr;
include/llvm/Analysis/InstructionSimplify.h 209 Value *SimplifyGEPInst(Type *SrcTy, ArrayRef<Value *> Ops,
229 Value *SimplifyCastInst(unsigned CastOpc, Value *Op, Type *Ty,
234 Type *RetTy, const SimplifyQuery &Q);
include/llvm/Analysis/Loads.h 30 bool isDereferenceablePointer(const Value *V, Type *Ty,
39 bool isDereferenceableAndAlignedPointer(const Value *V, Type *Ty,
86 bool isSafeToLoadUnconditionally(Value *V, Type *Ty, MaybeAlign Alignment,
150 Value *FindAvailablePtrLoadStore(Value *Ptr, Type *AccessTy, bool AtLeastAtomic,
include/llvm/Analysis/MemoryBuiltins.h 140 Type *getMallocAllocatedType(const CallInst *CI, const TargetLibraryInfo *TLI);
include/llvm/Analysis/MemorySSA.h 220 : DerivedUser(Type::getVoidTy(C), Vty, nullptr, NumOperands, DeleteValue),
include/llvm/Analysis/ScalarEvolution.h 130 Type *getType() const;
485 bool isSCEVable(Type *Ty) const;
489 uint64_t getTypeSizeInBits(Type *Ty) const;
494 Type *getEffectiveSCEVType(Type *Ty) const;
494 Type *getEffectiveSCEVType(Type *Ty) const;
497 Type *getWiderType(Type *Ty1, Type *Ty2) const;
497 Type *getWiderType(Type *Ty1, Type *Ty2) const;
497 Type *getWiderType(Type *Ty1, Type *Ty2) const;
512 const SCEV *getConstant(Type *Ty, uint64_t V, bool isSigned = false);
513 const SCEV *getTruncateExpr(const SCEV *Op, Type *Ty, unsigned Depth = 0);
514 const SCEV *getZeroExtendExpr(const SCEV *Op, Type *Ty, unsigned Depth = 0);
515 const SCEV *getSignExtendExpr(const SCEV *Op, Type *Ty, unsigned Depth = 0);
516 const SCEV *getAnyExtendExpr(const SCEV *Op, Type *Ty);
588 const SCEV *getZero(Type *Ty) { return getConstant(Ty, 0); }
591 const SCEV *getOne(Type *Ty) { return getConstant(Ty, 1); }
594 const SCEV *getSizeOfExpr(Type *IntTy, Type *AllocTy);
594 const SCEV *getSizeOfExpr(Type *IntTy, Type *AllocTy);
597 const SCEV *getOffsetOfExpr(Type *IntTy, StructType *STy, unsigned FieldNo);
613 const SCEV *getTruncateOrZeroExtend(const SCEV *V, Type *Ty,
618 const SCEV *getTruncateOrSignExtend(const SCEV *V, Type *Ty,
624 const SCEV *getNoopOrZeroExtend(const SCEV *V, Type *Ty);
629 const SCEV *getNoopOrSignExtend(const SCEV *V, Type *Ty);
634 const SCEV *getNoopOrAnyExtend(const SCEV *V, Type *Ty);
638 const SCEV *getTruncateOrNoop(const SCEV *V, Type *Ty);
include/llvm/Analysis/ScalarEvolutionExpander.h 190 PHINode *getOrInsertCanonicalInductionVariable(const Loop *L, Type *Ty);
207 Value *expandCodeFor(const SCEV *SH, Type *Ty, Instruction *I);
213 Value *expandCodeFor(const SCEV *SH, Type *Ty = nullptr);
338 Value *ReuseOrCreateCast(Value *V, Type *Ty,
344 Value *InsertNoopCastOfTo(Value *V, Type *Ty);
350 PointerType *PTy, Type *Ty, Value *V);
351 Value *expandAddToGEP(const SCEV *Op, PointerType *PTy, Type *Ty, Value *V);
401 Type *ExpandTy,
402 Type *IntTy,
403 Type *&TruncTy,
406 Type *ExpandTy, Type *IntTy, bool useSubtract);
406 Type *ExpandTy, Type *IntTy, bool useSubtract);
include/llvm/Analysis/ScalarEvolutionExpressions.h 59 Type *getType() const { return V->getType(); }
78 Type *Ty;
81 unsigned SCEVTy, const SCEV *op, Type *ty);
85 Type *getType() const { return Ty; }
101 const SCEV *op, Type *ty);
116 const SCEV *op, Type *ty);
131 const SCEV *op, Type *ty);
173 Type *getType() const { return getOperand(0)->getType(); }
230 Type *getType() const {
273 Type *getType() const {
496 bool isSizeOf(Type *&AllocTy) const;
497 bool isAlignOf(Type *&AllocTy) const;
498 bool isOffsetOf(Type *&STy, Constant *&FieldNo) const;
501 Type *getType() const { return getValPtr()->getType(); }
include/llvm/Analysis/SparsePropagation.h 103 virtual Value *GetValueFromLatticeVal(LatticeVal LV, Type *Ty = nullptr) {
include/llvm/Analysis/TargetFolder.h 135 Constant *CreateGetElementPtr(Type *Ty, Constant *C,
139 Constant *CreateGetElementPtr(Type *Ty, Constant *C, Constant *Idx) const {
145 Constant *CreateGetElementPtr(Type *Ty, Constant *C,
150 Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
154 Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
161 Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
171 Type *DestTy) const {
176 Constant *CreateIntCast(Constant *C, Type *DestTy,
182 Constant *CreatePointerCast(Constant *C, Type *DestTy) const {
187 Constant *CreateFPCast(Constant *C, Type *DestTy) const {
192 Constant *CreateBitCast(Constant *C, Type *DestTy) const {
195 Constant *CreateIntToPtr(Constant *C, Type *DestTy) const {
198 Constant *CreatePtrToInt(Constant *C, Type *DestTy) const {
201 Constant *CreateZExtOrBitCast(Constant *C, Type *DestTy) const {
206 Constant *CreateSExtOrBitCast(Constant *C, Type *DestTy) const {
211 Constant *CreateTruncOrBitCast(Constant *C, Type *DestTy) const {
218 Type *DestTy) const {
include/llvm/Analysis/TargetTransformInfo.h 216 int getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy = nullptr) const;
216 int getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy = nullptr) const;
223 int getGEPCost(Type *PointeeType, const Value *Ptr,
281 int getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
282 ArrayRef<Type *> ParamTys,
288 int getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
549 bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
578 bool isLegalMaskedStore(Type *DataType, MaybeAlign Alignment) const;
580 bool isLegalMaskedLoad(Type *DataType, MaybeAlign Alignment) const;
583 bool isLegalNTStore(Type *DataType, Align Alignment) const;
585 bool isLegalNTLoad(Type *DataType, Align Alignment) const;
588 bool isLegalMaskedScatter(Type *DataType) const;
590 bool isLegalMaskedGather(Type *DataType) const;
593 bool isLegalMaskedCompressStore(Type *DataType) const;
595 bool isLegalMaskedExpandLoad(Type *DataType) const;
602 bool hasDivRemOp(Type *DataType, bool IsSigned) const;
620 int getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
633 bool isTruncateFree(Type *Ty1, Type *Ty2) const;
633 bool isTruncateFree(Type *Ty1, Type *Ty2) const;
642 bool isTypeLegal(Type *Ty) const;
656 unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) const;
726 bool haveFastSqrt(Type *Ty) const;
732 bool isFCmpOrdCheaperThanFCmpZero(Type *Ty) const;
736 int getFPOpCost(Type *Ty) const;
740 int getIntImmCost(const APInt &Imm, Type *Ty) const;
746 Type *Ty) const;
748 Type *Ty) const;
758 Type *Ty) const;
804 unsigned getRegisterClassForType(bool Vector, Type *Ty = nullptr) const;
893 unsigned Opcode, Type *Ty, OperandValueKind Opd1Info = OK_AnyValue,
904 int getShuffleCost(ShuffleKind Kind, Type *Tp, int Index = 0,
905 Type *SubTp = nullptr) const;
910 int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
910 int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
915 int getExtractWithExtendCost(unsigned Opcode, Type *Dst, VectorType *VecTy,
925 int getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
926 Type *CondTy = nullptr, const Instruction *I = nullptr) const;
930 int getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index = -1) const;
933 int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
938 int getMaskedMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
948 int getGatherScatterOpCost(unsigned Opcode, Type *DataTy, Value *Ptr,
961 int getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy, unsigned Factor,
980 int getArithmeticReductionCost(unsigned Opcode, Type *Ty,
982 int getMinMaxReductionCost(Type *Ty, Type *CondTy, bool IsPairwiseForm,
982 int getMinMaxReductionCost(Type *Ty, Type *CondTy, bool IsPairwiseForm,
988 int getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
995 int getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
996 ArrayRef<Type *> Tys, FastMathFlags FMF,
1000 int getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys) const;
1000 int getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys) const;
1004 unsigned getNumberOfParts(Type *Tp) const;
1013 int getAddressComputationCost(Type *Ty, ScalarEvolution *SE = nullptr,
1021 unsigned getCostOfKeepingLiveOverCall(ArrayRef<Type *> Tys) const;
1038 Type *ExpectedType) const;
1041 Type *getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length,
1050 void getMemcpyLoopResidualLoweringType(SmallVectorImpl<Type *> &OpsOut,
1079 bool isIndexedLoadLegal(enum MemIndexedMode Mode, Type *Ty) const;
1082 bool isIndexedStoreLegal(enum MemIndexedMode Mode, Type *Ty) const;
1126 bool useReductionIntrinsic(unsigned Opcode, Type *Ty,
1163 virtual int getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) = 0;
1163 virtual int getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) = 0;
1164 virtual int getGEPCost(Type *PointeeType, const Value *Ptr,
1173 virtual int getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
1174 ArrayRef<Type *> ParamTys, const User *U) = 0;
1175 virtual int getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
1200 virtual bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV,
1213 virtual bool isLegalMaskedStore(Type *DataType, MaybeAlign Alignment) = 0;
1214 virtual bool isLegalMaskedLoad(Type *DataType, MaybeAlign Alignment) = 0;
1215 virtual bool isLegalNTStore(Type *DataType, Align Alignment) = 0;
1216 virtual bool isLegalNTLoad(Type *DataType, Align Alignment) = 0;
1217 virtual bool isLegalMaskedScatter(Type *DataType) = 0;
1218 virtual bool isLegalMaskedGather(Type *DataType) = 0;
1219 virtual bool isLegalMaskedCompressStore(Type *DataType) = 0;
1220 virtual bool isLegalMaskedExpandLoad(Type *DataType) = 0;
1221 virtual bool hasDivRemOp(Type *DataType, bool IsSigned) = 0;
1224 virtual int getScalingFactorCost(Type *Ty, GlobalValue *BaseGV,
1228 virtual bool isTruncateFree(Type *Ty1, Type *Ty2) = 0;
1228 virtual bool isTruncateFree(Type *Ty1, Type *Ty2) = 0;
1231 virtual bool isTypeLegal(Type *Ty) = 0;
1236 getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) = 0;
1252 virtual bool haveFastSqrt(Type *Ty) = 0;
1253 virtual bool isFCmpOrdCheaperThanFCmpZero(Type *Ty) = 0;
1254 virtual int getFPOpCost(Type *Ty) = 0;
1256 Type *Ty) = 0;
1257 virtual int getIntImmCost(const APInt &Imm, Type *Ty) = 0;
1259 Type *Ty) = 0;
1261 Type *Ty) = 0;
1263 virtual unsigned getRegisterClassForType(bool Vector, Type *Ty = nullptr) const = 0;
1293 getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind Opd1Info,
1298 virtual int getShuffleCost(ShuffleKind Kind, Type *Tp, int Index,
1299 Type *SubTp) = 0;
1300 virtual int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
1300 virtual int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
1302 virtual int getExtractWithExtendCost(unsigned Opcode, Type *Dst,
1305 virtual int getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
1306 Type *CondTy, const Instruction *I) = 0;
1307 virtual int getVectorInstrCost(unsigned Opcode, Type *Val,
1309 virtual int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
1311 virtual int getMaskedMemoryOpCost(unsigned Opcode, Type *Src,
1314 virtual int getGatherScatterOpCost(unsigned Opcode, Type *DataTy,
1317 virtual int getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
1324 virtual int getArithmeticReductionCost(unsigned Opcode, Type *Ty,
1326 virtual int getMinMaxReductionCost(Type *Ty, Type *CondTy,
1326 virtual int getMinMaxReductionCost(Type *Ty, Type *CondTy,
1328 virtual int getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
1329 ArrayRef<Type *> Tys, FastMathFlags FMF,
1331 virtual int getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
1333 virtual int getCallInstrCost(Function *F, Type *RetTy,
1334 ArrayRef<Type *> Tys) = 0;
1335 virtual unsigned getNumberOfParts(Type *Tp) = 0;
1336 virtual int getAddressComputationCost(Type *Ty, ScalarEvolution *SE,
1338 virtual unsigned getCostOfKeepingLiveOverCall(ArrayRef<Type *> Tys) = 0;
1343 Type *ExpectedType) = 0;
1344 virtual Type *getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length,
1348 SmallVectorImpl<Type *> &OpsOut, LLVMContext &Context,
1355 virtual bool isIndexedLoadLegal(MemIndexedMode Mode, Type *Ty) const = 0;
1356 virtual bool isIndexedStoreLegal(MemIndexedMode Mode,Type *Ty) const = 0;
1372 virtual bool useReductionIntrinsic(unsigned Opcode, Type *Ty,
1391 int getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) override {
1391 int getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) override {
1394 int getGEPCost(Type *PointeeType, const Value *Ptr,
1417 int getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
1418 ArrayRef<Type *> ParamTys, const User *U = nullptr) override {
1421 int getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
1474 bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
1500 bool isLegalMaskedStore(Type *DataType, MaybeAlign Alignment) override {
1503 bool isLegalMaskedLoad(Type *DataType, MaybeAlign Alignment) override {
1506 bool isLegalNTStore(Type *DataType, Align Alignment) override {
1509 bool isLegalNTLoad(Type *DataType, Align Alignment) override {
1512 bool isLegalMaskedScatter(Type *DataType) override {
1515 bool isLegalMaskedGather(Type *DataType) override {
1518 bool isLegalMaskedCompressStore(Type *DataType) override {
1521 bool isLegalMaskedExpandLoad(Type *DataType) override {
1524 bool hasDivRemOp(Type *DataType, bool IsSigned) override {
1533 int getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
1542 bool isTruncateFree(Type *Ty1, Type *Ty2) override {
1542 bool isTruncateFree(Type *Ty1, Type *Ty2) override {
1549 bool isTypeLegal(Type *Ty) override { return Impl.isTypeLegal(Ty); }
1560 unsigned getScalarizationOverhead(Type *Ty, bool Insert,
1598 bool haveFastSqrt(Type *Ty) override { return Impl.haveFastSqrt(Ty); }
1600 bool isFCmpOrdCheaperThanFCmpZero(Type *Ty) override {
1604 int getFPOpCost(Type *Ty) override { return Impl.getFPOpCost(Ty); }
1607 Type *Ty) override {
1610 int getIntImmCost(const APInt &Imm, Type *Ty) override {
1614 Type *Ty) override {
1618 Type *Ty) override {
1624 unsigned getRegisterClassForType(bool Vector, Type *Ty = nullptr) const override {
1685 getArithmeticInstrCost(unsigned Opcode, Type *Ty, OperandValueKind Opd1Info,
1693 int getShuffleCost(ShuffleKind Kind, Type *Tp, int Index,
1694 Type *SubTp) override {
1697 int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
1697 int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
1701 int getExtractWithExtendCost(unsigned Opcode, Type *Dst, VectorType *VecTy,
1708 int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
1708 int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
1712 int getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index) override {
1715 int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
1719 int getMaskedMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
1723 int getGatherScatterOpCost(unsigned Opcode, Type *DataTy,
1729 int getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy, unsigned Factor,
1737 int getArithmeticReductionCost(unsigned Opcode, Type *Ty,
1741 int getMinMaxReductionCost(Type *Ty, Type *CondTy,
1741 int getMinMaxReductionCost(Type *Ty, Type *CondTy,
1745 int getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy, ArrayRef<Type *> Tys,
1745 int getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy, ArrayRef<Type *> Tys,
1750 int getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
1754 int getCallInstrCost(Function *F, Type *RetTy,
1755 ArrayRef<Type *> Tys) override {
1758 unsigned getNumberOfParts(Type *Tp) override {
1761 int getAddressComputationCost(Type *Ty, ScalarEvolution *SE,
1765 unsigned getCostOfKeepingLiveOverCall(ArrayRef<Type *> Tys) override {
1776 Type *ExpectedType) override {
1779 Type *getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length,
1784 void getMemcpyLoopResidualLoweringType(SmallVectorImpl<Type *> &OpsOut,
1801 bool isIndexedLoadLegal(MemIndexedMode Mode, Type *Ty) const override {
1804 bool isIndexedStoreLegal(MemIndexedMode Mode, Type *Ty) const override {
1838 bool useReductionIntrinsic(unsigned Opcode, Type *Ty,
include/llvm/Analysis/TargetTransformInfoImpl.h 47 unsigned getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) {
47 unsigned getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) {
105 int getGEPCost(Type *PointeeType, const Value *Ptr,
219 bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
246 bool isLegalMaskedStore(Type *DataType, MaybeAlign Alignment) { return false; }
248 bool isLegalMaskedLoad(Type *DataType, MaybeAlign Alignment) { return false; }
250 bool isLegalNTStore(Type *DataType, Align Alignment) {
257 bool isLegalNTLoad(Type *DataType, Align Alignment) {
264 bool isLegalMaskedScatter(Type *DataType) { return false; }
266 bool isLegalMaskedGather(Type *DataType) { return false; }
268 bool isLegalMaskedCompressStore(Type *DataType) { return false; }
270 bool isLegalMaskedExpandLoad(Type *DataType) { return false; }
272 bool hasDivRemOp(Type *DataType, bool IsSigned) { return false; }
278 int getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
289 bool isTruncateFree(Type *Ty1, Type *Ty2) { return false; }
289 bool isTruncateFree(Type *Ty1, Type *Ty2) { return false; }
295 bool isTypeLegal(Type *Ty) { return false; }
302 unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) {
334 bool haveFastSqrt(Type *Ty) { return false; }
336 bool isFCmpOrdCheaperThanFCmpZero(Type *Ty) { return true; }
338 unsigned getFPOpCost(Type *Ty) { return TargetTransformInfo::TCC_Basic; }
341 Type *Ty) {
345 unsigned getIntImmCost(const APInt &Imm, Type *Ty) { return TTI::TCC_Basic; }
348 Type *Ty) {
353 Type *Ty) {
359 unsigned getRegisterClassForType(bool Vector, Type *Ty = nullptr) const {
417 unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty,
426 unsigned getShuffleCost(TTI::ShuffleKind Kind, Type *Ty, int Index,
427 Type *SubTp) {
431 unsigned getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
431 unsigned getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
434 unsigned getExtractWithExtendCost(unsigned Opcode, Type *Dst,
441 unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
441 unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
446 unsigned getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index) {
450 unsigned getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
455 unsigned getMaskedMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
460 unsigned getGatherScatterOpCost(unsigned Opcode, Type *DataTy, Value *Ptr,
466 unsigned getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
475 unsigned getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
476 ArrayRef<Type *> Tys, FastMathFlags FMF,
480 unsigned getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
485 unsigned getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys) {
485 unsigned getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys) {
489 unsigned getNumberOfParts(Type *Tp) { return 0; }
491 unsigned getAddressComputationCost(Type *Tp, ScalarEvolution *,
496 unsigned getArithmeticReductionCost(unsigned, Type *, bool) { return 1; }
498 unsigned getMinMaxReductionCost(Type *, Type *, bool, bool) { return 1; }
498 unsigned getMinMaxReductionCost(Type *, Type *, bool, bool) { return 1; }
500 unsigned getCostOfKeepingLiveOverCall(ArrayRef<Type *> Tys) { return 0; }
516 Type *ExpectedType) {
520 Type *getMemcpyLoopLoweringType(LLVMContext &Context, Value *Length,
522 return Type::getInt8Ty(Context);
525 void getMemcpyLoopResidualLoweringType(SmallVectorImpl<Type *> &OpsOut,
531 OpsOut.push_back(Type::getInt8Ty(Context));
550 bool isIndexedLoadLegal(TTI::MemIndexedMode Mode, Type *Ty,
555 bool isIndexedStoreLegal(TTI::MemIndexedMode Mode, Type *Ty,
590 bool useReductionIntrinsic(unsigned Opcode, Type *Ty,
709 SmallVector<Type *, 8> ParamTys(FTy->param_begin(), FTy->param_end());
731 int getGEPCost(Type *PointeeType, const Value *Ptr,
746 Type *TargetType = nullptr;
789 unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
790 ArrayRef<Type *> ParamTys, const User *U) {
833 unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
838 SmallVector<Type *, 8> ParamTys;
867 Type *FTy = CS.getCalledValue()->getType()->getPointerElementType();
896 Type *DstTy = I->getType();
include/llvm/Analysis/Utils/Local.h 31 Type *IntPtrTy = DL.getIntPtrType(GEP->getType());
include/llvm/Analysis/ValueLattice.h 293 Constant *getCompare(CmpInst::Predicate Pred, Type *Ty,
include/llvm/Analysis/VectorUtils.h 175 Value *getUniqueCastUse(Value *Ptr, Loop *Lp, Type *Ty);
include/llvm/AsmParser/Parser.h 191 Type *parseType(StringRef Asm, SMDiagnostic &Err, const Module &M,
201 Type *parseTypeAtBeginning(StringRef Asm, unsigned &Read, SMDiagnostic &Err,
include/llvm/AsmParser/SlotMapping.h 35 StringMap<Type *> NamedTypes;
36 std::map<unsigned, Type *> Types;
include/llvm/CodeGen/Analysis.h 54 unsigned ComputeLinearIndex(Type *Ty,
59 inline unsigned ComputeLinearIndex(Type *Ty,
72 void ComputeValueVTs(const TargetLowering &TLI, const DataLayout &DL, Type *Ty,
78 void ComputeValueVTs(const TargetLowering &TLI, const DataLayout &DL, Type *Ty,
91 void computeValueLLTs(const DataLayout &DL, Type &Ty,
include/llvm/CodeGen/BasicTTIImpl.h 84 unsigned getBroadcastShuffleOverhead(Type *Ty) {
101 unsigned getPermuteShuffleOverhead(Type *Ty) {
122 unsigned getExtractSubvectorOverhead(Type *Ty, int Index, Type *SubTy) {
122 unsigned getExtractSubvectorOverhead(Type *Ty, int Index, Type *SubTy) {
144 unsigned getInsertSubvectorOverhead(Type *Ty, int Index, Type *SubTy) {
144 unsigned getInsertSubvectorOverhead(Type *Ty, int Index, Type *SubTy) {
237 bool isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
248 bool isIndexedLoadLegal(TTI::MemIndexedMode M, Type *Ty,
254 bool isIndexedStoreLegal(TTI::MemIndexedMode M, Type *Ty,
264 int getScalingFactorCost(Type *Ty, GlobalValue *BaseGV, int64_t BaseOffset,
274 bool isTruncateFree(Type *Ty1, Type *Ty2) {
274 bool isTruncateFree(Type *Ty1, Type *Ty2) {
284 bool isTypeLegal(Type *Ty) {
289 int getGEPCost(Type *PointeeType, const Value *Ptr,
306 unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
311 unsigned getIntrinsicCost(Intrinsic::ID IID, Type *RetTy,
312 ArrayRef<Type *> ParamTys, const User *U) {
391 bool haveFastSqrt(Type *Ty) {
398 bool isFCmpOrdCheaperThanFCmpZero(Type *Ty) {
402 unsigned getFPOpCost(Type *Ty) {
412 unsigned getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) {
412 unsigned getOperationCost(unsigned Opcode, Type *Ty, Type *OpTy) {
560 unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) {
585 Type *VecTy = nullptr;
602 unsigned getScalarizationOverhead(Type *VecTy, ArrayRef<const Value *> Args) {
622 unsigned Opcode, Type *Ty,
668 unsigned getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index,
669 Type *SubTp) {
687 unsigned getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
687 unsigned getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
778 Type *SplitDst = VectorType::get(Dst->getVectorElementType(),
780 Type *SplitSrc = VectorType::get(Src->getVectorElementType(),
812 unsigned getExtractWithExtendCost(unsigned Opcode, Type *Dst,
825 unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
825 unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
865 unsigned getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index) {
872 unsigned getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
904 unsigned getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
1025 Type *I8Type = Type::getInt8Ty(VT->getContext());
1025 Type *I8Type = Type::getInt8Ty(VT->getContext());
1060 unsigned getIntrinsicInstrCost(Intrinsic::ID IID, Type *RetTy,
1070 SmallVector<Type *, 4> Types;
1072 Type *OpTy = Op->getType();
1153 Type *CondTy = RetTy->getWithNewBitWidth(1);
1169 Intrinsic::ID IID, Type *RetTy, ArrayRef<Type *> Tys, FastMathFlags FMF,
1169 Intrinsic::ID IID, Type *RetTy, ArrayRef<Type *> Tys, FastMathFlags FMF,
1180 Type *ScalarRetTy = RetTy;
1187 SmallVector<Type *, 4> ScalarTys;
1189 Type *Ty = Tys[i];
1327 Type *CondTy = RetTy->getWithNewBitWidth(1);
1329 Type *OpTy = StructType::create({RetTy, CondTy});
1347 Type *CondTy = RetTy->getWithNewBitWidth(1);
1349 Type *OpTy = StructType::create({RetTy, CondTy});
1364 Type *ExtTy = RetTy->getWithNewBitWidth(ExtSize);
1385 Type *SumTy = RetTy->getContainedType(0);
1386 Type *OverflowTy = RetTy->getContainedType(1);
1411 Type *SumTy = RetTy->getContainedType(0);
1412 Type *OverflowTy = RetTy->getContainedType(1);
1425 Type *MulTy = RetTy->getContainedType(0);
1426 Type *OverflowTy = RetTy->getContainedType(1);
1428 Type *ExtTy = MulTy->getWithNewBitWidth(ExtSize);
1511 SmallVector<Type *, 4> ScalarTys;
1513 Type *Ty = Tys[i];
1546 unsigned getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys) {
1546 unsigned getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys) {
1550 unsigned getNumberOfParts(Type *Tp) {
1555 unsigned getAddressComputationCost(Type *Ty, ScalarEvolution *,
1595 unsigned getArithmeticReductionCost(unsigned Opcode, Type *Ty,
1598 Type *ScalarTy = Ty->getVectorElementType();
1611 Type *SubTy = VectorType::get(ScalarTy, NumVecElts);
1645 unsigned getMinMaxReductionCost(Type *Ty, Type *CondTy, bool IsPairwise,
1645 unsigned getMinMaxReductionCost(Type *Ty, Type *CondTy, bool IsPairwise,
1648 Type *ScalarTy = Ty->getVectorElementType();
1649 Type *ScalarCondTy = CondTy->getVectorElementType();
1670 Type *SubTy = VectorType::get(ScalarTy, NumVecElts);
include/llvm/CodeGen/FastISel.h 71 Type *RetTy = nullptr;
104 CallLoweringInfo &setCallee(Type *ResultTy, FunctionType *FuncTy,
126 CallLoweringInfo &setCallee(Type *ResultTy, FunctionType *FuncTy,
150 CallLoweringInfo &setCallee(CallingConv::ID CC, Type *ResultTy,
162 CallingConv::ID CC, Type *ResultTy,
166 CallLoweringInfo &setCallee(CallingConv::ID CC, Type *ResultTy,
include/llvm/CodeGen/FunctionLoweringInfo.h 206 unsigned CreateRegs(Type *Ty, bool isDivergent = false);
include/llvm/CodeGen/GCStrategy.h 99 virtual Optional<bool> isGCManagedPointer(const Type *Ty) const {
include/llvm/CodeGen/GlobalISel/CallLowering.h 52 Type *Ty;
56 ArgInfo(ArrayRef<Register> Regs, Type *Ty,
194 Register packRegs(ArrayRef<Register> SrcRegs, Type *PackedTy,
202 void unpackRegs(ArrayRef<Register> DstRegs, Register SrcReg, Type *PackedTy,
include/llvm/CodeGen/GlobalISel/IRTranslator.h 140 DenseMap<const Type *, OffsetListT*> TypeToOffsets;
include/llvm/CodeGen/LowLevelType.h 27 LLT getLLTForType(Type &Ty, const DataLayout &DL);
include/llvm/CodeGen/MachineConstantPool.h 37 Type *Ty;
40 explicit MachineConstantPoolValue(Type *ty) : Ty(ty) {}
45 Type *getType() const { return Ty; }
100 Type *getType() const;
include/llvm/CodeGen/SelectionDAG.h 960 SDValue Size, Type *SizeTy, unsigned ElemSz,
966 SDValue Size, Type *SizeTy, unsigned ElemSz,
972 Type *SizeTy, unsigned ElemSz, bool isTailCall,
include/llvm/CodeGen/SelectionDAGNodes.h 1874 Type *getType() const;
include/llvm/CodeGen/StackProtector.h 94 bool ContainsProtectableArray(Type *Ty, bool &IsLarge, bool Strong = false,
include/llvm/CodeGen/TargetLowering.h 180 Type *Ty = nullptr;
193 Type *ByValType = nullptr;
632 virtual bool canCombineStoreAndExtract(Type *VectorTy, Value *Idx,
1237 EVT getValueType(const DataLayout &DL, Type *Ty,
1244 Type *EltTy = VTy->getElementType();
1257 EVT getMemValueType(const DataLayout &DL, Type *Ty,
1263 Type *Elm = VTy->getElementType();
1277 MVT getSimpleValueType(const DataLayout &DL, Type *Ty,
1285 virtual unsigned getByValTypeAlignment(Type *Ty, const DataLayout &DL) const;
1361 virtual Align getABIAlignmentForCallingConv(Type *ArgTy,
1697 Type *Ty) const;
2179 Type *&/*AccessTy*/) const {
2209 Type *Ty, unsigned AddrSpace,
2220 Type *Ty, unsigned AS = 0) const {
2253 virtual bool isVectorShiftByScalarCheap(Type *Ty) const {
2321 virtual bool isTruncateFree(Type *FromTy, Type *ToTy) const {
2321 virtual bool isTruncateFree(Type *FromTy, Type *ToTy) const {
2330 virtual bool allowTruncateForTailCall(Type *FromTy, Type *ToTy) const {
2330 virtual bool allowTruncateForTailCall(Type *FromTy, Type *ToTy) const {
2407 virtual bool isZExtFree(Type *FromTy, Type *ToTy) const {
2407 virtual bool isZExtFree(Type *FromTy, Type *ToTy) const {
2557 Type *Ty) const {
3436 Type *RetTy = nullptr;
3481 CallLoweringInfo &setLibCallee(CallingConv::ID CC, Type *ResultType,
3494 CallLoweringInfo &setCallee(CallingConv::ID CC, Type *ResultType,
3504 CallLoweringInfo &setCallee(Type *ResultType, FunctionType *FTy,
3720 functionArgumentNeedsConsecutiveRegisters(Type *Ty, CallingConv::ID CallConv,
4277 void GetReturnInfo(CallingConv::ID CC, Type *ReturnType, AttributeList attr,
include/llvm/CodeGen/ValueTypes.h 36 Type *LLVMTy = nullptr;
383 Type *getTypeForEVT(LLVMContext &Context) const;
388 static EVT getEVT(Type *Ty, bool HandleUnknown = false);
include/llvm/ExecutionEngine/ExecutionEngine.h 392 Type *Ty);
506 Type *Ty);
include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h 666 auto *Ty = A->getValueType();
include/llvm/FuzzMutate/IRMutator.h 57 using TypeGetter = std::function<Type *(LLVMContext &)>;
include/llvm/FuzzMutate/OpDescriptor.h 32 void makeConstantsWithType(Type *T, std::vector<Constant *> &Cs);
33 std::vector<Constant *> makeConstantsWithType(Type *T);
52 ArrayRef<Value *> Cur, ArrayRef<Type *> BaseTypes)>;
65 for (Type *T : BaseTypes) {
83 ArrayRef<Type *> BaseTypes) {
95 static inline SourcePred onlyType(Type *Only) {
136 for (Type *T : Ts)
155 for (Type *T : Ts)
include/llvm/FuzzMutate/RandomIRBuilder.h 27 SmallVector<Type *, 16> KnownTypes;
29 RandomIRBuilder(int Seed, ArrayRef<Type *> AllowedTypes)
55 Type *chooseType(LLVMContext &Context, ArrayRef<Value *> Srcs,
include/llvm/IR/Argument.h 38 explicit Argument(Type *Ty, const Twine &Name = "", Function *F = nullptr,
82 Type *getParamByValType() const;
include/llvm/IR/Attributes.h 94 static Attribute get(LLVMContext &Context, AttrKind Kind, Type *Ty);
107 static Attribute getWithByValType(LLVMContext &Context, Type *Ty);
150 Type *getValueAsType() const;
292 Type *getByValType() const;
613 Type *getParamByValType(unsigned ArgNo) const;
714 Type *ByValType = nullptr;
791 Type *getByValType() const { return ByValType; }
834 AttrBuilder &addByValAttr(Type *Ty);
874 AttrBuilder typeIncompatible(Type *Ty);
include/llvm/IR/AutoUpgrade.h 70 Instruction *UpgradeBitCastInst(unsigned Opc, Value *V, Type *DestTy,
76 Value *UpgradeBitCastExpr(unsigned Opc, Constant *C, Type *DestTy);
include/llvm/IR/CallSite.h 272 Type *getType() const { return (*this)->getType(); }
419 Type *getParamByValType(unsigned ArgNo) const {
include/llvm/IR/Constant.h 43 Constant(Type *ty, ValueTy vty, Use *Ops, unsigned NumOps)
166 static Constant *getNullValue(Type* Ty);
171 static Constant *getAllOnesValue(Type* Ty);
175 static Constant *getIntegerValue(Type *Ty, const APInt &V);
include/llvm/IR/ConstantFolder.h 145 Constant *CreateGetElementPtr(Type *Ty, Constant *C,
150 Constant *CreateGetElementPtr(Type *Ty, Constant *C, Constant *Idx) const {
157 Constant *CreateGetElementPtr(Type *Ty, Constant *C,
162 Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
167 Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
175 Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
185 Type *DestTy) const {
189 Constant *CreatePointerCast(Constant *C, Type *DestTy) const {
194 Type *DestTy) const {
198 Constant *CreateIntCast(Constant *C, Type *DestTy,
203 Constant *CreateFPCast(Constant *C, Type *DestTy) const {
207 Constant *CreateBitCast(Constant *C, Type *DestTy) const {
211 Constant *CreateIntToPtr(Constant *C, Type *DestTy) const {
215 Constant *CreatePtrToInt(Constant *C, Type *DestTy) const {
219 Constant *CreateZExtOrBitCast(Constant *C, Type *DestTy) const {
223 Constant *CreateSExtOrBitCast(Constant *C, Type *DestTy) const {
227 Constant *CreateTruncOrBitCast(Constant *C, Type *DestTy) const {
include/llvm/IR/Constants.h 65 explicit ConstantData(Type *Ty, ValueTy VT) : Constant(Ty, VT, nullptr, 0) {}
97 static Constant *getTrue(Type *Ty);
98 static Constant *getFalse(Type *Ty);
102 static Constant *get(Type *Ty, uint64_t V, bool isSigned = false);
119 static Constant *getSigned(Type *Ty, int64_t V);
132 static Constant *get(Type* Ty, const APInt& V);
184 static bool isValueValidForType(Type *Ty, uint64_t V);
185 static bool isValueValidForType(Type *Ty, int64_t V);
268 ConstantFP(Type *Ty, const APFloat& V);
278 static Constant *getZeroValueForNegation(Type *Ty);
284 static Constant *get(Type* Ty, double V);
288 static Constant *get(Type *Ty, const APFloat &V);
290 static Constant *get(Type* Ty, StringRef Str);
292 static Constant *getNaN(Type *Ty, bool Negative = false, uint64_t Payload = 0);
293 static Constant *getQNaN(Type *Ty, bool Negative = false,
295 static Constant *getSNaN(Type *Ty, bool Negative = false,
297 static Constant *getNegativeZero(Type *Ty);
298 static Constant *getInfinity(Type *Ty, bool Negative = false);
301 static bool isValueValidForType(Type *Ty, const APFloat &V);
343 explicit ConstantAggregateZero(Type *Ty)
351 static ConstantAggregateZero *get(Type *Ty);
590 explicit ConstantDataSequential(Type *ty, ValueTy VT, const char *Data)
594 static Constant *getImpl(StringRef Bytes, Type *Ty);
603 static bool isElementTypeCompatible(Type *Ty);
637 Type *getElementType() const;
692 explicit ConstantDataArray(Type *ty, const char *Data)
705 Type::getScalarTy<ElementTy>(Context));
721 static Constant *getRaw(StringRef Data, uint64_t NumElements, Type *ElementTy) {
722 Type *Ty = ArrayType::get(ElementTy, NumElements);
764 explicit ConstantDataVector(Type *ty, const char *Data)
821 : ConstantData(Type::getTokenTy(Context), ConstantTokenNoneVal) {}
896 ConstantExpr(Type *ty, unsigned Opcode, Use *Ops, unsigned NumOps)
910 static Constant *getAlignOf(Type *Ty);
916 static Constant *getSizeOf(Type *Ty);
926 static Constant *getOffsetOf(Type *Ty, Constant *FieldNo);
953 static Constant *getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced = false);
954 static Constant *getSExt(Constant *C, Type *Ty, bool OnlyIfReduced = false);
955 static Constant *getZExt(Constant *C, Type *Ty, bool OnlyIfReduced = false);
956 static Constant *getFPTrunc(Constant *C, Type *Ty,
958 static Constant *getFPExtend(Constant *C, Type *Ty,
960 static Constant *getUIToFP(Constant *C, Type *Ty, bool OnlyIfReduced = false);
961 static Constant *getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced = false);
962 static Constant *getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced = false);
963 static Constant *getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced = false);
964 static Constant *getPtrToInt(Constant *C, Type *Ty,
966 static Constant *getIntToPtr(Constant *C, Type *Ty,
968 static Constant *getBitCast(Constant *C, Type *Ty,
970 static Constant *getAddrSpaceCast(Constant *C, Type *Ty,
1031 static Constant *getBinOpIdentity(unsigned Opcode, Type *Ty,
1038 static Constant *getBinOpAbsorber(unsigned Opcode, Type *Ty);
1049 static Constant *getCast(unsigned ops, Constant *C, Type *Ty,
1055 Type *Ty ///< The type to zext or bitcast C to
1061 Type *Ty ///< The type to sext or bitcast C to
1067 Type *Ty ///< The type to trunc or bitcast C to
1074 Type *Ty ///< The type to which cast should be made
1081 Type *Ty ///< The type to bitcast or addrspacecast C to
1087 Type *Ty, ///< The integer type to cast to
1094 Type *Ty ///< The integer type to cast to
1118 Type *OnlyIfReducedTy = nullptr);
1125 Type *OnlyIfReducedTy = nullptr);
1132 unsigned Flags = 0, Type *OnlyIfReducedTy = nullptr);
1153 static Constant *getGetElementPtr(Type *Ty, Constant *C,
1157 Type *OnlyIfReducedTy = nullptr) {
1162 static Constant *getGetElementPtr(Type *Ty, Constant *C, Constant *Idx,
1165 Type *OnlyIfReducedTy = nullptr) {
1172 static Constant *getGetElementPtr(Type *Ty, Constant *C,
1176 Type *OnlyIfReducedTy = nullptr);
1180 static Constant *getInBoundsGetElementPtr(Type *Ty, Constant *C,
1184 static Constant *getInBoundsGetElementPtr(Type *Ty, Constant *C,
1191 static Constant *getInBoundsGetElementPtr(Type *Ty, Constant *C,
1197 Type *OnlyIfReducedTy = nullptr);
1199 Type *OnlyIfReducedTy = nullptr);
1201 Type *OnlyIfReducedTy = nullptr);
1203 Type *OnlyIfReducedTy = nullptr);
1206 Type *OnlyIfReducedTy = nullptr);
1242 Constant *getWithOperands(ArrayRef<Constant *> Ops, Type *Ty,
1244 Type *SrcTy = nullptr) const;
1288 explicit UndefValue(Type *T) : ConstantData(T, UndefValueVal) {}
1296 static UndefValue *get(Type *T);
include/llvm/IR/DataLayout.h 179 bool ABIAlign, Type *Ty) const;
184 Align getAlignment(Type *Ty, bool abi_or_pref) const;
384 bool isNonIntegralPointerType(Type *Ty) const {
411 unsigned getPointerTypeSizeInBits(Type *) const;
415 unsigned getIndexTypeSizeInBits(Type *Ty) const;
417 unsigned getPointerTypeSize(Type *Ty) const {
445 TypeSize getTypeSizeInBits(Type *Ty) const;
454 TypeSize getTypeStoreSize(Type *Ty) const {
466 TypeSize getTypeStoreSizeInBits(Type *Ty) const {
474 bool typeSizeEqualsStoreSize(Type *Ty) const {
486 TypeSize getTypeAllocSize(Type *Ty) const {
499 TypeSize getTypeAllocSizeInBits(Type *Ty) const {
504 unsigned getABITypeAlignment(Type *Ty) const;
509 Type *Ty) const {
521 unsigned getPrefTypeAlignment(Type *Ty) const;
529 Type *getIntPtrType(Type *) const;
529 Type *getIntPtrType(Type *) const;
533 Type *getSmallestLegalIntType(LLVMContext &C, unsigned Width = 0) const;
536 Type *getLargestLegalIntType(LLVMContext &C) const {
538 return (LargestSize == 0) ? nullptr : Type::getIntNTy(C, LargestSize);
548 Type *getIndexType(Type *PtrTy) const;
548 Type *getIndexType(Type *PtrTy) const;
555 int64_t getIndexedOffsetInType(Type *ElemTy, ArrayRef<Value *> Indices) const;
624 inline TypeSize DataLayout::getTypeSizeInBits(Type *Ty) const {
627 case Type::LabelTyID:
629 case Type::PointerTyID:
631 case Type::ArrayTyID: {
636 case Type::StructTyID:
640 case Type::IntegerTyID:
642 case Type::HalfTyID:
644 case Type::FloatTyID:
646 case Type::DoubleTyID:
647 case Type::X86_MMXTyID:
649 case Type::PPC_FP128TyID:
650 case Type::FP128TyID:
654 case Type::X86_FP80TyID:
656 case Type::VectorTyID: {
include/llvm/IR/DerivedTypes.h 40 class IntegerType : public Type {
67 return Type::getIntNTy(getContext(), 2 * getScalarSizeInBits());
97 static bool classof(const Type *T) {
108 class FunctionType : public Type {
109 FunctionType(Type *Result, ArrayRef<Type*> Params, bool IsVarArgs);
109 FunctionType(Type *Result, ArrayRef<Type*> Params, bool IsVarArgs);
116 static FunctionType *get(Type *Result,
117 ArrayRef<Type*> Params, bool isVarArg);
120 static FunctionType *get(Type *Result, bool isVarArg);
123 static bool isValidReturnType(Type *RetTy);
126 static bool isValidArgumentType(Type *ArgTy);
129 Type *getReturnType() const { return ContainedTys[0]; }
131 using param_iterator = Type::subtype_iterator;
135 ArrayRef<Type *> params() const {
140 Type *getParamType(unsigned i) const { return ContainedTys[i+1]; }
147 static bool classof(const Type *T) {
151 static_assert(alignof(FunctionType) >= alignof(Type *),
158 Type *Type::getFunctionParamType(unsigned i) const {
199 class CompositeType : public Type {
205 Type *getTypeAtIndex(const Value *V) const;
206 Type *getTypeAtIndex(unsigned Idx) const;
211 static bool classof(const Type *T) {
263 static StructType *create(ArrayRef<Type *> Elements, StringRef Name,
265 static StructType *create(ArrayRef<Type *> Elements);
266 static StructType *create(LLVMContext &Context, ArrayRef<Type *> Elements,
268 static StructType *create(LLVMContext &Context, ArrayRef<Type *> Elements);
270 static typename std::enable_if<are_base_of<Type, Tys...>::value,
270 static typename std::enable_if<are_base_of<Type, Tys...>::value,
272 create(StringRef Name, Type *elt1, Tys *... elts) {
272 create(StringRef Name, Type *elt1, Tys *... elts) {
274 SmallVector<llvm::Type *, 8> StructFields({elt1, elts...});
279 static StructType *get(LLVMContext &Context, ArrayRef<Type*> Elements,
289 static typename std::enable_if<are_base_of<Type, Tys...>::value,
289 static typename std::enable_if<are_base_of<Type, Tys...>::value,
291 get(Type *elt1, Tys *... elts) {
291 get(Type *elt1, Tys *... elts) {
294 SmallVector<llvm::Type *, 8> StructFields({elt1, elts...});
309 bool isSized(SmallPtrSetImpl<Type *> *Visited = nullptr) const;
324 void setBody(ArrayRef<Type*> Elements, bool isPacked = false);
327 typename std::enable_if<are_base_of<Type, Tys...>::value, void>::type
328 setBody(Type *elt1, Tys *... elts) {
330 SmallVector<llvm::Type *, 8> StructFields({elt1, elts...});
335 static bool isValidElementType(Type *ElemTy);
338 using element_iterator = Type::subtype_iterator;
342 ArrayRef<Type *> const elements() const {
351 Type *getElementType(unsigned N) const {
357 static bool classof(const Type *T) {
370 Type *Type::getStructElementType(unsigned N) const {
381 Type *ContainedType; ///< Storage for the single contained type.
385 SequentialType(TypeID TID, Type *ElType, uint64_t NumElements)
399 Type *getElementType() const { return ContainedType; }
402 static bool classof(const Type *T) {
409 ArrayType(Type *ElType, uint64_t NumEl);
416 static ArrayType *get(Type *ElementType, uint64_t NumElements);
419 static bool isValidElementType(Type *ElemTy);
422 static bool classof(const Type *T) {
446 VectorType(Type *ElType, unsigned NumEl, bool Scalable = false);
447 VectorType(Type *ElType, ElementCount EC);
459 static VectorType *get(Type *ElementType, ElementCount EC);
460 static VectorType *get(Type *ElementType, unsigned NumElements,
471 Type *EltTy = IntegerType::get(VTy->getContext(), EltBits);
487 Type *EltTy;
491 EltTy = Type::getFloatTy(VTy->getContext());
494 EltTy = Type::getHalfTy(VTy->getContext());
538 static bool isValidElementType(Type *ElemTy);
561 static bool classof(const Type *T) {
579 class PointerType : public Type {
580 explicit PointerType(Type *ElType, unsigned AddrSpace);
582 Type *PointeeTy;
590 static PointerType *get(Type *ElementType, unsigned AddressSpace);
594 static PointerType *getUnqual(Type *ElementType) {
598 Type *getElementType() const { return PointeeTy; }
601 static bool isValidElementType(Type *ElemTy);
604 static bool isLoadableOrStorableType(Type *ElemTy);
610 static bool classof(const Type *T) {
615 Type *Type::getExtendedType() const {
625 Type *Type::getWithNewBitWidth(unsigned NewBitWidth) const {
629 Type *NewType = getIntNTy(getContext(), NewBitWidth);
include/llvm/IR/DerivedUser.h 37 DerivedUser(Type *Ty, unsigned VK, Use *U, unsigned NumOps,
include/llvm/IR/DiagnosticInfo.h 426 Argument(StringRef Key, const Type *T);
include/llvm/IR/Function.h 168 Type *getReturnType() const { return getFunctionType()->getReturnType(); }
445 Type *getParamByValType(unsigned ArgNo) const {
446 Type *Ty = AttributeSets.getParamByValType(ArgNo);
include/llvm/IR/GetElementPtrTypeIterator.h 32 : public std::iterator<std::forward_iterator_tag, Type *, ptrdiff_t> {
33 using super = std::iterator<std::forward_iterator_tag, Type *, ptrdiff_t>;
36 PointerUnion<StructType *, Type *> CurTy;
43 static generic_gep_type_iterator begin(Type *Ty, ItTy It) {
68 Type *getIndexedType() const {
69 if (auto *T = CurTy.dyn_cast<Type *>())
69 if (auto *T = CurTy.dyn_cast<Type *>())
77 Type *Ty = getIndexedType();
107 bool isSequential() const { return CurTy.is<Type *>(); }
151 gep_type_begin(Type *Op0, ArrayRef<T> A) {
157 gep_type_end(Type * /*Op0*/, ArrayRef<T> A) {
include/llvm/IR/GlobalAlias.h 31 GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage,
40 static GlobalAlias *create(Type *Ty, unsigned AddressSpace,
45 static GlobalAlias *create(Type *Ty, unsigned AddressSpace,
50 static GlobalAlias *create(Type *Ty, unsigned AddressSpace,
include/llvm/IR/GlobalIFunc.h 36 GlobalIFunc(Type *Ty, unsigned AddressSpace, LinkageTypes Linkage,
45 static GlobalIFunc *create(Type *Ty, unsigned AddressSpace,
include/llvm/IR/GlobalIndirectSymbol.h 30 GlobalIndirectSymbol(Type *Ty, ValueTy VTy, unsigned AddressSpace,
include/llvm/IR/GlobalObject.h 46 GlobalObject(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
include/llvm/IR/GlobalValue.h 76 GlobalValue(Type *Ty, ValueTy VTy, Use *Ops, unsigned NumOps,
88 Type *ValueType;
279 Type *getValueType() const { return ValueType; }
include/llvm/IR/GlobalVariable.h 54 GlobalVariable(Type *Ty, bool isConstant, LinkageTypes Linkage,
60 GlobalVariable(Module &M, Type *Ty, bool isConstant,
include/llvm/IR/IRBuilder.h 170 Type *getCurrentFunctionReturnType() const;
384 return Type::getInt1Ty(Context);
389 return Type::getInt8Ty(Context);
394 return Type::getInt16Ty(Context);
399 return Type::getInt32Ty(Context);
404 return Type::getInt64Ty(Context);
408 IntegerType *getInt128Ty() { return Type::getInt128Ty(Context); }
412 return Type::getIntNTy(Context, N);
416 Type *getHalfTy() {
417 return Type::getHalfTy(Context);
421 Type *getFloatTy() {
422 return Type::getFloatTy(Context);
426 Type *getDoubleTy() {
427 return Type::getDoubleTy(Context);
431 Type *getVoidTy() {
432 return Type::getVoidTy(Context);
437 return Type::getInt8PtrTy(Context, AddrSpace);
718 Type *ResultType,
726 Type *ResultType,
744 CallInst *CreateIntrinsic(Intrinsic::ID ID, ArrayRef<Type *> Types,
772 ArrayRef<Type *> OverloadedTypes,
1578 AllocaInst *CreateAlloca(Type *Ty, unsigned AddrSpace,
1583 AllocaInst *CreateAlloca(Type *Ty, Value *ArraySize = nullptr,
1591 LoadInst *CreateLoad(Type *Ty, Value *Ptr, const char *Name) {
1595 LoadInst *CreateLoad(Type *Ty, Value *Ptr, const Twine &Name = "") {
1599 LoadInst *CreateLoad(Type *Ty, Value *Ptr, bool isVolatile,
1627 LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, unsigned Align,
1633 LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, unsigned Align,
1639 LoadInst *CreateAlignedLoad(Type *Ty, Value *Ptr, unsigned Align,
1697 Value *CreateGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
1716 Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, ArrayRef<Value *> IdxList,
1735 Value *CreateGEP(Type *Ty, Value *Ptr, Value *Idx, const Twine &Name = "") {
1742 Value *CreateInBoundsGEP(Type *Ty, Value *Ptr, Value *Idx,
1754 Value *CreateConstGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1756 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1764 Value *CreateConstInBoundsGEP1_32(Type *Ty, Value *Ptr, unsigned Idx0,
1766 Value *Idx = ConstantInt::get(Type::getInt32Ty(Context), Idx0);
1774 Value *CreateConstGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0, unsigned Idx1,
1777 ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1778 ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1787 Value *CreateConstInBoundsGEP2_32(Type *Ty, Value *Ptr, unsigned Idx0,
1790 ConstantInt::get(Type::getInt32Ty(Context), Idx0),
1791 ConstantInt::get(Type::getInt32Ty(Context), Idx1)
1800 Value *CreateConstGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1802 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1814 Value *CreateConstInBoundsGEP1_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1816 Value *Idx = ConstantInt::get(Type::getInt64Ty(Context), Idx0);
1829 Value *CreateConstGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0, uint64_t Idx1,
1832 ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1833 ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1847 Value *CreateConstInBoundsGEP2_64(Type *Ty, Value *Ptr, uint64_t Idx0,
1850 ConstantInt::get(Type::getInt64Ty(Context), Idx0),
1851 ConstantInt::get(Type::getInt64Ty(Context), Idx1)
1865 Value *CreateStructGEP(Type *Ty, Value *Ptr, unsigned Idx,
1879 Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
1889 Value *CreateTrunc(Value *V, Type *DestTy, const Twine &Name = "") {
1893 Value *CreateZExt(Value *V, Type *DestTy, const Twine &Name = "") {
1897 Value *CreateSExt(Value *V, Type *DestTy, const Twine &Name = "") {
1903 Value *CreateZExtOrTrunc(Value *V, Type *DestTy,
1908 Type *VTy = V->getType();
1918 Value *CreateSExtOrTrunc(Value *V, Type *DestTy,
1923 Type *VTy = V->getType();
1931 Value *CreateFPToUI(Value *V, Type *DestTy, const Twine &Name = "") {
1938 Value *CreateFPToSI(Value *V, Type *DestTy, const Twine &Name = "") {
1945 Value *CreateUIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
1949 Value *CreateSIToFP(Value *V, Type *DestTy, const Twine &Name = ""){
1953 Value *CreateFPTrunc(Value *V, Type *DestTy,
1962 Value *CreateFPExt(Value *V, Type *DestTy, const Twine &Name = "") {
1969 Value *CreatePtrToInt(Value *V, Type *DestTy,
1974 Value *CreateIntToPtr(Value *V, Type *DestTy,
1979 Value *CreateBitCast(Value *V, Type *DestTy,
1984 Value *CreateAddrSpaceCast(Value *V, Type *DestTy,
1989 Value *CreateZExtOrBitCast(Value *V, Type *DestTy,
1998 Value *CreateSExtOrBitCast(Value *V, Type *DestTy,
2007 Value *CreateTruncOrBitCast(Value *V, Type *DestTy,
2016 Value *CreateCast(Instruction::CastOps Op, Value *V, Type *DestTy,
2025 Value *CreatePointerCast(Value *V, Type *DestTy,
2034 Value *CreatePointerBitCastOrAddrSpaceCast(Value *V, Type *DestTy,
2048 Value *CreateIntCast(Value *V, Type *DestTy, bool isSigned,
2057 Value *CreateBitOrPointerCast(Value *V, Type *DestTy,
2069 Value *CreateFPCast(Value *V, Type *DestTy, const Twine &Name = "") {
2078 Intrinsic::ID ID, Value *V, Type *DestTy,
2113 Value *CreateIntCast(Value *, Type *, const char *) = delete;
2249 PHINode *CreatePHI(Type *Ty, unsigned NumReservedValues,
2327 VAArgInst *CreateVAArg(Value *List, Type *Ty, const Twine &Name = "") {
2390 LandingPadInst *CreateLandingPad(Type *Ty, unsigned NumClauses,
2421 Value *LHS_int = CreatePtrToInt(LHS, Type::getInt64Ty(Context));
2422 Value *RHS_int = CreatePtrToInt(RHS, Type::getInt64Ty(Context));
2436 auto *PtrType = Ptr->getType();
2464 auto *PtrType = Ptr->getType();
2490 Type *I32Ty = getInt32Ty();
2528 auto *BaseType = Base->getType();
2531 Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
2537 Type *ResultType =
2557 auto *BaseType = Base->getType();
2576 auto *BaseType = Base->getType();
2579 Constant *Zero = ConstantInt::get(Type::getInt32Ty(Context), 0);
2580 Type *ResultType =
2603 Type *IntPtrTy, Value *OffsetValue,
2647 Type *IntPtrTy = getIntPtrTy(DL, PtrTy->getAddressSpace());
2673 Type *IntPtrTy = getIntPtrTy(DL, PtrTy->getAddressSpace());
include/llvm/IR/InstrTypes.h 59 UnaryInstruction(Type *Ty, unsigned iType, Value *V,
64 UnaryInstruction(Type *Ty, unsigned iType, Value *V, BasicBlock *IAE)
107 UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
109 UnaryOperator(UnaryOps iType, Value *S, Type *Ty,
192 BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
194 BinaryOperator(BinaryOps iType, Value *S1, Value *S2, Type *Ty,
442 CastInst(Type *Ty, unsigned iType, Value *S,
448 CastInst(Type *Ty, unsigned iType, Value *S,
464 Type *Ty, ///< The type to which cast should be made
477 Type *Ty, ///< The type to which operand is casted
485 Type *Ty, ///< The type to which cast should be made
493 Type *Ty, ///< The type to which operand is casted
501 Type *Ty, ///< The type to which cast should be made
509 Type *Ty, ///< The type to which operand is casted
517 Type *Ty, ///< The type to which operand is casted
525 Type *Ty, ///< The type to which cast should be made
533 Type *Ty, ///< The type to which operand is casted
541 Type *Ty, ///< The type to which cast should be made
554 Type *Ty, ///< The type to which cast should be made
562 Type *Ty, ///< The type to which cast should be made
571 Type *Ty, ///< The integer type to which operand is casted
580 Type *Ty, ///< The floating point type to cast to
588 Type *Ty, ///< The floating point type to cast to
596 Type *Ty, ///< The type to which cast should be made
604 Type *Ty, ///< The type to which operand is casted
611 Type *SrcTy, ///< The Type from which the value should be cast.
612 Type *DestTy ///< The Type to which the value should be cast.
617 Type *SrcTy, ///< The Type from which the value should be cast.
618 Type *DestTy ///< The Type to which the value should be cast.
627 Type *SrcTy, ///< The Type from which the value should be cast.
628 Type *DestTy, ///< The Type to which the value should be cast.
637 Type *Ty, ///< The Type to which the value should be casted
664 Type *SrcTy, ///< SrcTy of cast
665 Type *DstTy, ///< DstTy of cast
683 Type *SrcTy, ///< SrcTy of 1st cast
684 Type *MidTy, ///< DstTy of 1st cast & SrcTy of 2nd cast
685 Type *DstTy, ///< DstTy of 2nd cast
686 Type *SrcIntPtrTy, ///< Integer type corresponding to Ptr SrcTy, or null
687 Type *MidIntPtrTy, ///< Integer type corresponding to Ptr MidTy, or null
688 Type *DstIntPtrTy ///< Integer type corresponding to Ptr DstTy, or null
697 Type* getSrcTy() const { return getOperand(0)->getType(); }
699 Type* getDestTy() const { return getType(); }
705 static bool castIsValid(Instruction::CastOps op, Value *S, Type *DstTy);
769 CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred,
774 CmpInst(Type *ty, Instruction::OtherOps op, Predicate pred,
975 static Type* makeCmpResultType(Type* opnd_type) {
975 static Type* makeCmpResultType(Type* opnd_type) {
977 return VectorType::get(Type::getInt1Ty(opnd_type->getContext()),
980 return Type::getInt1Ty(opnd_type->getContext());
1117 using Instruction::Instruction;
1589 Type *getParamByValType(unsigned ArgNo) const {
1590 Type *Ty = Attrs.getParamByValType(ArgNo);
include/llvm/IR/Instruction.h 773 Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
775 Instruction(Type *Ty, unsigned iType, Use *Ops, unsigned NumOps,
include/llvm/IR/Instructions.h 60 Type *AllocatedType;
69 explicit AllocaInst(Type *Ty, unsigned AddrSpace,
73 AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
76 AllocaInst(Type *Ty, unsigned AddrSpace,
78 AllocaInst(Type *Ty, unsigned AddrSpace,
81 AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, MaybeAlign Align,
83 AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize, MaybeAlign Align,
105 Type *getAllocatedType() const { return AllocatedType; }
108 void setAllocatedType(Type *Ty) { AllocatedType = Ty; }
179 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr = "",
181 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, BasicBlock *InsertAtEnd);
182 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
184 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
186 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
188 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
190 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
194 LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
292 Type *getPointerOperandType() const { return getPointerOperand()->getType(); }
421 Type *getPointerOperandType() const { return getPointerOperand()->getType(); }
873 inline Type *checkGEPType(Type *Ty) {
873 inline Type *checkGEPType(Type *Ty) {
882 Type *SourceElementType;
883 Type *ResultElementType;
891 inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
894 inline GetElementPtrInst(Type *PointeeType, Value *Ptr,
907 static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
923 static GetElementPtrInst *Create(Type *PointeeType, Value *Ptr,
949 CreateInBounds(Type *PointeeType, Value *Ptr, ArrayRef<Value *> IdxList,
965 static GetElementPtrInst *CreateInBounds(Type *PointeeType, Value *Ptr,
978 Type *getSourceElementType() const { return SourceElementType; }
980 void setSourceElementType(Type *Ty) { SourceElementType = Ty; }
981 void setResultElementType(Type *Ty) { ResultElementType = Ty; }
983 Type *getResultElementType() const {
1002 static Type *getIndexedType(Type *Ty, ArrayRef<Value *> IdxList);
1002 static Type *getIndexedType(Type *Ty, ArrayRef<Value *> IdxList);
1003 static Type *getIndexedType(Type *Ty, ArrayRef<Constant *> IdxList);
1003 static Type *getIndexedType(Type *Ty, ArrayRef<Constant *> IdxList);
1004 static Type *getIndexedType(Type *Ty, ArrayRef<uint64_t> IdxList);
1004 static Type *getIndexedType(Type *Ty, ArrayRef<uint64_t> IdxList);
1031 Type *getPointerOperandType() const {
1042 static Type *getGEPReturnType(Value *Ptr, ArrayRef<Value *> IdxList) {
1047 static Type *getGEPReturnType(Type *ElTy, Value *Ptr,
1047 static Type *getGEPReturnType(Type *ElTy, Value *Ptr,
1049 Type *PtrTy = PointerType::get(checkGEPType(getIndexedType(ElTy, IdxList)),
1114 GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
1128 GetElementPtrInst::GetElementPtrInst(Type *PointeeType, Value *Ptr,
1596 static Instruction *CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy,
1597 Type *AllocTy, Value *AllocSize,
1601 static Instruction *CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy,
1602 Type *AllocTy, Value *AllocSize,
1606 static Instruction *CreateMalloc(Instruction *InsertBefore, Type *IntPtrTy,
1607 Type *AllocTy, Value *AllocSize,
1612 static Instruction *CreateMalloc(BasicBlock *InsertAtEnd, Type *IntPtrTy,
1613 Type *AllocTy, Value *AllocSize,
1818 VAArgInst(Value *List, Type *Ty, const Twine &NameStr = "",
1824 VAArgInst(Value *List, Type *Ty, const Twine &NameStr,
2337 static Type *getIndexedType(Type *Agg, ArrayRef<unsigned> Idxs);
2337 static Type *getIndexedType(Type *Agg, ArrayRef<unsigned> Idxs);
2553 explicit PHINode(Type *Ty, unsigned NumReservedValues,
2562 PHINode(Type *Ty, unsigned NumReservedValues, const Twine &NameStr,
2586 static PHINode *Create(Type *Ty, unsigned NumReservedValues,
2592 static PHINode *Create(Type *Ty, unsigned NumReservedValues,
2802 explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
2804 explicit LandingPadInst(Type *RetTy, unsigned NumReservedValues,
2824 static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
2827 static LandingPadInst *Create(Type *RetTy, unsigned NumReservedClauses,
4724 Type *Ty, ///< The (smaller) type to truncate to
4732 Type *Ty, ///< The (smaller) type to truncate to
4763 Type *Ty, ///< The type to zero extend to
4771 Type *Ty, ///< The type to zero extend to
4802 Type *Ty, ///< The type to sign extend to
4810 Type *Ty, ///< The type to sign extend to
4841 Type *Ty, ///< The type to truncate to
4849 Type *Ty, ///< The type to truncate to
4880 Type *Ty, ///< The type to extend to
4888 Type *Ty, ///< The type to extend to
4919 Type *Ty, ///< The type to convert to
4927 Type *Ty, ///< The type to convert to
4958 Type *Ty, ///< The type to convert to
4966 Type *Ty, ///< The type to convert to
4997 Type *Ty, ///< The type to convert to
5005 Type *Ty, ///< The type to convert to
5036 Type *Ty, ///< The type to convert to
5044 Type *Ty, ///< The type to convert to
5071 Type *Ty, ///< The type to convert to
5079 Type *Ty, ///< The type to convert to
5118 Type *Ty, ///< The type to convert to
5126 Type *Ty, ///< The type to convert to
5169 Type *Ty, ///< The type to casted to
5177 Type *Ty, ///< The type to casted to
5209 Type *Ty, ///< The type to casted to
5217 Type *Ty, ///< The type to casted to
include/llvm/IR/Intrinsics.h 56 std::string getName(ID id, ArrayRef<Type*> Tys);
60 ArrayRef<Type*> Tys = None);
80 Function *getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys = None);
185 SmallVectorImpl<Type *> &ArgTys);
include/llvm/IR/Metadata.h 179 MetadataAsValue(Type *Ty, Metadata *MD);
379 Type *getType() const { return V->getType(); }
include/llvm/IR/Module.h 358 AttributeList AttributeList, Type *RetTy,
360 SmallVector<Type*, sizeof...(ArgsTy)> ArgTys{Args...};
368 FunctionCallee getOrInsertFunction(StringRef Name, Type *RetTy,
419 getOrInsertGlobal(StringRef Name, Type *Ty,
424 Constant *getOrInsertGlobal(StringRef Name, Type *Ty);
include/llvm/IR/NoFolder.h 214 Constant *CreateGetElementPtr(Type *Ty, Constant *C,
219 Constant *CreateGetElementPtr(Type *Ty, Constant *C, Constant *Idx) const {
226 Instruction *CreateGetElementPtr(Type *Ty, Constant *C,
231 Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
236 Constant *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
244 Instruction *CreateInBoundsGetElementPtr(Type *Ty, Constant *C,
254 Type *DestTy) const {
258 Instruction *CreatePointerCast(Constant *C, Type *DestTy) const {
262 Instruction *CreateIntCast(Constant *C, Type *DestTy,
267 Instruction *CreateFPCast(Constant *C, Type *DestTy) const {
271 Instruction *CreateBitCast(Constant *C, Type *DestTy) const {
275 Instruction *CreateIntToPtr(Constant *C, Type *DestTy) const {
279 Instruction *CreatePtrToInt(Constant *C, Type *DestTy) const {
283 Instruction *CreateZExtOrBitCast(Constant *C, Type *DestTy) const {
287 Instruction *CreateSExtOrBitCast(Constant *C, Type *DestTy) const {
291 Instruction *CreateTruncOrBitCast(Constant *C, Type *DestTy) const {
include/llvm/IR/Operator.h 493 Type *getPointerOperandType() const {
497 Type *getSourceElementType() const;
498 Type *getResultElementType() const;
572 Type *getPointerOperandType() const {
588 Type *getSrcTy() const {
592 Type *getDestTy() const {
include/llvm/IR/Statepoint.h 157 Type *getActualReturnType() const {
include/llvm/IR/Type.h 111 Type * const *ContainedTys = nullptr;
236 bool canLosslesslyBitCastTo(Type *Ty) const;
265 bool isSized(SmallPtrSetImpl<Type*> *Visited = nullptr) const {
307 Type *getScalarType() const {
316 using subtype_iterator = Type * const *;
320 ArrayRef<Type*> subtypes() const {
336 Type *getContainedType(unsigned i) const {
353 inline Type *getFunctionParamType(unsigned i) const;
359 inline Type *getStructElementType(unsigned N) const;
361 inline Type *getSequentialElementType() const {
368 Type *getArrayElementType() const {
376 Type *getVectorElementType() const {
381 Type *getPointerElementType() const {
388 inline Type *getWithNewBitWidth(unsigned NewBitWidth) const;
392 inline Type *getExtendedType() const;
403 static Type *getPrimitiveType(LLVMContext &C, TypeID IDNumber);
408 static Type *getVoidTy(LLVMContext &C);
409 static Type *getLabelTy(LLVMContext &C);
410 static Type *getHalfTy(LLVMContext &C);
411 static Type *getFloatTy(LLVMContext &C);
412 static Type *getDoubleTy(LLVMContext &C);
413 static Type *getMetadataTy(LLVMContext &C);
414 static Type *getX86_FP80Ty(LLVMContext &C);
415 static Type *getFP128Ty(LLVMContext &C);
416 static Type *getPPC_FP128Ty(LLVMContext &C);
417 static Type *getX86_MMXTy(LLVMContext &C);
418 static Type *getTokenTy(LLVMContext &C);
426 template <typename ScalarTy> static Type *getScalarTy(LLVMContext &C) {
429 return (Type*) Type::getIntNTy(C, noOfBits);
433 return Type::getFloatTy(C);
435 return Type::getDoubleTy(C);
467 bool isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited = nullptr) const;
471 inline raw_ostream &operator<<(raw_ostream &OS, const Type &T) {
478 static inline bool doit(const Type &Ty) {
479 return Ty.getTypeID() == Type::PointerTyID;
488 inline Type **unwrap(LLVMTypeRef* Tys) {
492 inline LLVMTypeRef *wrap(Type **Tys) {
include/llvm/IR/TypeFinder.h 35 DenseSet<Type*> VisitedTypes;
66 void incorporateType(Type *Ty);
include/llvm/IR/User.h 73 User(Type *ty, unsigned vty, Use *, unsigned NumOps)
include/llvm/IR/Value.h 77 Type *VTy;
206 Value(Type *Ty, unsigned scid);
246 Type *getType() const { return VTy; }
663 void mutateType(Type *Ty) {
include/llvm/Linker/IRMover.h 28 ArrayRef<Type *> ETypes;
30 KeyTy(ArrayRef<Type *> E, bool P);
58 StructType *findNonOpaque(ArrayRef<Type *> ETypes, bool IsPacked);
include/llvm/Support/Casting.h 57 static inline bool doit(const From &Val) {
66 static inline bool doit(const From &) { return true; }
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;
227 static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
228 typename cast_retty<To, FromTy>::ret_type Res2
256 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) {
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);
305 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
306 cast_or_null(Y *Val) {
337 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) {
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
367 dyn_cast_or_null(Y *Val) {
include/llvm/Support/MachineValueType.h 1079 static MVT getVT(Type *Ty, bool HandleUnknown = false);
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 };
91 typedef PointerLikeTypeTraits<T *> NonConst;
93 static inline const void *getAsVoidPointer(const T *P) {
96 static inline const T *getFromVoidPointer(const void *P) {
include/llvm/Target/TargetIntrinsicInfo.h 43 virtual std::string getName(unsigned IID, Type **Tys = nullptr,
63 virtual Function *getDeclaration(Module *M, unsigned ID, Type **Tys = nullptr,
include/llvm/Transforms/Scalar/ConstantHoisting.h 104 Type *Ty;
195 void emitBaseConstants(Instruction *Base, Constant *Offset, Type *Ty,
include/llvm/Transforms/Scalar/Float2Int.h 42 Value *convert(Instruction *I, Type *ToTy);
include/llvm/Transforms/Scalar/GVNExpression.h 144 Type *ValueType = nullptr;
210 void setType(Type *T) { ValueType = T; }
211 Type *getType() const { return ValueType; }
include/llvm/Transforms/Scalar/NaryReassociate.h 130 unsigned I, Type *IndexedType);
136 Value *RHS, Type *IndexedType);
include/llvm/Transforms/Utils/BuildLibCalls.h 35 bool hasFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
40 StringRef getFloatFnName(const TargetLibraryInfo *TLI, Type *Ty,
include/llvm/Transforms/Utils/CodeExtractor.h 101 Type *RetTy;
include/llvm/Transforms/Utils/FunctionComparator.h 320 int cmpTypes(Type *TyL, Type *TyR) const;
320 int cmpTypes(Type *TyL, Type *TyR) const;
include/llvm/Transforms/Utils/ModuleUtils.h 44 ArrayRef<Type *> InitArgTypes);
52 ArrayRef<Type *> InitArgTypes, ArrayRef<Value *> InitArgs,
64 ArrayRef<Type *> InitArgTypes, ArrayRef<Value *> InitArgs,
include/llvm/Transforms/Utils/SSAUpdater.h 47 Type *ProtoType = nullptr;
68 void Initialize(Type *Ty, StringRef Name);
include/llvm/Transforms/Utils/SSAUpdaterBulk.h 45 Type *Ty;
47 RewriteInfo(StringRef &N, Type *T) : Name(N), Ty(T){};
64 unsigned AddVariable(StringRef Name, Type *Ty);
include/llvm/Transforms/Utils/VNCoercion.h 37 bool canCoerceMustAliasedValueToLoad(Value *StoredVal, Type *LoadTy,
46 Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
54 int analyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr,
62 int analyzeLoadFromClobberingLoad(Type *LoadTy, Value *LoadPtr, LoadInst *DepLI,
70 int analyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr,
76 Value *getStoreValueForLoad(Value *SrcVal, unsigned Offset, Type *LoadTy,
81 Type *LoadTy, const DataLayout &DL);
87 Value *getLoadValueForLoad(LoadInst *SrcVal, unsigned Offset, Type *LoadTy,
92 Type *LoadTy, const DataLayout &DL);
99 Type *LoadTy, Instruction *InsertPt,
104 Type *LoadTy, const DataLayout &DL);
include/llvm/Transforms/Utils/ValueMapper.h 45 virtual Type *remapType(Type *SrcTy) = 0;
45 virtual Type *remapType(Type *SrcTy) = 0;
include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h 250 Type *getWidestInductionType() { return WidestIndTy; }
445 Type *WidestIndTy = nullptr;
lib/Analysis/AliasAnalysisEvaluator.cpp 143 Type *I1ElTy = cast<PointerType>((*I1)->getType())->getElementType();
149 Type *I2ElTy = cast<PointerType>((*I2)->getType())->getElementType();
234 Type *ElTy = cast<PointerType>(Pointer->getType())->getElementType();
lib/Analysis/BasicAliasAnalysis.cpp 1143 auto *Ty = GetElementPtrInst::getIndexedType(
lib/Analysis/CmpInstAnalysis.cpp 42 Constant *llvm::getPredForICmpCode(unsigned Code, bool Sign, Type *OpTy,
lib/Analysis/ConstantFolding.cpp 62 static Constant *foldConstVectorToAPInt(APInt &Result, Type *DestTy,
63 Constant *C, Type *SrcEltTy,
95 Constant *FoldBitCast(Constant *C, Type *DestTy, const DataLayout &DL) {
110 Type *SrcEltTy = VTy->getElementType();
116 Type *SrcIVTy =
157 Type *SrcEltTy = C->getType()->getVectorElementType();
158 Type *DstEltTy = DestVTy->getElementType();
173 Type *DestIVTy =
186 Type *SrcIVTy =
270 IntegerType *DstIntTy = Type::getIntNTy(C->getContext(), DstBitSize);
326 Constant *llvm::ConstantFoldLoadThroughBitcast(Constant *C, Type *DestTy,
329 Type *SrcTy = C->getType();
408 C = FoldBitCast(C, Type::getInt64Ty(C->getContext()), DL);
412 C = FoldBitCast(C, Type::getInt32Ty(C->getContext()), DL);
416 C = FoldBitCast(C, Type::getInt16Ty(C->getContext()), DL);
461 Type *EltTy = C->getType()->getSequentialElementType();
500 Constant *FoldReinterpretLoadFromConstPtr(Constant *C, Type *LoadTy,
513 Type *MapTy;
515 MapTy = Type::getInt16Ty(C->getContext());
517 MapTy = Type::getInt32Ty(C->getContext());
519 MapTy = Type::getInt64Ty(C->getContext());
531 Type *CastTy = LoadTy->isPtrOrPtrVectorTy() ? DL.getIntPtrType(LoadTy) : LoadTy;
604 Constant *ConstantFoldLoadThroughBitcastExpr(ConstantExpr *CE, Type *DestTy,
610 Type *SrcTy = SrcPtrTy->getPointerElementType();
621 Constant *llvm::ConstantFoldLoadFromConstPtr(Constant *C, Type *Ty,
764 Constant *CastGEPIndices(Type *SrcElemTy, ArrayRef<Constant *> Ops,
765 Type *ResultTy, Optional<unsigned> InRangeIndex,
767 Type *IntPtrTy = DL.getIntPtrType(ResultTy);
768 Type *IntPtrScalarTy = IntPtrTy->getScalarType();
778 Type *NewType = Ops[i]->getType()->isVectorTy()
802 Constant *StripPtrCastKeepAS(Constant *Ptr, Type *&ElemTy) {
826 Type *SrcElemTy = GEP->getSourceElementType();
827 Type *ResElemTy = GEP->getResultElementType();
828 Type *ResTy = GEP->getType();
840 Type *IntPtrTy = DL.getIntPtrType(Ptr->getType());
918 Type *Ty = PTy;
971 NewIdxs.push_back(ConstantInt::get(Type::getInt32Ty(Ty->getContext()),
1019 Type *DestTy = InstOrCE->getType();
1219 Type *IntPtrTy = DL.getIntPtrType(CE0->getType());
1231 Type *IntPtrTy = DL.getIntPtrType(CE0->getOperand(0)->getType());
1243 Type *IntPtrTy = DL.getIntPtrType(CE0->getType());
1257 Type *IntPtrTy = DL.getIntPtrType(CE0->getOperand(0)->getType());
1308 Type *DestTy, const DataLayout &DL) {
1562 Constant *GetConstantFoldFPValue(double V, Type *Ty) {
1594 Constant *ConstantFoldFP(double (*NativeFP)(double), double V, Type *Ty) {
1606 double W, Type *Ty) {
1625 Type *Ty, bool IsSigned) {
1645 Type *Ty = Op->getType();
1686 Type *Ty,
2025 Type *Ty,
2179 ConstantInt::get(Type::getInt1Ty(Ty->getContext()), Overflow)
2278 Type *Ty,
2373 Type *Ty,
2398 Type *Ty = VTy->getElementType();
2477 Type *Ty = F->getReturnType();
2553 Type *Ty = OpC->getType();
2613 Type *Ty = Op0C->getType();
lib/Analysis/DemandedBits.cpp 328 Type *T = I.getType();
339 Type *T = J->getType();
383 Type *T = OI->getType();
lib/Analysis/DependenceAnalysis.cpp 809 Type *widestType;
1020 Type *MaxType =
1070 const SCEV *DependenceInfo::collectUpperBound(const Loop *L, Type *T) const {
1082 Type *T) const {
lib/Analysis/GlobalsModRef.cpp 738 Type *GVType = GVar->getInitializer()->getType();
739 Type *InputGVType = InputGVar->getInitializer()->getType();
lib/Analysis/IVDescriptors.cpp 87 static Instruction *lookThroughAnd(PHINode *Phi, Type *&RT,
112 static std::pair<Type *, bool> computeRecurrenceType(Instruction *Exit,
154 return std::make_pair(Type::getIntNTy(Exit->getContext(), MaxBitWidth),
162 Type *RecurrenceType,
228 Type *RecurrenceType = Phi->getType();
425 Type *ComputedType;
726 Type *Tp) {
988 Type *PhiTy = Phi->getType();
1033 Type *PhiTy = Phi->getType();
1083 Type *PointerElementType = PhiTy->getPointerElementType();
lib/Analysis/InlineCost.cpp 437 Type *Ty = I.getAllocatedType();
447 Type *Ty = I.getAllocatedType();
1679 Type *IntPtrTy = DL.getIntPtrType(V->getContext(), AS);
lib/Analysis/InstructionSimplify.cpp 67 static Value *SimplifyCastInst(unsigned, Value *, Type *,
69 static Value *SimplifyGEPInst(Type *, ArrayRef<Value *>, const SimplifyQuery &,
116 static Constant *getFalse(Type *Ty) {
122 static Constant *getTrue(Type *Ty) {
602 Type *Ty = Op0->getType();
659 Type *IntPtrTy = DL.getIntPtrType(V->getType())->getScalarType();
892 Type *Ty = Op0->getType();
971 Type *Ty = X->getType();
1626 Type *ITy = Op0->getType();
1699 Type *ITy = Op0->getType();
2247 static Type *GetCompareTy(Value *Op) {
2489 Type *ITy = GetCompareTy(LHS); // The return type.
2490 Type *OpTy = LHS->getType(); // The operand type.
2566 Type *ITy = GetCompareTy(LHS); // The return type.
2625 Type *ITy = GetCompareTy(RHS); // The return type.
2667 Type *ITy = GetCompareTy(LHS); // The return type.
2981 Type *ITy = GetCompareTy(LHS); // The return type.
3197 Type *ITy = GetCompareTy(LHS); // The return type.
3247 Type *SrcTy = SrcOp->getType();
3248 Type *DstTy = LI->getType();
3492 Type *RetTy = GetCompareTy(LHS);
3988 static Value *SimplifyGEPInst(Type *SrcTy, ArrayRef<Value *> Ops,
3999 Type *LastType = GetElementPtrInst::getIndexedType(SrcTy, Ops.slice(1));
4000 Type *GEPTy = PointerType::get(LastType, AS);
4014 Type *Ty = SrcTy;
4100 Value *llvm::SimplifyGEPInst(Type *SrcTy, ArrayRef<Value *> Ops,
4277 Type *Ty, const SimplifyQuery &Q, unsigned MaxRecurse) {
4283 Type *SrcTy = Src->getType();
4284 Type *MidTy = CI->getType();
4285 Type *DstTy = Ty;
4289 Type *SrcIntPtrTy =
4291 Type *MidIntPtrTy =
4293 Type *DstIntPtrTy =
4310 Value *llvm::SimplifyCastInst(unsigned CastOpc, Value *Op, Type *Ty,
4367 Type *RetTy, const SimplifyQuery &Q,
4372 Type *InVecTy = Op0->getType();
4444 Type *RetTy, const SimplifyQuery &Q) {
4880 Type *Int8PtrTy = Type::getInt8PtrTy(Ptr->getContext());
4880 Type *Int8PtrTy = Type::getInt8PtrTy(Ptr->getContext());
4881 Type *Int32Ty = Type::getInt32Ty(Ptr->getContext());
4881 Type *Int32Ty = Type::getInt32Ty(Ptr->getContext());
4882 Type *Int32PtrTy = Int32Ty->getPointerTo();
4883 Type *Int64Ty = Type::getInt64Ty(Ptr->getContext());
4883 Type *Int64Ty = Type::getInt64Ty(Ptr->getContext());
5005 Type *ReturnType = F->getReturnType();
lib/Analysis/LazyValueInfo.cpp 1397 Type::getInt1Ty(Val->getContext()), isTrueDest));
lib/Analysis/Lint.cpp 98 Type *Ty, unsigned Flags);
289 Type *Ty =
416 Type *Ty, unsigned Flags) {
470 Type *ATy = AI->getAllocatedType();
480 Type *GTy = GV->getValueType();
lib/Analysis/Loads.cpp 33 Type *const Ty = Base->getType()->getPointerElementType();
76 Type *Ty = V->getType();
138 bool llvm::isDereferenceableAndAlignedPointer(const Value *V, Type *Ty,
159 bool llvm::isDereferenceablePointer(const Value *V, Type *Ty,
322 Type *AccessedTy = AccessedPtr->getType()->getPointerElementType();
341 bool llvm::isSafeToLoadUnconditionally(Value *V, Type *Ty, MaybeAlign Alignment,
376 Value *llvm::FindAvailablePtrLoadStore(Value *Ptr, Type *AccessTy,
lib/Analysis/LoopAccessAnalysis.cpp 993 Type *Ty = Ptr->getType();
1191 Type *Ty = cast<PointerType>(PtrA->getType())->getElementType();
1492 Type *ATy = APtr->getType()->getPointerElementType();
1493 Type *BTy = BPtr->getType()->getPointerElementType();
2155 Type *PtrArithTy = Type::getInt8PtrTy(Ctx, AS);
2155 Type *PtrArithTy = Type::getInt8PtrTy(Ctx, AS);
2230 Type *PtrArithTy0 = Type::getInt8PtrTy(Ctx, AS0);
2230 Type *PtrArithTy0 = Type::getInt8PtrTy(Ctx, AS0);
2231 Type *PtrArithTy1 = Type::getInt8PtrTy(Ctx, AS1);
2231 Type *PtrArithTy1 = Type::getInt8PtrTy(Ctx, AS1);
lib/Analysis/MemoryBuiltins.cpp 160 if (FTy->getReturnType() == Type::getInt8PtrTy(FTy->getContext()) &&
333 Type *T = getMallocAllocatedType(CI, TLI);
388 Type *llvm::getMallocAllocatedType(const CallInst *CI,
455 if (FTy->getParamType(0) != Type::getInt8PtrTy(F->getContext()))
lib/Analysis/ModuleSummaryAnalysis.cpp 517 Type *EltTy = ATy->getElementType();
lib/Analysis/ScalarEvolution.cpp 326 Type *AllocTy;
336 Type *CTy;
356 Type *SCEV::getType() const {
436 ScalarEvolution::getConstant(Type *Ty, uint64_t V, bool isSigned) {
442 unsigned SCEVTy, const SCEV *op, Type *ty)
446 const SCEV *op, Type *ty)
453 const SCEV *op, Type *ty)
460 const SCEV *op, Type *ty)
487 bool SCEVUnknown::isSizeOf(Type *&AllocTy) const {
504 bool SCEVUnknown::isAlignOf(Type *&AllocTy) const {
510 Type *Ty =
529 bool SCEVUnknown::isOffsetOf(Type *&CTy, Constant *&FieldNo) const {
537 Type *Ty =
979 Type *Ty = Denominator->getType();
991 Type *Ty = Denominator->getType();
1017 Type *Ty = Denominator->getType();
1118 Type *ResultTy) {
1254 const SCEV *ScalarEvolution::getTruncateExpr(const SCEV *Op, Type *Ty,
1437 static const SCEV *getPreStartForExtend(const SCEVAddRecExpr *AR, Type *Ty,
1483 Type *WideTy = IntegerType::get(SE->getContext(), BitWidth * 2);
1511 static const SCEV *getExtendAddRecStart(const SCEVAddRecExpr *AR, Type *Ty,
1638 ScalarEvolution::getZeroExtendExpr(const SCEV *Op, Type *Ty, unsigned Depth) {
1726 Type *WideTy = IntegerType::get(getContext(), BitWidth * 2);
1924 Type *NewTruncTy = IntegerType::get(getContext(), NewTruncBits);
1944 ScalarEvolution::getSignExtendExpr(const SCEV *Op, Type *Ty, unsigned Depth) {
2070 Type *WideTy = IntegerType::get(getContext(), BitWidth * 2);
2198 Type *Ty) {
2414 Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
2454 Type *Ty = Ops[0]->getType();
2493 if (auto *SrcType = FindTruncSrcType()) {
2915 Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
3105 Type *Ty = AddRec->getType();
3172 Type *FullTy = LHS->getType();
3173 Type *TruncTy =
3203 Type *Ty = LHS->getType();
3414 Type *ETy = getEffectiveSCEVType(Operands[0]->getType());
3491 Type *IntPtrTy = getEffectiveSCEVType(BaseExpr->getType());
3503 Type *CurTy = ArrayType::get(GEP->getSourceElementType(), 0);
3554 Type *ETy = getEffectiveSCEVType(Ops[0]->getType());
3719 const SCEV *ScalarEvolution::getSizeOfExpr(Type *IntTy, Type *AllocTy) {
3719 const SCEV *ScalarEvolution::getSizeOfExpr(Type *IntTy, Type *AllocTy) {
3726 const SCEV *ScalarEvolution::getOffsetOfExpr(Type *IntTy,
3766 bool ScalarEvolution::isSCEVable(Type *Ty) const {
3773 uint64_t ScalarEvolution::getTypeSizeInBits(Type *Ty) const {
3783 Type *ScalarEvolution::getEffectiveSCEVType(Type *Ty) const {
3783 Type *ScalarEvolution::getEffectiveSCEVType(Type *Ty) const {
3794 Type *ScalarEvolution::getWiderType(Type *T1, Type *T2) const {
3794 Type *ScalarEvolution::getWiderType(Type *T1, Type *T2) const {
3794 Type *ScalarEvolution::getWiderType(Type *T1, Type *T2) const {
3952 Type *Ty = V->getType();
3997 Type *Ty = V->getType();
4043 const SCEV *ScalarEvolution::getTruncateOrZeroExtend(const SCEV *V, Type *Ty,
4045 Type *SrcTy = V->getType();
4055 const SCEV *ScalarEvolution::getTruncateOrSignExtend(const SCEV *V, Type *Ty,
4057 Type *SrcTy = V->getType();
4068 ScalarEvolution::getNoopOrZeroExtend(const SCEV *V, Type *Ty) {
4069 Type *SrcTy = V->getType();
4080 ScalarEvolution::getNoopOrSignExtend(const SCEV *V, Type *Ty) {
4081 Type *SrcTy = V->getType();
4092 ScalarEvolution::getNoopOrAnyExtend(const SCEV *V, Type *Ty) {
4093 Type *SrcTy = V->getType();
4104 ScalarEvolution::getTruncateOrNoop(const SCEV *V, Type *Ty) {
4105 Type *SrcTy = V->getType();
4142 Type *MaxType = nullptr;
4393 return IsPositiveBECond ? SE.getOne(Type::getInt1Ty(SE.getContext()))
4394 : SE.getZero(Type::getInt1Ty(SE.getContext()));
4585 static Type *isSimpleCastedPHI(const SCEV *Op, const SCEVUnknown *SymbolicPHI,
4729 Type *TruncTy = nullptr;
6340 Type *UTy = BO->LHS->getType();
6342 Type *Z0Ty = Z0->getType();
6397 Type *OuterTy = BO->LHS->getType();
6410 Type *TruncTy = IntegerType::get(getContext(), BitWidth - AShrAmt);
6463 Type *Ty = U->getType();
7995 return getConstant(Type::getInt32Ty(getContext()), IterationNum);
8080 Type *DestPtrTy = Type::getInt8PtrTy(C->getContext(), AS);
8080 Type *DestPtrTy = Type::getInt8PtrTy(C->getContext(), AS);
8091 Type *DestPtrTy = Type::getInt8PtrTy(C->getContext(), AS);
8091 Type *DestPtrTy = Type::getInt8PtrTy(C->getContext(), AS);
8105 C2, Type::getInt32Ty(C->getContext()), true);
9493 Type *Ty = LatchBECount->getType();
10310 auto *DTy = Denominator->getType();
10311 auto *FRHSTy = FoundRHS->getType();
10321 auto *WTy = getWiderType(DTy, FRHSTy);
11135 Type *Ty;
11143 Type *ETy = getEffectiveSCEVType(PointerType::getUnqual(Ty));
12137 Type *Ty = Expr->getType();
12153 Type *Ty = Expr->getType();
lib/Analysis/ScalarEvolutionExpander.cpp 37 Value *SCEVExpander::ReuseOrCreateCast(Value *V, Type *Ty,
109 Value *SCEVExpander::InsertNoopCastOfTo(Value *V, Type *Ty) {
317 Type *Ty,
346 Type *Ty,
405 Type *Ty,
407 Type *OriginalElTy = PTy->getElementType();
408 Type *ElTy = OriginalElTy;
417 Type *IntPtrTy = DL.getIntPtrType(PTy);
479 ConstantInt::get(Type::getInt32Ty(Ty->getContext()), ElIdx));
493 Constant::getNullValue(Type::getInt32Ty(Ty->getContext())));
509 Type::getInt8PtrTy(Ty->getContext(), PTy->getAddressSpace()));
520 return ConstantExpr::getGetElementPtr(Type::getInt8Ty(Ty->getContext()),
596 Value *SCEVExpander::expandAddToGEP(const SCEV *Op, PointerType *PTy, Type *Ty,
689 Type *Ty = SE.getEffectiveSCEVType(S->getType());
761 Type *Ty = SE.getEffectiveSCEVType(S->getType());
856 Type *Ty = SE.getEffectiveSCEVType(S->getType());
972 if (IncV->getType() != Type::getInt1PtrTy(SE.getContext(), AS)
973 && IncV->getType() != Type::getInt8PtrTy(SE.getContext(), AS))
1053 Type *ExpandTy, Type *IntTy,
1053 Type *ExpandTy, Type *IntTy,
1062 GEPPtrTy = PointerType::get(Type::getInt1Ty(SE.getContext()),
1100 Type *PhiTy = SE.getEffectiveSCEVType(Phi->getType());
1101 Type *RequestedTy = SE.getEffectiveSCEVType(Requested->getType());
1132 Type *WideTy = IntegerType::get(AR->getType()->getContext(), BitWidth * 2);
1146 Type *WideTy = IntegerType::get(AR->getType()->getContext(), BitWidth * 2);
1161 Type *ExpandTy,
1162 Type *IntTy,
1163 Type *&TruncTy,
1338 Type *STy = S->getType();
1339 Type *IntTy = SE.getEffectiveSCEVType(STy);
1384 Type *ExpandTy = PostLoopScale ? IntTy : STy;
1387 Type *AddRecPHIExpandTy =
1392 Type *TruncTy = nullptr;
1439 Type *ResTy = Result->getType();
1499 Type *Ty = SE.getEffectiveSCEVType(S->getType());
1635 Type *Ty = SE.getEffectiveSCEVType(S->getType());
1644 Type *Ty = SE.getEffectiveSCEVType(S->getType());
1653 Type *Ty = SE.getEffectiveSCEVType(S->getType());
1663 Type *Ty = LHS->getType();
1667 Type *OpTy = S->getOperand(i)->getType();
1688 Type *Ty = LHS->getType();
1692 Type *OpTy = S->getOperand(i)->getType();
1713 Type *Ty = LHS->getType();
1717 Type *OpTy = S->getOperand(i)->getType();
1738 Type *Ty = LHS->getType();
1742 Type *OpTy = S->getOperand(i)->getType();
1761 Value *SCEVExpander::expandCodeFor(const SCEV *SH, Type *Ty,
1767 Value *SCEVExpander::expandCodeFor(const SCEV *SH, Type *Ty) {
1883 Type *Ety = Vty->getPointerElementType();
1894 V = Builder.CreateBitCast(V, Type::getInt8PtrTy(SE.getContext(), AS));
1895 V = Builder.CreateGEP(Type::getInt8Ty(SE.getContext()), V, Idx,
1926 Type *Ty) {
2252 Type *ARTy = AR->getType();
2267 Type *ARExpandTy = DL.isNonIntegralPointerType(ARTy) ? ARTy : Ty;
lib/Analysis/TargetLibraryInfo.cpp 637 Type *PCharTy = Type::getInt8PtrTy(Ctx);
637 Type *PCharTy = Type::getInt8PtrTy(Ctx);
638 Type *SizeTTy = DL ? DL->getIntPtrType(Ctx, /*AS=*/0) : nullptr;
1454 Type* RetTy = FTy.getReturnType();
lib/Analysis/TargetTransformInfo.cpp 148 int TargetTransformInfo::getOperationCost(unsigned Opcode, Type *Ty,
149 Type *OpTy) const {
178 int TargetTransformInfo::getGEPCost(Type *PointeeType, const Value *Ptr,
189 Intrinsic::ID IID, Type *RetTy, ArrayRef<const Value *> Arguments,
258 bool TargetTransformInfo::isLegalAddressingMode(Type *Ty, GlobalValue *BaseGV,
291 bool TargetTransformInfo::isLegalMaskedStore(Type *DataType,
296 bool TargetTransformInfo::isLegalMaskedLoad(Type *DataType,
301 bool TargetTransformInfo::isLegalNTStore(Type *DataType,
306 bool TargetTransformInfo::isLegalNTLoad(Type *DataType, Align Alignment) const {
310 bool TargetTransformInfo::isLegalMaskedGather(Type *DataType) const {
314 bool TargetTransformInfo::isLegalMaskedScatter(Type *DataType) const {
318 bool TargetTransformInfo::isLegalMaskedCompressStore(Type *DataType) const {
322 bool TargetTransformInfo::isLegalMaskedExpandLoad(Type *DataType) const {
326 bool TargetTransformInfo::hasDivRemOp(Type *DataType, bool IsSigned) const {
339 int TargetTransformInfo::getScalingFactorCost(Type *Ty, GlobalValue *BaseGV,
354 bool TargetTransformInfo::isTruncateFree(Type *Ty1, Type *Ty2) const {
354 bool TargetTransformInfo::isTruncateFree(Type *Ty1, Type *Ty2) const {
364 bool TargetTransformInfo::isTypeLegal(Type *Ty) const {
380 getScalarizationOverhead(Type *Ty, bool Insert, bool Extract) const {
429 bool TargetTransformInfo::haveFastSqrt(Type *Ty) const {
433 bool TargetTransformInfo::isFCmpOrdCheaperThanFCmpZero(Type *Ty) const {
437 int TargetTransformInfo::getFPOpCost(Type *Ty) const {
445 Type *Ty) const {
451 int TargetTransformInfo::getIntImmCost(const APInt &Imm, Type *Ty) const {
458 const APInt &Imm, Type *Ty) const {
465 const APInt &Imm, Type *Ty) const {
475 unsigned TargetTransformInfo::getRegisterClassForType(bool Vector, Type *Ty) const {
585 unsigned Opcode, Type *Ty, OperandValueKind Opd1Info,
595 int TargetTransformInfo::getShuffleCost(ShuffleKind Kind, Type *Ty, int Index,
596 Type *SubTp) const {
602 int TargetTransformInfo::getCastInstrCost(unsigned Opcode, Type *Dst,
603 Type *Src, const Instruction *I) const {
611 int TargetTransformInfo::getExtractWithExtendCost(unsigned Opcode, Type *Dst,
625 int TargetTransformInfo::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
626 Type *CondTy, const Instruction *I) const {
634 int TargetTransformInfo::getVectorInstrCost(unsigned Opcode, Type *Val,
641 int TargetTransformInfo::getMemoryOpCost(unsigned Opcode, Type *Src,
652 int TargetTransformInfo::getMaskedMemoryOpCost(unsigned Opcode, Type *Src,
661 int TargetTransformInfo::getGatherScatterOpCost(unsigned Opcode, Type *DataTy,
671 unsigned Opcode, Type *VecTy, unsigned Factor, ArrayRef<unsigned> Indices,
682 int TargetTransformInfo::getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
683 ArrayRef<Type *> Tys, FastMathFlags FMF,
691 int TargetTransformInfo::getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
698 int TargetTransformInfo::getCallInstrCost(Function *F, Type *RetTy,
699 ArrayRef<Type *> Tys) const {
705 unsigned TargetTransformInfo::getNumberOfParts(Type *Tp) const {
709 int TargetTransformInfo::getAddressComputationCost(Type *Tp,
723 int TargetTransformInfo::getArithmeticReductionCost(unsigned Opcode, Type *Ty,
730 int TargetTransformInfo::getMinMaxReductionCost(Type *Ty, Type *CondTy,
730 int TargetTransformInfo::getMinMaxReductionCost(Type *Ty, Type *CondTy,
740 TargetTransformInfo::getCostOfKeepingLiveOverCall(ArrayRef<Type *> Tys) const {
754 IntrinsicInst *Inst, Type *ExpectedType) const {
758 Type *TargetTransformInfo::getMemcpyLoopLoweringType(LLVMContext &Context,
767 SmallVectorImpl<Type *> &OpsOut, LLVMContext &Context,
785 Type *Ty) const {
790 Type *Ty) const {
833 Type *Ty, ReductionFlags Flags) const {
1001 unsigned &Opcode, Type *&Ty) {
1020 Type *VecTy = RdxStart->getType();
1066 unsigned &Opcode, Type *&Ty) {
1085 Type *VecTy = ReduxRoot->getOperand(0)->getType();
1192 Type *CondTy = SI->getCondition()->getType();
1197 Type *ValTy = I->getOperand(0)->getType();
1202 Type *ValTy = SI->getValueOperand()->getType();
1226 Type *SrcTy = I->getOperand(0)->getType();
1239 Type *ReduxType;
1289 Type *Ty = Shuffle->getType();
1290 Type *SrcTy = Shuffle->getOperand(0)->getType();
lib/Analysis/TypeBasedAliasAnalysis.cpp 548 Type *Int64 = IntegerType::get(AccessType->getContext(), 64);
lib/Analysis/ValueTracking.cpp 87 static unsigned getBitWidth(Type *Ty, const DataLayout &DL) {
1131 Type *SrcTy = I->getOperand(0)->getType();
1136 Type *ScalarTy = SrcTy->getScalarType();
1148 Type *SrcTy = I->getOperand(0)->getType();
1329 Type *IndexedTy = GTI.getIndexedType();
1644 Type *ScalarTy = V->getType()->getScalarType();
2381 Type *ScalarTy = V->getType()->getScalarType();
2673 Type *T = V->getType();
3195 auto *UndefInt8 = UndefValue::get(Type::getInt8Ty(Ctx));
3216 return Constant::getNullValue(Type::getInt8Ty(Ctx));
3221 Type *Ty = nullptr;
3223 Ty = Type::getInt16Ty(Ctx);
3225 Ty = Type::getInt32Ty(Ctx);
3227 Ty = Type::getInt64Ty(Ctx);
3249 Type::getIntNTy(Ctx, PS), false),
3292 static Value *BuildSubAggregate(Value *From, Value* To, Type *IndexedType,
3354 Type *IndexedType = ExtractValueInst::getIndexedType(From->getType(),
3512 Type *GVTy = GV->getValueType();
4965 Type *SrcTy = Cast1->getSrcTy();
5356 Type *OpTy = LHS->getType();
lib/Analysis/VectorUtils.cpp 169 Value *llvm::getUniqueCastUse(Value *Ptr, Loop *Lp, Type *Ty) {
235 Type *StripedOffRecurrenceCast = nullptr;
498 Type *Ty = (*MI)->getType();
lib/AsmParser/LLLexer.h 40 Type *TyVal;
60 Type *getTyVal() const { return TyVal; }
lib/AsmParser/LLParser.cpp 56 static std::string getTypeString(Type *T) {
82 Type *Ty = nullptr;
90 bool LLParser::parseTypeAtBeginning(Type *&Ty, unsigned &Read,
194 for (StringMap<std::pair<Type*, LocTy> >::iterator I =
438 Type *Result = nullptr;
443 std::pair<Type*, LocTy> &Entry = NumberedTypes[TypeID];
464 Type *Result = nullptr;
469 std::pair<Type*, LocTy> &Entry = NamedTypes[Name];
895 Type *Ty;
919 Type *AliaseeType = Aliasee->getType();
1040 Type *Ty = nullptr;
1376 Value *LLParser::checkValidVariableType(LocTy Loc, const Twine &Name, Type *Ty,
1381 Type *SuggestedTy = Ty;
1383 Type *TyInProgAS = cast<PointerType>(Ty)->getElementType()->getPointerTo(
1401 GlobalValue *LLParser::GetGlobalVal(const std::string &Name, Type *Ty,
1432 GlobalValue *LLParser::GetGlobalVal(unsigned ID, Type *Ty, LocTy Loc,
1614 Type *Ty;
2316 bool LLParser::ParseType(Type *&Result, const Twine &Msg, bool AllowVoid) {
2349 std::pair<Type*, LocTy> &Entry = NamedTypes[Lex.getStrVal()];
2364 std::pair<Type*, LocTy> &Entry = NumberedTypes[Lex.getUIntVal()];
2455 Type *ArgTy = nullptr;
2484 bool LLParser::ParseByValWithOptionalType(Type *&Result) {
2532 Type *Ty = nullptr;
2574 Type *ArgTy = nullptr;
2644 bool LLParser::ParseFunctionType(Type *&Result) {
2664 SmallVector<Type*, 16> ArgListTy;
2674 bool LLParser::ParseAnonStructType(Type *&Result, bool Packed) {
2675 SmallVector<Type*, 8> Elts;
2684 std::pair<Type*, LocTy> &Entry,
2685 Type *&ResultTy) {
2728 SmallVector<Type*, 8> Body;
2744 bool LLParser::ParseStructBody(SmallVectorImpl<Type*> &Body) {
2753 Type *Ty = nullptr;
2779 bool LLParser::ParseArrayVectorType(Type *&Result, bool isVector) {
2802 Type *EltTy = nullptr;
2874 Value *LLParser::PerFunctionState::GetVal(const std::string &Name, Type *Ty,
2909 Value *LLParser::PerFunctionState::GetVal(unsigned ID, Type *Ty, LocTy Loc,
3009 GetVal(Name, Type::getLabelTy(F.getContext()), Loc, /*IsCall=*/false));
3014 GetVal(ID, Type::getLabelTy(F.getContext()), Loc, /*IsCall=*/false));
3274 FwdRef = new GlobalVariable(*M, Type::getInt8Ty(Context), false,
3320 Type *DestTy = nullptr;
3369 Type *IndexedType =
3549 Type *Ty;
3576 Type *BaseType = Elts[0]->getType();
3588 Type *ValTy = Val->getType();
3603 SmallPtrSet<Type*, 4> Visited;
3659 bool LLParser::ParseGlobalValue(Type *Ty, Constant *&C) {
3671 Type *Ty = nullptr;
5068 Type *Ty;
5133 bool LLParser::ConvertValIDToValue(Type *Ty, ValID &ID, Value *&V,
5247 bool LLParser::parseConstantValue(Type *Ty, Constant *&C) {
5275 bool LLParser::ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS) {
5283 Type *Ty = nullptr;
5314 Type *RetType = nullptr;
5420 std::vector<Type*> ParamTypeList;
5896 Type *Ty = nullptr;
5899 Type *ResType = PFS.getFunction().getReturnType();
5935 if (Op0->getType() != Type::getInt1Ty(Context))
6045 Type *RetType = nullptr;
6071 std::vector<Type*> ParamTypes;
6098 Type *ExpectedTy = nullptr;
6157 Type *ArgTy = nullptr;
6184 if (ParseValue(Type::getTokenTy(Context), CleanupPad, PFS))
6213 if (ParseValue(Type::getTokenTy(Context), CatchPad, PFS))
6237 if (ParseValue(Type::getTokenTy(Context), ParentPad, PFS))
6286 if (ParseValue(Type::getTokenTy(Context), CatchSwitch, PFS))
6309 if (ParseValue(Type::getTokenTy(Context), ParentPad, PFS))
6355 Type *RetType = nullptr;
6398 std::vector<Type *> ParamTypes;
6428 Type *ExpectedTy = nullptr;
6547 Type *DestTy = nullptr;
6586 Type *EltTy = nullptr;
6658 Type *Ty = nullptr; LocTy TypeLoc;
6665 ParseValue(Type::getLabelTy(Context), Op1, PFS) ||
6686 ParseValue(Type::getLabelTy(Context), Op1, PFS) ||
6708 Type *Ty = nullptr; LocTy TyLoc;
6766 Type *RetType = nullptr;
6800 std::vector<Type*> ParamTypes;
6828 Type *ExpectedTy = nullptr;
6876 Type *Ty = nullptr;
6952 Type *Ty;
7188 Type *Ty = nullptr;
7195 Type *BaseType = Ptr->getType();
7230 SmallPtrSet<Type*, 4> Visited;
7276 Type *IndexedType = ExtractValueInst::getIndexedType(Val0->getType(), Indices);
lib/AsmParser/LLParser.h 118 StringMap<std::pair<Type*, LocTy> > NamedTypes;
119 std::map<unsigned, std::pair<Type*, LocTy> > NumberedTypes;
183 bool parseTypeAtBeginning(Type *&Ty, unsigned &Read,
204 GlobalValue *GetGlobalVal(const std::string &N, Type *Ty, LocTy Loc,
206 GlobalValue *GetGlobalVal(unsigned ID, Type *Ty, LocTy Loc, bool IsCall);
342 bool ParseByValWithOptionalType(Type *&Result);
390 bool ParseType(Type *&Result, const Twine &Msg, bool AllowVoid = false);
391 bool ParseType(Type *&Result, bool AllowVoid = false) {
394 bool ParseType(Type *&Result, const Twine &Msg, LocTy &Loc,
399 bool ParseType(Type *&Result, LocTy &Loc, bool AllowVoid = false) {
403 bool ParseAnonStructType(Type *&Result, bool Packed);
404 bool ParseStructBody(SmallVectorImpl<Type*> &Body);
406 std::pair<Type*, LocTy> &Entry,
407 Type *&ResultTy);
409 bool ParseArrayVectorType(Type *&Result, bool isVector);
410 bool ParseFunctionType(Type *&Result);
434 Value *GetVal(const std::string &Name, Type *Ty, LocTy Loc, bool IsCall);
435 Value *GetVal(unsigned ID, Type *Ty, LocTy Loc, bool IsCall);
456 bool ConvertValIDToValue(Type *Ty, ValID &ID, Value *&V,
459 Value *checkValidVariableType(LocTy Loc, const Twine &Name, Type *Ty,
462 bool parseConstantValue(Type *Ty, Constant *&C);
463 bool ParseValue(Type *Ty, Value *&V, PerFunctionState *PFS);
464 bool ParseValue(Type *Ty, Value *&V, PerFunctionState &PFS) {
468 bool ParseValue(Type *Ty, Value *&V, LocTy &Loc,
511 bool ParseGlobalValue(Type *Ty, Constant *&C);
545 Type *Ty;
548 ArgInfo(LocTy L, Type *ty, AttributeSet Attr, const std::string &N)
lib/AsmParser/Parser.cpp 159 Type *llvm::parseType(StringRef Asm, SMDiagnostic &Err, const Module &M,
162 Type *Ty = parseTypeAtBeginning(Asm, Read, Err, M, Slots);
175 Type *llvm::parseTypeAtBeginning(StringRef Asm, unsigned &Read,
181 Type *Ty;
lib/Bitcode/Reader/BitcodeReader.cpp 496 std::vector<Type*> TypeList;
600 Type *flattenPointerTypes(Type *Ty) {
600 Type *flattenPointerTypes(Type *Ty) {
606 Type *getPointerElementFlatType(Type *Ty) {
606 Type *getPointerElementFlatType(Type *Ty) {
613 std::pair<Type *, Type *> getPointerElementTypes(Type *FullTy) {
613 std::pair<Type *, Type *> getPointerElementTypes(Type *FullTy) {
613 std::pair<Type *, Type *> getPointerElementTypes(Type *FullTy) {
614 Type *ElTy = cast<PointerType>(FullTy)->getElementType();
620 Type *getTypeByID(unsigned ID) {
626 Type *getFullyStructuredTypeByID(unsigned ID);
628 Value *getFnValueByID(unsigned ID, Type *Ty, Type **FullTy = nullptr) {
628 Value *getFnValueByID(unsigned ID, Type *Ty, Type **FullTy = nullptr) {
654 Type **FullTy = nullptr) {
680 unsigned InstNum, Type *Ty, Value *&ResVal) {
690 unsigned InstNum, Type *Ty, Value *&ResVal) {
698 unsigned InstNum, Type *Ty) {
709 unsigned InstNum, Type *Ty) {
720 void propagateByValTypes(CallBase *CB, ArrayRef<Type *> ArgsFullTys);
753 Error typeCheckLoadStoreInst(Type *ValType, Type *PtrType);
753 Error typeCheckLoadStoreInst(Type *ValType, Type *PtrType);
1057 static int getDecodedUnaryOpcode(unsigned Val, Type *Ty) {
1071 static int getDecodedBinaryOpcode(unsigned Val, Type *Ty) {
1185 Type *BitcodeReader::getFullyStructuredTypeByID(unsigned ID) {
1190 if (Type *Ty = TypeList[ID])
1708 Type *ResultTy = nullptr;
1723 ResultTy = Type::getVoidTy(Context);
1726 ResultTy = Type::getHalfTy(Context);
1729 ResultTy = Type::getFloatTy(Context);
1732 ResultTy = Type::getDoubleTy(Context);
1735 ResultTy = Type::getX86_FP80Ty(Context);
1738 ResultTy = Type::getFP128Ty(Context);
1741 ResultTy = Type::getPPC_FP128Ty(Context);
1744 ResultTy = Type::getLabelTy(Context);
1747 ResultTy = Type::getMetadataTy(Context);
1750 ResultTy = Type::getX86_MMXTy(Context);
1753 ResultTy = Type::getTokenTy(Context);
1785 SmallVector<Type*, 8> ArgTys;
1787 if (Type *T = getTypeByID(Record[i]))
1804 SmallVector<Type*, 8> ArgTys;
1806 if (Type *T = getTypeByID(Record[i])) {
1825 SmallVector<Type*, 8> EltTys;
1827 if (Type *T = getTypeByID(Record[i]))
1858 SmallVector<Type*, 8> EltTys;
1860 if (Type *T = getTypeByID(Record[i]))
2330 Type *CurTy = Type::getInt32Ty(Context);
2330 Type *CurTy = Type::getInt32Ty(Context);
2331 Type *CurFullTy = Type::getInt32Ty(Context);
2331 Type *CurFullTy = Type::getInt32Ty(Context);
2359 Type *VoidType = Type::getVoidTy(Context);
2359 Type *VoidType = Type::getVoidTy(Context);
2442 Type *EltTy = ATy->getElementType();
2447 Type *EltTy = VTy->getElementType();
2470 Type *EltTy = cast<SequentialType>(CurTy)->getElementType();
2569 Type *OpTy = getTypeByID(Record[1]);
2583 Type *PointeeType = nullptr;
2598 Type *Elt0FullTy = nullptr;
2602 Type *ElTy = getTypeByID(Record[OpNum++]);
2611 Type *ImplicitPointeeType =
2628 Type *SelectorTy = Type::getInt1Ty(Context);
2628 Type *SelectorTy = Type::getInt1Ty(Context);
2654 Type *IdxTy = getTypeByID(Record[2]);
2659 Op1 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context));
2675 Type *IdxTy = getTypeByID(Record[2]);
2680 Op2 = ValueList.getConstantFwdRef(Record[2], Type::getInt32Ty(Context));
2692 Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
2692 Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
2706 Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
2706 Type *ShufTy = VectorType::get(Type::getInt32Ty(Context),
2715 Type *OpTy = getTypeByID(Record[0]);
2782 Type *FnTy = getTypeByID(Record[0]);
3097 Type *FullTy = getFullyStructuredTypeByID(Record[0]);
3098 Type *Ty = flattenPointerTypes(FullTy);
3202 Type *FullFTy = getFullyStructuredTypeByID(Record[0]);
3203 Type *FTy = flattenPointerTypes(FullFTy);
3240 Type *PTy = cast<FunctionType>(FullFTy)->getParamType(i);
3303 Type *FullTy = PointerType::get(FullFTy, AddrSpace);
3335 Type *FullTy = getFullyStructuredTypeByID(Record[OpNum++]);
3336 Type *Ty = flattenPointerTypes(FullTy);
3667 Error BitcodeReader::typeCheckLoadStoreInst(Type *ValType, Type *PtrType) {
3667 Error BitcodeReader::typeCheckLoadStoreInst(Type *ValType, Type *PtrType) {
3670 Type *ElemType = cast<PointerType>(PtrType)->getElementType();
3681 ArrayRef<Type *> ArgsFullTys) {
3785 Type *FullTy = nullptr;
3931 Type *ResTy = flattenPointerTypes(FullTy);
3955 Type *Ty;
3968 Type *FullBaseTy = nullptr;
4049 Type *CurTy = Agg->getType();
4086 popValue(Record, OpNum, NextValueNo, Type::getInt1Ty(Context), Cond))
4108 if (vector_type->getElementType() != Type::getInt1Ty(Context))
4112 if (Cond->getType() != Type::getInt1Ty(Context))
4245 Type::getInt1Ty(Context));
4258 getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
4277 getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
4296 getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
4335 getValue(Record, Idx++, NextValueNo, Type::getTokenTy(Context));
4365 Type *OpTy = getTypeByID(Record[1]);
4423 Type *OpTy = getTypeByID(Record[0]);
4447 Type *OpTy = getTypeByID(Record[0]);
4506 SmallVector<Type *, 16> ArgsFullTys;
4522 Type *FullTy;
4636 Type *Ty = flattenPointerTypes(FullTy);
4690 Type *Ty = flattenPointerTypes(FullTy);
4744 Type *Ty = flattenPointerTypes(FullTy);
4751 Type *OpTy = getTypeByID(Record[1]);
4782 Type *Ty = nullptr;
4810 Type *Ty = nullptr;
4840 Type *FullTy;
4863 Type *FullTy;
4933 FullTy = StructType::get(Context, {FullTy, Type::getInt1Ty(Context)});
5034 SmallVector<Type*, 16> ArgsFullTys;
5054 Type *FullTy;
5089 Type *OpTy = getTypeByID(Record[0]);
5092 Type *ResTy = flattenPointerTypes(FullTy);
lib/Bitcode/Reader/MetadataLoader.cpp 427 std::function<Type *(unsigned)> getTypeByID;
637 std::function<Type *(unsigned)> getTypeByID,
1152 Type *Ty = getTypeByID(Record[0]);
1172 Type *Ty = getTypeByID(Record[i]);
1194 Type *Ty = getTypeByID(Record[0]);
2135 std::function<Type *(unsigned)> getTypeByID)
lib/Bitcode/Reader/MetadataLoader.h 44 std::function<Type *(unsigned)> getTypeByID);
lib/Bitcode/Reader/ValueList.cpp 38 explicit ConstantPlaceHolder(Type *Ty, LLVMContext &Context)
40 Op<0>() = UndefValue::get(Type::getInt32Ty(Context));
68 void BitcodeReaderValueList::assignValue(Value *V, unsigned Idx, Type *FullTy) {
99 Constant *BitcodeReaderValueList::getConstantFwdRef(unsigned Idx, Type *Ty) {
119 Value *BitcodeReaderValueList::getValueFwdRef(unsigned Idx, Type *Ty,
120 Type **FullTy) {
lib/Bitcode/Reader/ValueList.h 36 std::vector<Type *> FullTypes;
69 void push_back(Value *V, Type *Ty) {
98 Constant *getConstantFwdRef(unsigned Idx, Type *Ty);
99 Value *getValueFwdRef(unsigned Idx, Type *Ty, Type **FullTy = nullptr);
99 Value *getValueFwdRef(unsigned Idx, Type *Ty, Type **FullTy = nullptr);
101 void assignValue(Value *V, unsigned Idx, Type *FullTy);
lib/Bitcode/Writer/BitcodeWriter.cpp 772 Type *Ty = Attr.getValueAsType();
870 Type *T = TypeList[i];
875 case Type::VoidTyID: Code = bitc::TYPE_CODE_VOID; break;
876 case Type::HalfTyID: Code = bitc::TYPE_CODE_HALF; break;
877 case Type::FloatTyID: Code = bitc::TYPE_CODE_FLOAT; break;
878 case Type::DoubleTyID: Code = bitc::TYPE_CODE_DOUBLE; break;
879 case Type::X86_FP80TyID: Code = bitc::TYPE_CODE_X86_FP80; break;
880 case Type::FP128TyID: Code = bitc::TYPE_CODE_FP128; break;
881 case Type::PPC_FP128TyID: Code = bitc::TYPE_CODE_PPC_FP128; break;
882 case Type::LabelTyID: Code = bitc::TYPE_CODE_LABEL; break;
883 case Type::MetadataTyID: Code = bitc::TYPE_CODE_METADATA; break;
884 case Type::X86_MMXTyID: Code = bitc::TYPE_CODE_X86_MMX; break;
885 case Type::TokenTyID: Code = bitc::TYPE_CODE_TOKEN; break;
886 case Type::IntegerTyID:
891 case Type::PointerTyID: {
901 case Type::FunctionTyID: {
912 case Type::StructTyID: {
939 case Type::ArrayTyID: {
948 case Type::VectorTyID: {
2308 Type *LastTy = nullptr;
2365 Type *Ty = CFP->getType();
2413 Type *EltTy = CDS->getType()->getElementType();
lib/Bitcode/Writer/ValueEnumerator.cpp 372 EnumerateType(Type::getMetadataTy(M.getContext()));
854 void ValueEnumerator::EnumerateType(Type *Ty) {
870 for (Type *SubTy : Ty->subtypes())
lib/Bitcode/Writer/ValueEnumerator.h 46 using TypeList = std::vector<Type *>;
58 using TypeMapType = DenseMap<Type *, unsigned>;
167 unsigned getTypeID(Type *T) const {
293 void EnumerateType(Type *T);
lib/CodeGen/Analysis.cpp 35 unsigned llvm::ComputeLinearIndex(Type *Ty,
58 Type *EltTy = ATy->getElementType();
84 Type *Ty, SmallVectorImpl<EVT> &ValueVTs,
101 Type *EltTy = ATy->getElementType();
120 Type *Ty, SmallVectorImpl<EVT> &ValueVTs,
127 void llvm::computeValueLLTs(const DataLayout &DL, Type &Ty,
141 Type *EltTy = ATy->getElementType();
255 static bool isNoopBitcast(Type *T1, Type *T2,
255 static bool isNoopBitcast(Type *T1, Type *T2,
438 Type *DeeperType = SubTypes.back()->getTypeAtIndex(Path.back());
463 static bool firstRealType(Type *Next,
674 Type *SlotType = RetSubTypes.back()->getTypeAtIndex(RetPath.back());
lib/CodeGen/AsmPrinter/AsmPrinter.cpp 1773 Type *Ty = CPE.getType();
2243 Type *Ty = CE->getType();
2323 static void emitGlobalConstantFP(APFloat APF, Type *ET, AsmPrinter &AP);
2401 Type *ET = CDS->getElementType();
2473 static void emitGlobalConstantFP(APFloat APF, Type *ET, AsmPrinter &AP) {
lib/CodeGen/AtomicExpandPass.cpp 72 IntegerType *getCorrespondingIntegerType(Type *T, const DataLayout &DL);
81 insertRMWLLSCLoop(IRBuilder<> &Builder, Type *ResultTy, Value *Addr,
85 Instruction *I, Type *ResultTy, Value *Addr, AtomicOrdering MemOpOrder,
97 IRBuilder<> &Builder, Type *ResultType, Value *Addr,
361 IntegerType *AtomicExpand::getCorrespondingIntegerType(Type *T,
374 Type *NewTy = getCorrespondingIntegerType(LI->getType(),
380 Type *PT = PointerType::get(NewTy,
437 Type *Ty = cast<PointerType>(Addr->getType())->getElementType();
462 Type *NewTy = getCorrespondingIntegerType(SI->getValueOperand()->getType(),
467 Type *PT = PointerType::get(NewTy,
501 Type *OrigTy = NewVal->getType();
612 Type *WordType;
613 Type *ValueType;
639 Type *ValueType, Value *Addr,
655 Ret.WordType = Type::getIntNTy(Ctx, WordSize * 8);
657 Type *WordPtrType =
936 Instruction *I, Type *ResultType, Value *Addr, AtomicOrdering MemOpOrder,
1003 IRBuilder<> &Builder, Type *ResultTy, Value *Addr,
1055 Type *NewTy = getCorrespondingIntegerType(CI->getCompareOperand()->getType(),
1061 Type *PT = PointerType::get(NewTy,
1210 StoreSuccess, ConstantInt::get(Type::getInt32Ty(Ctx), 0), "success");
1252 PHINode *Success = Builder.CreatePHI(Type::getInt1Ty(Ctx), 2);
1345 IRBuilder<> &Builder, Type *ResultTy, Value *Addr,
1622 Type *SizedIntTy = Type::getIntNTy(Ctx, Size * 8);
1622 Type *SizedIntTy = Type::getIntNTy(Ctx, Size * 8);
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));
1638 bool HasResult = I->getType() != Type::getVoidTy(Ctx);
1690 Type *ResultTy;
1707 Type::getInt8PtrTy(Ctx, PtrTypeAS));
1708 PtrVal = Builder.CreateAddrSpaceCast(PtrVal, Type::getInt8PtrTy(Ctx));
1719 Type::getInt8PtrTy(Ctx, AllocaAS));
1735 Builder.CreateBitCast(AllocaValue, Type::getInt8PtrTy(Ctx));
1748 Builder.CreateBitCast(AllocaResult, Type::getInt8PtrTy(Ctx, AllocaAS));
1762 ResultTy = Type::getInt1Ty(Ctx);
1767 ResultTy = Type::getVoidTy(Ctx);
1770 SmallVector<Type *, 6> ArgTys;
1787 Type *FinalResultTy = I->getType();
lib/CodeGen/BuiltinGCs.cpp 75 Optional<bool> isGCManagedPointer(const Type *Ty) const override {
107 Optional<bool> isGCManagedPointer(const Type *Ty) const override {
lib/CodeGen/CodeGenPrepare.cpp 237 using TypeIsSExt = PointerIntPair<Type *, 2, ExtType>;
361 Type *AccessTy, unsigned AddrSpace);
1730 Type *Ty = CountZeros->getType();
1914 Type *AccessTy;
2146 Value *GetFieldAsValue(FieldName Field, Type *IntPtrTy) {
2414 TruncBuilder(Instruction *Opnd, Type *Ty) : TypePromotionAction(Opnd) {
2439 SExtBuilder(Instruction *InsertPt, Value *Opnd, Type *Ty)
2465 ZExtBuilder(Instruction *InsertPt, Value *Opnd, Type *Ty)
2486 Type *OrigTy;
2490 TypeMutator(Instruction *Inst, Type *NewTy)
2642 void mutateType(Instruction *Inst, Type *NewTy);
2645 Value *createTrunc(Instruction *Opnd, Type *Ty);
2648 Value *createSExt(Instruction *Inst, Value *Opnd, Type *Ty);
2651 Value *createZExt(Instruction *Inst, Value *Opnd, Type *Ty);
2687 void TypePromotionTransaction::mutateType(Instruction *Inst, Type *NewTy) {
2693 Type *Ty) {
2701 Value *Opnd, Type *Ty) {
2709 Value *Opnd, Type *Ty) {
2756 Type *AccessTy;
2782 const TargetRegisterInfo &TRI, Type *AT, unsigned AS, Instruction *MI,
2802 Match(Value *V, Type *AccessTy, unsigned AS, Instruction *MemoryInst,
3052 void destroyNewNodes(Type *CommonType) {
3084 Type *CommonType;
3198 Type *IntPtrTy = SQ.DL.getIntPtrType(AddrModes[0].OriginalValue->getType());
3202 auto *Type = DV->getType();
3611 static const Type *getOrigType(const InstrToOrigTy &PromotedInsts,
3632 static bool canGetThrough(const Instruction *Inst, Type *ConsideredExtType,
3719 Type *ConsideredExtType,
3807 const Type *OpndType = getOrigType(PromotedInsts, Opnd, IsSExt);
3826 Type *ExtTy = Ext->getType();
4598 Type *AddressAccessTy = AddrTy->getElementType();
4659 Type *AccessTy, unsigned AddrSpace) {
4783 Type *IntPtrTy = DL->getIntPtrType(Addr->getType());
4810 Type *ScaledRegTy = AddrMode.ScaledReg->getType();
4844 Type *I8PtrTy =
4846 Type *I8Ty = Builder.getInt8Ty();
4918 Type *BaseTy = AddrMode.BaseReg ? AddrMode.BaseReg->getType() : nullptr;
4919 Type *ScaleTy = AddrMode.Scale ? AddrMode.ScaledReg->getType() : nullptr;
4931 Type *IntPtrTy = DL->getIntPtrType(Addr->getType());
5062 Type *ExtTy = FirstUser->getType();
5067 Type *CurTy = UI->getType();
5086 Type *NarrowTy;
5087 Type *LargeTy;
5331 Type *IntPtrTy = DL->getIntPtrType(GEP->getType());
5332 Type *I8PtrTy =
5333 Type::getInt8PtrTy(Ctx, GEP->getType()->getPointerAddressSpace());
5334 Type *I8Ty = Type::getInt8Ty(Ctx);
5334 Type *I8Ty = Type::getInt8Ty(Ctx);
5791 Type *TruncTy = Type::getIntNTy(Ctx, ActiveBits);
5791 Type *TruncTy = Type::getIntNTy(Ctx, ActiveBits);
5911 Type *Ty = Shift->getType();
6229 Type *OldType = Cond->getType();
6243 auto *NewType = Type::getIntNTy(Context, RegWidth);
6339 Type *getTransitionType() const {
6359 Type *PromotedType = getTransitionType();
6560 Type *TransitionTy = getTransitionType();
6677 Type *StoreType = SI.getValueOperand()->getType();
6683 Type *SplitStoreType = Type::getIntNTy(SI.getContext(), HalfValBitSize);
6683 Type *SplitStoreType = Type::getIntNTy(SI.getContext(), HalfValBitSize);
6744 ConstantInt::get(Type::getInt32Ty(SI.getContext()), 1));
lib/CodeGen/DwarfEHPrepare.cpp 210 FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
211 Type::getInt8PtrTy(Ctx), false);
234 PHINode *PN = PHINode::Create(Type::getInt8PtrTy(Ctx), ResumesLeft,
lib/CodeGen/ExpandMemCmp.cpp 102 Value *getPtrToElementAtOffset(Value *Source, Type *LoadSizeType,
263 Type *LoadSizeType,
266 auto *ByteType = Type::getInt8Ty(CI->getContext());
281 Type *LoadSizeType = Type::getInt8Ty(CI->getContext());
281 Type *LoadSizeType = Type::getInt8Ty(CI->getContext());
290 LoadSrc1 = Builder.CreateZExt(LoadSrc1, Type::getInt32Ty(CI->getContext()));
291 LoadSrc2 = Builder.CreateZExt(LoadSrc2, Type::getInt32Ty(CI->getContext()));
420 Value *Zero = ConstantInt::get(Type::getInt32Ty(CI->getContext()), 0);
443 Type *LoadSizeType =
445 Type *MaxLoadType = IntegerType::get(CI->getContext(), MaxLoadSize * 8);
491 Value *Zero = ConstantInt::get(Type::getInt32Ty(CI->getContext()), 0);
505 Value *Res = ConstantInt::get(Type::getInt32Ty(CI->getContext()), 1);
527 Type *MaxLoadType = IntegerType::get(CI->getContext(), MaxLoadSize * 8);
538 PhiRes = Builder.CreatePHI(Type::getInt32Ty(CI->getContext()), 2, "phi.res");
560 return Builder.CreateZExt(Cmp, Type::getInt32Ty(CI->getContext()));
566 Type *LoadSizeType = IntegerType::get(CI->getContext(), Size * 8);
lib/CodeGen/GlobalISel/CallLowering.cpp 97 Type *ElementTy = cast<PointerType>(Arg.Ty)->getElementType();
126 Register CallLowering::packRegs(ArrayRef<Register> SrcRegs, Type *PackedTy,
152 Type *PackedTy,
lib/CodeGen/GlobalISel/CombinerHelper.cpp 883 static Type *getTypeForLLT(LLT Ty, LLVMContext &C) {
956 Type *IRTy = getTypeForLLT(MemOps[0], C);
1075 Type *IRTy = getTypeForLLT(MemOps[0], C);
1182 Type *IRTy = getTypeForLLT(MemOps[0], C);
lib/CodeGen/GlobalISel/IRTranslator.cpp 245 Type *ValTy = nullptr;
515 Type *PtrIRTy = Type::getInt8PtrTy(MF->getFunction().getContext());
515 Type *PtrIRTy = Type::getInt8PtrTy(MF->getFunction().getContext());
538 Type *PtrIRTy = SValue.getType()->getPointerTo();
873 Type *OffsetIRTy = DL->getIntPtrType(LI.getPointerOperandType());
915 Type *OffsetIRTy = DL->getIntPtrType(SI.getPointerOperandType());
944 Type *Int32Ty = Type::getInt32Ty(U.getContext());
944 Type *Int32Ty = Type::getInt32Ty(U.getContext());
1057 Type *PtrIRTy = Op0.getType();
1059 Type *OffsetIRTy = DL->getIntPtrType(PtrIRTy);
1759 for (Type *Ty : cast<StructType>(LP.getType())->elements())
1803 Type *Ty = AI.getAllocatedType();
1809 Type *IntPtrIRTy = DL->getIntPtrType(AI.getType());
1951 Type *ResType = I.getType();
1952 Type *ValType = ResType->Type::getStructElementType(0);
1979 Type *ResType = I.getType();
2120 auto *ZeroTy = Type::getIntNTy(C.getContext(), NullSize);
lib/CodeGen/GlobalISel/LegalizerHelper.cpp 381 Type *OpType) {
404 Type *OpTy = nullptr;
406 OpTy = Type::getInt8PtrTy(Ctx, OpLLT.getAddressSpace());
436 Info.OrigRet = CallLowering::ArgInfo({0}, Type::getVoidTy(Ctx));
459 static RTLIB::Libcall getConvRTLibDesc(unsigned Opcode, Type *ToType,
460 Type *FromType) {
482 conversionLibcall(MachineInstr &MI, MachineIRBuilder &MIRBuilder, Type *ToType,
483 Type *FromType) {
505 Type *HLTy = IntegerType::get(Ctx, Size);
531 Type *HLTy = Size == 64 ? Type::getDoubleTy(Ctx) : Type::getFloatTy(Ctx);
531 Type *HLTy = Size == 64 ? Type::getDoubleTy(Ctx) : Type::getFloatTy(Ctx);
531 Type *HLTy = Size == 64 ? Type::getDoubleTy(Ctx) : Type::getFloatTy(Ctx);
544 MI, MIRBuilder, Type::getDoubleTy(Ctx), Type::getFloatTy(Ctx));
544 MI, MIRBuilder, Type::getDoubleTy(Ctx), Type::getFloatTy(Ctx));
556 MI, MIRBuilder, Type::getFloatTy(Ctx), Type::getDoubleTy(Ctx));
556 MI, MIRBuilder, Type::getFloatTy(Ctx), Type::getDoubleTy(Ctx));
570 ToSize == 32 ? Type::getInt32Ty(Ctx) : Type::getInt64Ty(Ctx),
570 ToSize == 32 ? Type::getInt32Ty(Ctx) : Type::getInt64Ty(Ctx),
571 FromSize == 64 ? Type::getDoubleTy(Ctx) : Type::getFloatTy(Ctx));
571 FromSize == 64 ? Type::getDoubleTy(Ctx) : Type::getFloatTy(Ctx));
585 ToSize == 64 ? Type::getDoubleTy(Ctx) : Type::getFloatTy(Ctx),
585 ToSize == 64 ? Type::getDoubleTy(Ctx) : Type::getFloatTy(Ctx),
586 FromSize == 32 ? Type::getInt32Ty(Ctx) : Type::getInt64Ty(Ctx));
586 FromSize == 32 ? Type::getInt32Ty(Ctx) : Type::getInt64Ty(Ctx));
1981 Type *ZeroTy;
1985 ZeroTy = Type::getHalfTy(Ctx);
1988 ZeroTy = Type::getFloatTy(Ctx);
1991 ZeroTy = Type::getDoubleTy(Ctx);
1994 ZeroTy = Type::getFP128Ty(Ctx);
lib/CodeGen/GlobalMerge.cpp 441 Type *Int32Ty = Type::getInt32Ty(M.getContext());
441 Type *Int32Ty = Type::getInt32Ty(M.getContext());
442 Type *Int8Ty = Type::getInt8Ty(M.getContext());
442 Type *Int8Ty = Type::getInt8Ty(M.getContext());
453 std::vector<Type*> Tys;
462 Type *Ty = Globals[j]->getValueType();
638 Type *Ty = GV.getValueType();
lib/CodeGen/HardwareLoops.cpp 163 Type *CountType = nullptr;
372 Type *Ty = LoopCountInit->getType();
lib/CodeGen/InterleavedAccessPass.cpp 320 Type *VecTy = Shuffles[0]->getType();
lib/CodeGen/InterleavedLoadCombinePass.cpp 888 ConstantInt::get(Type::getInt32Ty(LI->getContext()), 0),
889 ConstantInt::get(Type::getInt32Ty(LI->getContext()), i),
1200 Type *ETy = InterleavedLoad.front().SVI->getType()->getElementType();
lib/CodeGen/IntrinsicLowering.cpp 33 Type *RetTy) {
38 std::vector<Type *> ParamTys;
217 case Type::FloatTyID:
219 Type::getFloatTy(CI->getContext()));
221 case Type::DoubleTyID:
223 Type::getDoubleTy(CI->getContext()));
225 case Type::X86_FP80TyID:
226 case Type::FP128TyID:
227 case Type::PPC_FP128TyID:
263 Type::getInt32Ty(Context));
275 Type::getVoidTy(Context));
282 Type::getVoidTy(Context));
351 CI->replaceAllUsesWith(ConstantInt::get(Type::getInt64Ty(Context), 0));
375 Type *IntPtr = DL.getIntPtrType(Context);
386 Type *IntPtr = DL.getIntPtrType(Context);
398 Type *IntPtr = DL.getIntPtrType(Op0->getType());
405 Type::getInt32Ty(Context),
lib/CodeGen/LowLevelType.cpp 20 LLT llvm::getLLTForType(Type &Ty, const DataLayout &DL) {
lib/CodeGen/LowerEmuTLS.cpp 86 PointerType *VoidPtrType = Type::getInt8PtrTy(C);
117 Type *ElementTypes[4] = {WordType, WordType, VoidPtrType, InitPtrType};
118 ArrayRef<Type*> ElementTypeArray(ElementTypes, 4);
128 Type *GVType = GV->getValueType();
lib/CodeGen/MIRParser/MIParser.cpp 2300 Type *I32Ty = Type::getInt32Ty(Ctx);
2300 Type *I32Ty = Type::getInt32Ty(Ctx);
lib/CodeGen/MIRParser/MIRParser.cpp 263 Function::Create(FunctionType::get(Type::getVoidTy(Context), false),
lib/CodeGen/MachineFunction.cpp 968 Type *MachineConstantPoolEntry::getType() const {
1036 Type *IntTy = IntegerType::get(A->getContext(), StoreSize*8);
lib/CodeGen/MachineOutliner.cpp 1100 Function *F = Function::Create(FunctionType::get(Type::getVoidTy(C), false),
lib/CodeGen/MachinePipeliner.cpp 663 UndefValue::get(Type::getVoidTy(MF.getFunction().getContext()));
lib/CodeGen/PreISelIntrinsicLowering.cpp 33 Type *Int32Ty = Type::getInt32Ty(F.getContext());
33 Type *Int32Ty = Type::getInt32Ty(F.getContext());
34 Type *Int32PtrTy = Int32Ty->getPointerTo();
35 Type *Int8Ty = Type::getInt8Ty(F.getContext());
35 Type *Int8Ty = Type::getInt8Ty(F.getContext());
lib/CodeGen/SafeStack.cpp 130 Type *StackPtrTy;
131 Type *IntPtrTy;
132 Type *Int32Ty;
133 Type *Int8Ty;
209 StackPtrTy(Type::getInt8PtrTy(F.getContext())),
211 Int32Ty(Type::getInt32Ty(F.getContext())),
212 Int8Ty(Type::getInt8Ty(F.getContext())) {}
502 Type *Ty = StackGuardSlot->getAllocatedType();
510 Type *Ty = Arg->getType()->getPointerElementType();
522 Type *Ty = AI->getAllocatedType();
566 Type *Ty = Arg->getType()->getPointerElementType();
651 Type *Ty = AI->getAllocatedType();
lib/CodeGen/ScalarizeMaskedMemIntrin.cpp 135 Type *EltTy = VecType->getElementType();
155 Type *NewPtrType =
180 Type *SclrMaskTy = Builder.getIntNTy(VectorWidth);
273 Type *EltTy = VecType->getElementType();
291 Type *NewPtrType =
312 Type *SclrMaskTy = Builder.getIntNTy(VectorWidth);
396 Type *EltTy = VecType->getElementType();
430 Type *SclrMaskTy = Builder.getIntNTy(VectorWidth);
552 Type *SclrMaskTy = Builder.getIntNTy(VectorWidth);
605 Type *EltTy = VecType->getElementType();
641 Type *SclrMaskTy = Builder.getIntNTy(VectorWidth);
725 Type *EltTy = VecType->getVectorElementType();
749 Type *SclrMaskTy = Builder.getIntNTy(VectorWidth);
lib/CodeGen/ScheduleDAGInstrs.cpp 116 Type::getVoidTy(mf.getFunction().getContext()))), Topo(SUnits, &ExitSU) {
lib/CodeGen/SelectionDAG/DAGCombiner.cpp 922 Type *AccessTy = VT.getTypeForEVT(*DAG.getContext());
14928 Type *NewVTTy = NewVT.getTypeForEVT(*DAG.getContext());
14987 Type *IntVTTy = IntVT.getTypeForEVT(*DAG.getContext());
20001 Type *FPTy = Elts[0]->getType();
lib/CodeGen/SelectionDAG/FastISel.cpp 704 Type *Ty = GTI.getIndexedType();
887 Type *RetTy = ForceRetVoidTy ? Type::getVoidTy(CI->getType()->getContext())
887 Type *RetTy = ForceRetVoidTy ? Type::getVoidTy(CI->getType()->getContext())
895 const DataLayout &DL, MCContext &Ctx, CallingConv::ID CC, Type *ResultTy,
1110 Type *RetTy = CS.getType();
1174 Type *FinalType = Arg.Ty;
1208 Type *ElementTy = Ty->getElementType();
1252 Type *RetTy = CS.getType();
1766 Type *AggTy = Op0->getType();
2391 Type *ValTy;
lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp 136 Type *Ty = AI->getAllocatedType();
362 unsigned FunctionLoweringInfo::CreateRegs(Type *Ty, bool isDivergent) {
412 Type *Ty = PN->getType();
lib/CodeGen/SelectionDAG/InstrEmitter.cpp 413 Type *Type = CP->getType();
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp 321 Type *SType = SVT.getTypeForEVT(*DAG.getContext());
1759 Type *DestType = DestVT.getTypeForEVT(*DAG.getContext());
1957 Type *OpNTy = EltVT.getTypeForEVT(*DAG.getContext());
2028 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
2039 Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
2092 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
2102 Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext());
2203 Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
2209 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
2298 Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
2332 TLI.getLibcallCallingConv(LC), Type::getVoidTy(*DAG.getContext()), Callee,
2428 Type::getInt64Ty(*DAG.getContext()), FF);
3766 CallingConv::C, Type::getVoidTy(*DAG.getContext()),
3807 .setLibCallee(CallingConv::C, Type::getVoidTy(*DAG.getContext()),
lib/CodeGen/SelectionDAG/LegalizeIntegerTypes.cpp 3415 Type *RetTy = VT.getTypeForEVT(*DAG.getContext());
3417 Type *PtrTy = PtrVT.getTypeForEVT(*DAG.getContext());
3439 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
lib/CodeGen/SelectionDAG/LegalizeTypes.cpp 1014 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
1024 Type *RetTy = Node->getValueType(0).getTypeForEVT(*DAG.getContext());
lib/CodeGen/SelectionDAG/LegalizeVectorTypes.cpp 1199 Type *VecType = VecVT.getTypeForEVT(*DAG.getContext());
1496 Type *VecType = VecVT.getTypeForEVT(*DAG.getContext());
lib/CodeGen/SelectionDAG/SelectionDAG.cpp 989 Type *Ty = VT == MVT::iPTR ?
990 PointerType::get(Type::getInt8Ty(*getContext()), 0) :
1947 Type *Ty = VT.getTypeForEVT(*getContext());
1957 Type *Ty1 = VT1.getTypeForEVT(*getContext());
1958 Type *Ty2 = VT2.getTypeForEVT(*getContext());
2924 Type *CstTy = Cst->getType();
3904 Type *CstTy = Cst->getType();
5705 Type *Ty = VT.getTypeForEVT(*DAG.getContext());
5812 Type *Ty = MemOps[0].getTypeForEVT(C);
5994 Type *Ty = MemOps[0].getTypeForEVT(C);
6095 Type *Ty = MemOps[0].getTypeForEVT(*DAG.getContext());
6212 Entry.Ty = Type::getInt8PtrTy(*getContext());
6237 SDValue Size, Type *SizeTy,
6264 Type::getVoidTy(*getContext()),
6316 Entry.Ty = Type::getInt8PtrTy(*getContext());
6341 SDValue Size, Type *SizeTy,
6368 Type::getVoidTy(*getContext()),
6415 Entry.Node = Dst; Entry.Ty = Type::getInt8PtrTy(*getContext());
6442 SDValue Value, SDValue Size, Type *SizeTy,
6452 Entry.Ty = Type::getInt8Ty(*getContext());
6469 Type::getVoidTy(*getContext()),
9354 Type *ConstantPoolSDNode::getType() const {
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp 776 const DataLayout &DL, unsigned Reg, Type *Ty,
1370 SDValue SelectionDAGBuilder::getCopyFromRegs(const Value *V, Type *Ty) {
2517 unsigned Align = DL->getPrefTypeAlignment(Type::getInt8PtrTy(M.getContext()));
2963 Type *Ty = I.getType();
3749 Type *AggTy = I.getType();
3750 Type *ValTy = Op1->getType();
3802 Type *AggTy = Op0->getType();
3803 Type *ValTy = I.getType();
3952 Type *Ty = I.getAllocatedType();
4021 Type *Ty = I.getType();
4159 Type *Ty = I.getType();
5761 Type *LengthTy = MI.getLength()->getType();
5779 Type *LengthTy = MI.getLength()->getType();
5796 Type *LengthTy = MI.getLength()->getType();
7101 Type *RetTy = CS.getType();
7204 Type *LoadTy =
7205 Type::getIntNTy(PtrVal->getContext(), LoadVT.getScalarSizeInBits());
7761 llvm::Type *OpTy = CallOperandVal->getType();
7858 Type *Ty = OpVal->getType();
8415 llvm::Type *CSResultType = CS.getType();
8416 ArrayRef<Type *> ResultTypes;
8622 unsigned ArgIdx, unsigned NumArgs, SDValue Callee, Type *ReturnTy,
8785 Type *ReturnTy =
8786 IsAnyRegCC ? Type::getVoidTy(*DAG.getContext()) : CS->getType();
8990 Type *OrigRetTy = CLI.RetTy;
9032 Type *StackSlotPtrType = PointerType::get(CLI.RetTy,
9052 CLI.RetTy = Type::getVoidTy(CLI.RetTy->getContext());
9115 Type *FinalType = Args[i].Ty;
9123 Type *ArgTy = VT.getTypeForEVT(CLI.RetTy->getContext());
9176 Type *ElementTy = Ty->getElementType();
9294 Type *PtrRetTy = OrigRetTy->getPointerTo(DL.getAllocaAddrSpace());
9617 Type *FinalType = Arg.getType();
9625 Type *ArgTy = VT.getTypeForEVT(*DAG.getContext());
9679 Type *ElementTy = Arg.getParamByValType();
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.h 474 SDValue getCopyFromRegs(const Value *V, Type *Ty);
551 Type *ReturnTy, bool IsPatchPoint);
842 const DataLayout &DL, unsigned Reg, Type *Ty,
lib/CodeGen/SelectionDAG/StatepointLowering.cpp 892 Type *RetTy = ISP.getActualReturnType();
932 ForceVoidReturnTy ? Type::getVoidTy(*DAG.getContext()) : Call->getType(),
979 Type *RetTy =
999 auto *Ty = Relocate.getType()->getScalarType();
lib/CodeGen/SelectionDAG/TargetLowering.cpp 150 Type *RetTy = RetVT.getTypeForEVT(*DAG.getContext());
4233 llvm::Type *OpTy = OpInfo.CallOperandVal->getType();
6825 PointerType *VoidPtrType = Type::getInt8PtrTy(*DAG.getContext());
lib/CodeGen/ShadowStackGCLowering.cpp 74 Type *GetConcreteStackEntryType(Function &F);
78 Type *Ty, Value *BasePtr, int Idx1,
81 Type *Ty, Value *BasePtr, int Idx1, int Idx2,
103 Type *VoidPtr = Type::getInt8PtrTy(F.getContext());
103 Type *VoidPtr = Type::getInt8PtrTy(F.getContext());
116 Type *Int32Ty = Type::getInt32Ty(F.getContext());
116 Type *Int32Ty = Type::getInt32Ty(F.getContext());
127 Type *EltTys[] = {DescriptorElts[0]->getType(), DescriptorElts[1]->getType()};
150 ConstantInt::get(Type::getInt32Ty(F.getContext()), 0),
151 ConstantInt::get(Type::getInt32Ty(F.getContext()), 0)};
155 Type *ShadowStackGCLowering::GetConcreteStackEntryType(Function &F) {
157 std::vector<Type *> EltTys;
183 std::vector<Type *> EltTys;
185 EltTys.push_back(Type::getInt32Ty(M.getContext()));
187 EltTys.push_back(Type::getInt32Ty(M.getContext()));
256 IRBuilder<> &B, Type *Ty,
260 Value *Indices[] = {ConstantInt::get(Type::getInt32Ty(Context), 0),
261 ConstantInt::get(Type::getInt32Ty(Context), Idx),
262 ConstantInt::get(Type::getInt32Ty(Context), Idx2)};
271 IRBuilder<> &B, Type *Ty, Value *BasePtr,
273 Value *Indices[] = {ConstantInt::get(Type::getInt32Ty(Context), 0),
274 ConstantInt::get(Type::getInt32Ty(Context), Idx)};
301 Type *ConcreteStackEntryTy = GetConcreteStackEntryType(F);
lib/CodeGen/SjLjEHPrepare.cpp 39 Type *doubleUnderDataTy;
40 Type *doubleUnderJBufTy;
41 Type *FunctionContextTy;
85 Type *VoidPtrTy = Type::getInt8PtrTy(M.getContext());
85 Type *VoidPtrTy = Type::getInt8PtrTy(M.getContext());
86 Type *Int32Ty = Type::getInt32Ty(M.getContext());
86 Type *Int32Ty = Type::getInt32Ty(M.getContext());
106 Type *Int32Ty = Type::getInt32Ty(I->getContext());
106 Type *Int32Ty = Type::getInt32Ty(I->getContext());
115 ConstantInt::get(Type::getInt32Ty(I->getContext()), Number);
158 Type *LPadType = LPI->getType();
192 Type *Int32Ty = Type::getInt32Ty(F.getContext());
192 Type *Int32Ty = Type::getInt32Ty(F.getContext());
243 Type *Ty = AI.getType();
420 ConstantInt::get(Type::getInt32Ty(F.getContext()), I + 1);
475 "_Unwind_SjLj_Register", Type::getVoidTy(M.getContext()),
478 "_Unwind_SjLj_Unregister", Type::getVoidTy(M.getContext()),
482 {Type::getInt8PtrTy(M.getContext(),
lib/CodeGen/StackProtector.cpp 112 bool StackProtector::ContainsProtectableArray(Type *Ty, bool &IsLarge,
386 PointerType *PtrTy = Type::getInt8PtrTy(RI->getContext());
530 "__stack_smash_handler", Type::getVoidTy(Context),
531 Type::getInt8PtrTy(Context));
536 M->getOrInsertFunction("__stack_chk_fail", Type::getVoidTy(Context));
lib/CodeGen/TargetLoweringBase.cpp 1463 void llvm::GetReturnInfo(CallingConv::ID CC, Type *ReturnType,
1515 unsigned TargetLoweringBase::getByValTypeAlignment(Type *Ty,
1528 Type *Ty = VT.getTypeForEVT(Context);
1651 Type *Ty) const {
1686 Type *StackPtrTy = Type::getInt8PtrTy(M->getContext());
1686 Type *StackPtrTy = Type::getInt8PtrTy(M->getContext());
1716 Type *StackPtrTy = Type::getInt8PtrTy(M->getContext());
1716 Type *StackPtrTy = Type::getInt8PtrTy(M->getContext());
1729 const AddrMode &AM, Type *Ty,
1772 PointerType *PtrTy = Type::getInt8PtrTy(M.getContext());
1782 new GlobalVariable(M, Type::getInt8PtrTy(M.getContext()), false,
lib/CodeGen/TargetLoweringObjectFileImpl.cpp 1611 Type *Ty = C->getType();
lib/CodeGen/ValueTypes.cpp 264 Type *EVT::getTypeForEVT(LLVMContext &Context) const {
269 case MVT::isVoid: return Type::getVoidTy(Context);
270 case MVT::i1: return Type::getInt1Ty(Context);
271 case MVT::i8: return Type::getInt8Ty(Context);
272 case MVT::i16: return Type::getInt16Ty(Context);
273 case MVT::i32: return Type::getInt32Ty(Context);
274 case MVT::i64: return Type::getInt64Ty(Context);
276 case MVT::f16: return Type::getHalfTy(Context);
277 case MVT::f32: return Type::getFloatTy(Context);
278 case MVT::f64: return Type::getDoubleTy(Context);
279 case MVT::f80: return Type::getX86_FP80Ty(Context);
280 case MVT::f128: return Type::getFP128Ty(Context);
281 case MVT::ppcf128: return Type::getPPC_FP128Ty(Context);
282 case MVT::x86mmx: return Type::getX86_MMXTy(Context);
283 case MVT::v1i1: return VectorType::get(Type::getInt1Ty(Context), 1);
284 case MVT::v2i1: return VectorType::get(Type::getInt1Ty(Context), 2);
285 case MVT::v4i1: return VectorType::get(Type::getInt1Ty(Context), 4);
286 case MVT::v8i1: return VectorType::get(Type::getInt1Ty(Context), 8);
287 case MVT::v16i1: return VectorType::get(Type::getInt1Ty(Context), 16);
288 case MVT::v32i1: return VectorType::get(Type::getInt1Ty(Context), 32);
289 case MVT::v64i1: return VectorType::get(Type::getInt1Ty(Context), 64);
290 case MVT::v128i1: return VectorType::get(Type::getInt1Ty(Context), 128);
291 case MVT::v256i1: return VectorType::get(Type::getInt1Ty(Context), 256);
292 case MVT::v512i1: return VectorType::get(Type::getInt1Ty(Context), 512);
293 case MVT::v1024i1: return VectorType::get(Type::getInt1Ty(Context), 1024);
294 case MVT::v1i8: return VectorType::get(Type::getInt8Ty(Context), 1);
295 case MVT::v2i8: return VectorType::get(Type::getInt8Ty(Context), 2);
296 case MVT::v4i8: return VectorType::get(Type::getInt8Ty(Context), 4);
297 case MVT::v8i8: return VectorType::get(Type::getInt8Ty(Context), 8);
298 case MVT::v16i8: return VectorType::get(Type::getInt8Ty(Context), 16);
299 case MVT::v32i8: return VectorType::get(Type::getInt8Ty(Context), 32);
300 case MVT::v64i8: return VectorType::get(Type::getInt8Ty(Context), 64);
301 case MVT::v128i8: return VectorType::get(Type::getInt8Ty(Context), 128);
302 case MVT::v256i8: return VectorType::get(Type::getInt8Ty(Context), 256);
303 case MVT::v1i16: return VectorType::get(Type::getInt16Ty(Context), 1);
304 case MVT::v2i16: return VectorType::get(Type::getInt16Ty(Context), 2);
305 case MVT::v3i16: return VectorType::get(Type::getInt16Ty(Context), 3);
306 case MVT::v4i16: return VectorType::get(Type::getInt16Ty(Context), 4);
307 case MVT::v8i16: return VectorType::get(Type::getInt16Ty(Context), 8);
308 case MVT::v16i16: return VectorType::get(Type::getInt16Ty(Context), 16);
309 case MVT::v32i16: return VectorType::get(Type::getInt16Ty(Context), 32);
310 case MVT::v64i16: return VectorType::get(Type::getInt16Ty(Context), 64);
311 case MVT::v128i16: return VectorType::get(Type::getInt16Ty(Context), 128);
312 case MVT::v1i32: return VectorType::get(Type::getInt32Ty(Context), 1);
313 case MVT::v2i32: return VectorType::get(Type::getInt32Ty(Context), 2);
314 case MVT::v3i32: return VectorType::get(Type::getInt32Ty(Context), 3);
315 case MVT::v4i32: return VectorType::get(Type::getInt32Ty(Context), 4);
316 case MVT::v5i32: return VectorType::get(Type::getInt32Ty(Context), 5);
317 case MVT::v8i32: return VectorType::get(Type::getInt32Ty(Context), 8);
318 case MVT::v16i32: return VectorType::get(Type::getInt32Ty(Context), 16);
319 case MVT::v32i32: return VectorType::get(Type::getInt32Ty(Context), 32);
320 case MVT::v64i32: return VectorType::get(Type::getInt32Ty(Context), 64);
321 case MVT::v128i32: return VectorType::get(Type::getInt32Ty(Context), 128);
322 case MVT::v256i32: return VectorType::get(Type::getInt32Ty(Context), 256);
323 case MVT::v512i32: return VectorType::get(Type::getInt32Ty(Context), 512);
324 case MVT::v1024i32:return VectorType::get(Type::getInt32Ty(Context), 1024);
325 case MVT::v2048i32:return VectorType::get(Type::getInt32Ty(Context), 2048);
326 case MVT::v1i64: return VectorType::get(Type::getInt64Ty(Context), 1);
327 case MVT::v2i64: return VectorType::get(Type::getInt64Ty(Context), 2);
328 case MVT::v4i64: return VectorType::get(Type::getInt64Ty(Context), 4);
329 case MVT::v8i64: return VectorType::get(Type::getInt64Ty(Context), 8);
330 case MVT::v16i64: return VectorType::get(Type::getInt64Ty(Context), 16);
331 case MVT::v32i64: return VectorType::get(Type::getInt64Ty(Context), 32);
332 case MVT::v1i128: return VectorType::get(Type::getInt128Ty(Context), 1);
333 case MVT::v2f16: return VectorType::get(Type::getHalfTy(Context), 2);
334 case MVT::v3f16: return VectorType::get(Type::getHalfTy(Context), 3);
335 case MVT::v4f16: return VectorType::get(Type::getHalfTy(Context), 4);
336 case MVT::v8f16: return VectorType::get(Type::getHalfTy(Context), 8);
337 case MVT::v16f16: return VectorType::get(Type::getHalfTy(Context), 16);
338 case MVT::v32f16: return VectorType::get(Type::getHalfTy(Context), 32);
339 case MVT::v1f32: return VectorType::get(Type::getFloatTy(Context), 1);
340 case MVT::v2f32: return VectorType::get(Type::getFloatTy(Context), 2);
341 case MVT::v3f32: return VectorType::get(Type::getFloatTy(Context), 3);
342 case MVT::v4f32: return VectorType::get(Type::getFloatTy(Context), 4);
343 case MVT::v5f32: return VectorType::get(Type::getFloatTy(Context), 5);
344 case MVT::v8f32: return VectorType::get(Type::getFloatTy(Context), 8);
345 case MVT::v16f32: return VectorType::get(Type::getFloatTy(Context), 16);
346 case MVT::v32f32: return VectorType::get(Type::getFloatTy(Context), 32);
347 case MVT::v64f32: return VectorType::get(Type::getFloatTy(Context), 64);
348 case MVT::v128f32: return VectorType::get(Type::getFloatTy(Context), 128);
349 case MVT::v256f32: return VectorType::get(Type::getFloatTy(Context), 256);
350 case MVT::v512f32: return VectorType::get(Type::getFloatTy(Context), 512);
351 case MVT::v1024f32:return VectorType::get(Type::getFloatTy(Context), 1024);
352 case MVT::v2048f32:return VectorType::get(Type::getFloatTy(Context), 2048);
353 case MVT::v1f64: return VectorType::get(Type::getDoubleTy(Context), 1);
354 case MVT::v2f64: return VectorType::get(Type::getDoubleTy(Context), 2);
355 case MVT::v4f64: return VectorType::get(Type::getDoubleTy(Context), 4);
356 case MVT::v8f64: return VectorType::get(Type::getDoubleTy(Context), 8);
358 return VectorType::get(Type::getInt1Ty(Context), 1, /*Scalable=*/ true);
360 return VectorType::get(Type::getInt1Ty(Context), 2, /*Scalable=*/ true);
362 return VectorType::get(Type::getInt1Ty(Context), 4, /*Scalable=*/ true);
364 return VectorType::get(Type::getInt1Ty(Context), 8, /*Scalable=*/ true);
366 return VectorType::get(Type::getInt1Ty(Context), 16, /*Scalable=*/ true);
368 return VectorType::get(Type::getInt1Ty(Context), 32, /*Scalable=*/ true);
370 return VectorType::get(Type::getInt8Ty(Context), 1, /*Scalable=*/ true);
372 return VectorType::get(Type::getInt8Ty(Context), 2, /*Scalable=*/ true);
374 return VectorType::get(Type::getInt8Ty(Context), 4, /*Scalable=*/ true);
376 return VectorType::get(Type::getInt8Ty(Context), 8, /*Scalable=*/ true);
378 return VectorType::get(Type::getInt8Ty(Context), 16, /*Scalable=*/ true);
380 return VectorType::get(Type::getInt8Ty(Context), 32, /*Scalable=*/ true);
382 return VectorType::get(Type::getInt16Ty(Context), 1, /*Scalable=*/ true);
384 return VectorType::get(Type::getInt16Ty(Context), 2, /*Scalable=*/ true);
386 return VectorType::get(Type::getInt16Ty(Context), 4, /*Scalable=*/ true);
388 return VectorType::get(Type::getInt16Ty(Context), 8, /*Scalable=*/ true);
390 return VectorType::get(Type::getInt16Ty(Context), 16, /*Scalable=*/ true);
392 return VectorType::get(Type::getInt16Ty(Context), 32, /*Scalable=*/ true);
394 return VectorType::get(Type::getInt32Ty(Context), 1, /*Scalable=*/ true);
396 return VectorType::get(Type::getInt32Ty(Context), 2, /*Scalable=*/ true);
398 return VectorType::get(Type::getInt32Ty(Context), 4, /*Scalable=*/ true);
400 return VectorType::get(Type::getInt32Ty(Context), 8, /*Scalable=*/ true);
402 return VectorType::get(Type::getInt32Ty(Context), 16,/*Scalable=*/ true);
404 return VectorType::get(Type::getInt32Ty(Context), 32,/*Scalable=*/ true);
406 return VectorType::get(Type::getInt64Ty(Context), 1, /*Scalable=*/ true);
408 return VectorType::get(Type::getInt64Ty(Context), 2, /*Scalable=*/ true);
410 return VectorType::get(Type::getInt64Ty(Context), 4, /*Scalable=*/ true);
412 return VectorType::get(Type::getInt64Ty(Context), 8, /*Scalable=*/ true);
414 return VectorType::get(Type::getInt64Ty(Context), 16, /*Scalable=*/ true);
416 return VectorType::get(Type::getInt64Ty(Context), 32, /*Scalable=*/ true);
418 return VectorType::get(Type::getHalfTy(Context), 2, /*Scalable=*/ true);
420 return VectorType::get(Type::getHalfTy(Context), 4, /*Scalable=*/ true);
422 return VectorType::get(Type::getHalfTy(Context), 8, /*Scalable=*/ true);
424 return VectorType::get(Type::getFloatTy(Context), 1, /*Scalable=*/ true);
426 return VectorType::get(Type::getFloatTy(Context), 2, /*Scalable=*/ true);
428 return VectorType::get(Type::getFloatTy(Context), 4, /*Scalable=*/ true);
430 return VectorType::get(Type::getFloatTy(Context), 8, /*Scalable=*/ true);
432 return VectorType::get(Type::getFloatTy(Context), 16, /*Scalable=*/ true);
434 return VectorType::get(Type::getDoubleTy(Context), 1, /*Scalable=*/ true);
436 return VectorType::get(Type::getDoubleTy(Context), 2, /*Scalable=*/ true);
438 return VectorType::get(Type::getDoubleTy(Context), 4, /*Scalable=*/ true);
440 return VectorType::get(Type::getDoubleTy(Context), 8, /*Scalable=*/ true);
441 case MVT::Metadata: return Type::getMetadataTy(Context);
448 MVT MVT::getVT(Type *Ty, bool HandleUnknown){
453 case Type::VoidTyID:
455 case Type::IntegerTyID:
457 case Type::HalfTyID: return MVT(MVT::f16);
458 case Type::FloatTyID: return MVT(MVT::f32);
459 case Type::DoubleTyID: return MVT(MVT::f64);
460 case Type::X86_FP80TyID: return MVT(MVT::f80);
461 case Type::X86_MMXTyID: return MVT(MVT::x86mmx);
462 case Type::FP128TyID: return MVT(MVT::f128);
463 case Type::PPC_FP128TyID: return MVT(MVT::ppcf128);
464 case Type::PointerTyID: return MVT(MVT::iPTR);
465 case Type::VectorTyID: {
477 EVT EVT::getEVT(Type *Ty, bool HandleUnknown){
481 case Type::IntegerTyID:
483 case Type::VectorTyID: {
lib/CodeGen/WasmEHPrepare.cpp 99 Type *LPadContextTy = nullptr; // type of 'struct _Unwind_LandingPadContext'
lib/ExecutionEngine/ExecutionEngine.cpp 108 Type *ElTy = GV->getValueType();
346 Type *SBytePtr = Type::getInt8PtrTy(C);
346 Type *SBytePtr = Type::getInt8PtrTy(C);
436 Type* PPInt8Ty = Type::getInt8PtrTy(Fn->getContext())->getPointerTo();
436 Type* PPInt8Ty = Type::getInt8PtrTy(Fn->getContext())->getPointerTo();
601 case Type::IntegerTyID:
602 case Type::X86_FP80TyID:
603 case Type::FP128TyID:
604 case Type::PPC_FP128TyID:
609 case Type::StructTyID: {
615 Type *ElemTy = STy->getElementType(i);
627 case Type::VectorTyID:
630 Type *ElemTy = VTy->getElementType();
754 Type* DestTy = CE->getType();
757 case Type::IntegerTyID:
764 case Type::FloatTyID:
768 case Type::DoubleTyID:
772 case Type::PointerTyID:
796 case Type::IntegerTyID:
811 case Type::FloatTyID:
826 case Type::DoubleTyID:
841 case Type::X86_FP80TyID:
842 case Type::PPC_FP128TyID:
843 case Type::FP128TyID: {
890 case Type::FloatTyID:
893 case Type::DoubleTyID:
896 case Type::X86_FP80TyID:
897 case Type::FP128TyID:
898 case Type::PPC_FP128TyID:
901 case Type::IntegerTyID:
904 case Type::PointerTyID:
917 case Type::VectorTyID: {
919 Type* ElemTy;
1023 GenericValue *Ptr, Type *Ty) {
1030 case Type::IntegerTyID:
1033 case Type::FloatTyID:
1036 case Type::DoubleTyID:
1039 case Type::X86_FP80TyID:
1042 case Type::PointerTyID:
1049 case Type::VectorTyID:
1073 Type *Ty) {
1077 case Type::IntegerTyID:
1082 case Type::FloatTyID:
1085 case Type::DoubleTyID:
1088 case Type::PointerTyID:
1091 case Type::X86_FP80TyID: {
1099 case Type::VectorTyID: {
1101 Type *ElemT = VT->getElementType();
1192 std::map<std::pair<std::string, Type*>,
1305 Type *ElTy = GV->getValueType();
lib/ExecutionEngine/ExecutionEngineBindings.cpp 57 case Type::FloatTyID:
60 case Type::DoubleTyID:
88 case Type::FloatTyID:
90 case Type::DoubleTyID:
lib/ExecutionEngine/Interpreter/Execution.cpp 49 static void executeFNegInst(GenericValue &Dest, GenericValue Src, Type *Ty) {
51 case Type::FloatTyID:
54 case Type::DoubleTyID:
64 Type *Ty = I.getOperand(0)->getType();
109 GenericValue Src2, Type *Ty) {
120 GenericValue Src2, Type *Ty) {
131 GenericValue Src2, Type *Ty) {
142 GenericValue Src2, Type *Ty) {
153 GenericValue Src2, Type *Ty) {
155 case Type::FloatTyID:
158 case Type::DoubleTyID:
192 Type *Ty) {
206 Type *Ty) {
220 Type *Ty) {
234 Type *Ty) {
248 Type *Ty) {
262 Type *Ty) {
276 Type *Ty) {
290 Type *Ty) {
304 Type *Ty) {
318 Type *Ty) {
333 Type *Ty = I.getOperand(0)->getType();
379 Type *Ty) {
429 Type *Ty)
455 Type *Ty) {
469 Type *Ty) {
483 Type *Ty) {
497 Type *Ty) {
532 Type *Ty) {
542 Type *Ty) {
551 Type *Ty) {
560 Type *Ty) {
569 Type *Ty) {
578 Type *Ty) {
587 Type *Ty) {
618 Type *Ty) {
649 Type *Ty, const bool val) {
665 Type *Ty = I.getOperand(0)->getType();
699 GenericValue Src2, Type *Ty) {
736 Type *Ty = I.getOperand(0)->getType();
844 GenericValue Src3, Type *Ty) {
861 Type * Ty = I.getOperand(0)->getType();
890 void Interpreter::popStackAndReturnValueToCaller(Type *RetTy,
918 Type *RetTy = Type::getVoidTy(I.getContext());
918 Type *RetTy = Type::getVoidTy(I.getContext());
950 Type *ElTy = Cond->getType();
1018 Type *Ty = I.getType()->getElementType(); // Type to be allocated
1194 Type *Ty = I.getType();
1221 Type *Ty = I.getType();
1248 Type *Ty = I.getType();
1270 GenericValue Interpreter::executeTruncInst(Value *SrcVal, Type *DstTy,
1273 Type *SrcTy = SrcVal->getType();
1275 Type *DstVecTy = DstTy->getScalarType();
1290 GenericValue Interpreter::executeSExtInst(Value *SrcVal, Type *DstTy,
1292 Type *SrcTy = SrcVal->getType();
1295 Type *DstVecTy = DstTy->getScalarType();
1310 GenericValue Interpreter::executeZExtInst(Value *SrcVal, Type *DstTy,
1312 Type *SrcTy = SrcVal->getType();
1315 Type *DstVecTy = DstTy->getScalarType();
1331 GenericValue Interpreter::executeFPTruncInst(Value *SrcVal, Type *DstTy,
1335 if (SrcVal->getType()->getTypeID() == Type::VectorTyID) {
1354 GenericValue Interpreter::executeFPExtInst(Value *SrcVal, Type *DstTy,
1358 if (SrcVal->getType()->getTypeID() == Type::VectorTyID) {
1376 GenericValue Interpreter::executeFPToUIInst(Value *SrcVal, Type *DstTy,
1378 Type *SrcTy = SrcVal->getType();
1381 if (SrcTy->getTypeID() == Type::VectorTyID) {
1382 Type *DstVecTy = DstTy->getScalarType();
1383 Type *SrcVecTy = SrcTy->getScalarType();
1389 if (SrcVecTy->getTypeID() == Type::FloatTyID) {
1404 if (SrcTy->getTypeID() == Type::FloatTyID)
1414 GenericValue Interpreter::executeFPToSIInst(Value *SrcVal, Type *DstTy,
1416 Type *SrcTy = SrcVal->getType();
1419 if (SrcTy->getTypeID() == Type::VectorTyID) {
1420 Type *DstVecTy = DstTy->getScalarType();
1421 Type *SrcVecTy = SrcTy->getScalarType();
1427 if (SrcVecTy->getTypeID() == Type::FloatTyID) {
1442 if (SrcTy->getTypeID() == Type::FloatTyID)
1451 GenericValue Interpreter::executeUIToFPInst(Value *SrcVal, Type *DstTy,
1455 if (SrcVal->getType()->getTypeID() == Type::VectorTyID) {
1456 Type *DstVecTy = DstTy->getScalarType();
1461 if (DstVecTy->getTypeID() == Type::FloatTyID) {
1474 if (DstTy->getTypeID() == Type::FloatTyID)
1483 GenericValue Interpreter::executeSIToFPInst(Value *SrcVal, Type *DstTy,
1487 if (SrcVal->getType()->getTypeID() == Type::VectorTyID) {
1488 Type *DstVecTy = DstTy->getScalarType();
1493 if (DstVecTy->getTypeID() == Type::FloatTyID) {
1507 if (DstTy->getTypeID() == Type::FloatTyID)
1517 GenericValue Interpreter::executePtrToIntInst(Value *SrcVal, Type *DstTy,
1527 GenericValue Interpreter::executeIntToPtrInst(Value *SrcVal, Type *DstTy,
1540 GenericValue Interpreter::executeBitCastInst(Value *SrcVal, Type *DstTy,
1545 Type *SrcTy = SrcVal->getType();
1548 if ((SrcTy->getTypeID() == Type::VectorTyID) ||
1549 (DstTy->getTypeID() == Type::VectorTyID)) {
1554 Type *SrcElemTy;
1555 Type *DstElemTy;
1561 if (SrcTy->getTypeID() == Type::VectorTyID) {
1574 if (DstTy->getTypeID() == Type::VectorTyID) {
1647 if (DstTy->getTypeID() == Type::VectorTyID) {
1779 Type *Ty = I.getType();
1781 case Type::IntegerTyID:
1805 Type *Ty = I.getType();
1815 case Type::IntegerTyID:
1818 case Type::FloatTyID:
1821 case Type::DoubleTyID:
1841 Type *TyContained = Ty->getElementType();
1851 case Type::IntegerTyID:
1854 case Type::FloatTyID:
1857 case Type::DoubleTyID:
1878 Type *TyContained = Ty->getElementType();
1889 case Type::IntegerTyID:
1905 case Type::FloatTyID:
1916 case Type::DoubleTyID:
1947 Type *IndexedType = ExtractValueInst::getIndexedType(Agg->getType(), I.getIndices());
1952 case Type::IntegerTyID:
1955 case Type::FloatTyID:
1958 case Type::DoubleTyID:
1961 case Type::ArrayTyID:
1962 case Type::StructTyID:
1963 case Type::VectorTyID:
1966 case Type::PointerTyID:
1993 Type *IndexedType = ExtractValueInst::getIndexedType(Agg->getType(), I.getIndices());
1999 case Type::IntegerTyID:
2002 case Type::FloatTyID:
2005 case Type::DoubleTyID:
2008 case Type::ArrayTyID:
2009 case Type::StructTyID:
2010 case Type::VectorTyID:
2013 case Type::PointerTyID:
2071 Type * Ty = CE->getOperand(0)->getType();
lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp 73 static char getTypeID(Type *Ty) {
75 case Type::VoidTyID: return 'V';
76 case Type::IntegerTyID:
85 case Type::FloatTyID: return 'F';
86 case Type::DoubleTyID: return 'D';
87 case Type::PointerTyID: return 'P';
88 case Type::FunctionTyID:return 'M';
89 case Type::StructTyID: return 'T';
90 case Type::ArrayTyID: return 'A';
106 for (Type *T : FT->params())
lib/ExecutionEngine/Interpreter/Interpreter.h 203 GenericValue executeTruncInst(Value *SrcVal, Type *DstTy,
205 GenericValue executeSExtInst(Value *SrcVal, Type *DstTy,
207 GenericValue executeZExtInst(Value *SrcVal, Type *DstTy,
209 GenericValue executeFPTruncInst(Value *SrcVal, Type *DstTy,
211 GenericValue executeFPExtInst(Value *SrcVal, Type *DstTy,
213 GenericValue executeFPToUIInst(Value *SrcVal, Type *DstTy,
215 GenericValue executeFPToSIInst(Value *SrcVal, Type *DstTy,
217 GenericValue executeUIToFPInst(Value *SrcVal, Type *DstTy,
219 GenericValue executeSIToFPInst(Value *SrcVal, Type *DstTy,
221 GenericValue executePtrToIntInst(Value *SrcVal, Type *DstTy,
223 GenericValue executeIntToPtrInst(Value *SrcVal, Type *DstTy,
225 GenericValue executeBitCastInst(Value *SrcVal, Type *DstTy,
228 Type *Ty, ExecutionContext &SF);
229 void popStackAndReturnValueToCaller(Type *RetTy, GenericValue Result);
lib/ExecutionEngine/MCJIT/MCJIT.cpp 514 Type *RetTy = FTy->getReturnType();
570 case Type::IntegerTyID: {
586 case Type::VoidTyID:
589 case Type::FloatTyID:
592 case Type::DoubleTyID:
595 case Type::X86_FP80TyID:
596 case Type::FP128TyID:
597 case Type::PPC_FP128TyID:
599 case Type::PointerTyID:
lib/ExecutionEngine/Orc/IndirectionUtils.cpp 221 ConstantInt::get(Type::getInt64Ty(FT.getContext()), Addr);
lib/ExecutionEngine/Orc/OrcMCJITReplacement.cpp 33 Type *RetTy = FTy->getReturnType();
89 case Type::IntegerTyID: {
105 case Type::VoidTyID:
108 case Type::FloatTyID:
111 case Type::DoubleTyID:
114 case Type::X86_FP80TyID:
115 case Type::FP128TyID:
116 case Type::PPC_FP128TyID:
118 case Type::PointerTyID:
lib/ExecutionEngine/Orc/Speculation.cpp 73 Type::getVoidTy(MContext),
74 {SpeculatorVTy->getPointerTo(), Type::getInt64Ty(MContext)}, false);
94 auto LoadValueTy = Type::getInt8Ty(MContext);
123 Mutator.CreatePtrToInt(&Fn, Type::getInt64Ty(MContext));
lib/FuzzMutate/IRMutator.cpp 28 Function *F = Function::Create(FunctionType::get(Type::getVoidTy(Context), {},
56 std::vector<Type *> Types;
lib/FuzzMutate/OpDescriptor.cpp 15 void fuzzerop::makeConstantsWithType(Type *T, std::vector<Constant *> &Cs) {
33 std::vector<Constant *> fuzzerop::makeConstantsWithType(Type *T) {
lib/FuzzMutate/Operations.cpp 172 Type *Ty = cast<PointerType>(Srcs[0]->getType())->getElementType();
182 static uint64_t getAggregateNumElements(Type *T) {
198 auto *Int32Ty = Type::getInt32Ty(Cur[0]->getContext());
256 auto *Int32Ty = Type::getInt32Ty(Cur[0]->getContext());
302 auto *Int32Ty = Type::getInt32Ty(Cur[0]->getContext());
lib/IR/AsmWriter.cpp 479 void print(Type *Ty, raw_ostream &OS);
557 void TypePrinting::print(Type *Ty, raw_ostream &OS) {
559 case Type::VoidTyID: OS << "void"; return;
560 case Type::HalfTyID: OS << "half"; return;
561 case Type::FloatTyID: OS << "float"; return;
562 case Type::DoubleTyID: OS << "double"; return;
563 case Type::X86_FP80TyID: OS << "x86_fp80"; return;
564 case Type::FP128TyID: OS << "fp128"; return;
565 case Type::PPC_FP128TyID: OS << "ppc_fp128"; return;
566 case Type::LabelTyID: OS << "label"; return;
567 case Type::MetadataTyID: OS << "metadata"; return;
568 case Type::X86_MMXTyID: OS << "x86_mmx"; return;
569 case Type::TokenTyID: OS << "token"; return;
570 case Type::IntegerTyID:
574 case Type::FunctionTyID: {
591 case Type::StructTyID: {
608 case Type::PointerTyID: {
616 case Type::ArrayTyID: {
623 case Type::VectorTyID: {
1398 Type *ETy = CA->getType()->getElementType();
1426 Type *ETy = CA->getType()->getElementType();
1475 Type *ETy = CV->getType()->getVectorElementType();
3848 Type *RetTy = FTy->getReturnType();
3887 Type *RetTy = FTy->getReturnType();
3930 Type *RetTy = FTy->getReturnType();
4026 Type *TheType = Operand->getType();
lib/IR/AttributeImpl.h 72 Type *getValueAsType() const;
100 Type *Ty) {
164 Type *Ty;
167 TypeAttributeImpl(Attribute::AttrKind Kind, Type *Ty)
170 Type *getTypeValue() const { return Ty; }
217 Type *getByValType() const;
lib/IR/Attributes.cpp 125 Type *Ty) {
167 Attribute Attribute::getWithByValType(LLVMContext &Context, Type *Ty) {
227 Type *Attribute::getValueAsType() const {
399 if (Type *Ty = getValueAsType()) {
539 Type *AttributeImpl::getValueAsType() const {
686 Type *AttributeSet::getByValType() const {
852 Type *AttributeSetNode::getByValType() const {
1359 Type *AttributeList::getParamByValType(unsigned Index) const {
1576 AttrBuilder &AttrBuilder::addByValAttr(Type *Ty) {
1697 AttrBuilder AttributeFuncs::typeIncompatible(Type *Ty) {
lib/IR/AutoUpgrade.cpp 41 Type *Arg0Type = F->getFunctionType()->getParamType(0);
42 if (Arg0Type != VectorType::get(Type::getFloatTy(F->getContext()), 4))
56 Type *LastArgType = F->getFunctionType()->getParamType(
508 Type* args[2] = {
510 Type::getInt1Ty(F->getContext())
528 SmallVector<Type *, 4> Tys(fArgs.begin(), fArgs.end());
549 Type *Tys[] = {fArgs[0], fArgs[1]};
612 Type *Tys[] = {F->getFunctionType()->getReturnType(), Args[1]};
626 Type* ObjectPtr[1] = {Args[1]};
640 Type* ObjectPtr[1] = {Args[IsLifetimeEnd ? 1 : 2]};
650 Type* ObjectPtr[1] = {Args[0]};
662 Type *Tys[] = { F->getReturnType(), F->arg_begin()->getType() };
673 Type *Tys[] = { Args[0], Args[1] };
685 Type *Tys[] = {F->getReturnType(), F->arg_begin()->getType()};
695 Type *Tys[] = {Args[0], Args[1]};
709 ArrayRef<Type *> ParamTypes = F->getFunctionType()->params().slice(0, 3);
717 ArrayRef<Type *> ParamTypes = F->getFunctionType()->params().slice(0, 3);
726 Type *ParamTypes[2] = {
775 Type *Tys[2] = { F->getReturnType(), F->arg_begin()->getType() };
789 Type *Tys[] = {F->arg_begin()->getType()};
872 Type *ResultTy = Op->getType();
876 Type *VecTy = VectorType::get(Builder.getInt8Ty(), NumElts);
906 Type *ResultTy = Op->getType();
910 Type *VecTy = VectorType::get(Builder.getInt8Ty(), NumElts);
1033 Type *Ty = CI.getType();
1094 Type *Ty = CI.getType();
1114 Type *Ty = CI.getType();
1141 Type *Ty = CI.getType();
1180 Type *Ty = CI.getType();
1235 Type *ValTy = Passthru->getType();
1254 llvm::Type *Ty = Op0->getType();
1280 Type *Ty = CI.getType();
1386 Type* ReturnOp = CI.getType();
1672 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(C), 1)));
1680 Type *SrcEltTy = cast<VectorType>(Arg1->getType())->getElementType();
1699 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(C), 1)));
1723 Type *NewVecTy = VectorType::get(Type::getInt64Ty(C), 2);
1723 Type *NewVecTy = VectorType::get(Type::getInt64Ty(C), 2);
1783 Type *ExtTy = Type::getInt32Ty(C);
1783 Type *ExtTy = Type::getInt32Ty(C);
1785 ExtTy = Type::getInt64Ty(C);
1829 llvm::Type *Ty = Op0->getType();
1908 Type *I32Ty = Type::getInt32Ty(C);
1908 Type *I32Ty = Type::getInt32Ty(C);
1929 Type *OpTy = CI->getArgOperand(0)->getType();
1943 Type *OpTy = CI->getArgOperand(0)->getType();
1966 Type *OpTy = CI->getArgOperand(0)->getType();
2084 Type *DstTy = CI->getType();
2086 Type *SrcTy = Rep->getType();
2124 Type *ResultTy = CI->getType();
2125 Type *PtrTy = ResultTy->getVectorElementType();
2139 Type *ResultTy = CI->getArgOperand(1)->getType();
2140 Type *PtrTy = ResultTy->getVectorElementType();
2155 Type *ResultTy = CI->getType();
2229 Value *Trunc0 = Builder.CreateTrunc(CI->getArgOperand(0), Type::getInt32Ty(C));
2235 Type *VecTy = CI->getType();
2236 Type *EltTy = VecTy->getVectorElementType();
2241 Type *I32Ty = Type::getInt32Ty(C);
2241 Type *I32Ty = Type::getInt32Ty(C);
2275 Type *Ty = CI->getArgOperand(1)->getType();
2282 Type *EltTy = CI->getType()->getVectorElementType();
2284 Type *VT = VectorType::get(EltTy, NumSrcElts);
2297 Type *VT = CI->getType();
2338 Type *MaskTy = VectorType::get(Type::getInt32Ty(C), NumElts);
2338 Type *MaskTy = VectorType::get(Type::getInt32Ty(C), NumElts);
3025 C, ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(C), 1)));
3610 if (Arg0->getType() != VectorType::get(Type::getFloatTy(C), 4))
3616 Type *NewVecTy = VectorType::get(Type::getInt64Ty(C), 2);
3616 Type *NewVecTy = VectorType::get(Type::getInt64Ty(C), 2);
3663 Args.back() = Builder.CreateTrunc(Args.back(), Type::getInt8Ty(C), "trunc");
3755 Constant::getNullValue(Type::getInt64Ty(Context))),
3761 Type::getInt64Ty(Context)))};
3765 Instruction *llvm::UpgradeBitCastInst(unsigned Opc, Value *V, Type *DestTy,
3771 Type *SrcTy = V->getType();
3778 Type *MidTy = Type::getInt64Ty(Context);
3778 Type *MidTy = Type::getInt64Ty(Context);
3787 Value *llvm::UpgradeBitCastExpr(unsigned Opc, Constant *C, Type *DestTy) {
3791 Type *SrcTy = C->getType();
3798 Type *MidTy = Type::getInt64Ty(Context);
3798 Type *MidTy = Type::getInt64Ty(Context);
4003 Type *Int32Ty = Type::getInt32Ty(M.getContext());
4003 Type *Int32Ty = Type::getInt32Ty(M.getContext());
lib/IR/BasicBlock.cpp 42 : Value(Type::getLabelTy(C), Value::BasicBlockVal), Parent(nullptr) {
73 ConstantInt::get(llvm::Type::getInt32Ty(getContext()), 1);
lib/IR/ConstantFold.cpp 57 Type *DstEltTy = DstTy->getElementType();
60 Type *Ty = IntegerType::get(CV->getContext(), 32);
79 Type *DstTy ///< destination type of the first cast
86 Type *SrcTy = Op->getOperand(0)->getType();
87 Type *MidTy = Op->getType();
94 IntegerType *FakeIntPtrTy = Type::getInt64Ty(DstTy->getContext());
101 static Constant *FoldBitCast(Constant *V, Type *DestTy) {
102 Type *SrcTy = V->getType();
114 Constant::getNullValue(Type::getInt32Ty(DPTy->getContext()));
116 Type *ElTy = PTy->getElementType();
353 static Constant *getFoldedSizeOf(Type *Ty, Type *DestTy, bool Folded) {
353 static Constant *getFoldedSizeOf(Type *Ty, Type *DestTy, bool Folded) {
408 static Constant *getFoldedAlignOf(Type *Ty, Type *DestTy, bool Folded) {
408 static Constant *getFoldedAlignOf(Type *Ty, Type *DestTy, bool Folded) {
472 static Constant *getFoldedOffsetOf(Type *Ty, Constant *FieldNo, Type *DestTy,
472 static Constant *getFoldedOffsetOf(Type *Ty, Constant *FieldNo, Type *DestTy,
522 Type *DestTy) {
577 Type *DstEltTy = DestVecTy->getElementType();
578 Type *Ty = IntegerType::get(V->getContext(), 32);
648 Type *Ty = GEPO->getSourceElementType();
742 Type *Ty = IntegerType::get(CondV->getContext(), 32);
842 auto *Ty = Type::getInt32Ty(Val->getContext());
861 Type *EltTy = V1->getType()->getVectorElementType();
884 Type *Ty = IntegerType::get(V2->getContext(), 32);
889 Type *Ty = IntegerType::get(V1->getContext(), 32);
972 Type *Ty = IntegerType::get(VTy->getContext(), 32);
1310 Type *Ty = IntegerType::get(VTy->getContext(), 32);
1380 static bool isMaybeZeroSizedType(Type *Ty) {
1402 static int IdxCompare(Constant *C1, Constant *C2, Type *ElTy) {
1505 Type *Ty = GVar->getValueType();
1787 Type *ResultTy;
1789 ResultTy = VectorType::get(Type::getInt1Ty(C1->getContext()),
1792 ResultTy = Type::getInt1Ty(C1->getContext());
1924 Type *Ty = IntegerType::get(C1->getContext(), 32);
2164 Constant *llvm::ConstantFoldGetElementPtr(Type *PointeeTy, Constant *C,
2170 Type *GEPTy = GetElementPtrInst::getGEPReturnType(
2193 Type *Ty = GetElementPtrInst::getIndexedType(PointeeTy, Idxs);
2196 Type *OrigGEPTy = PointerType::get(Ty, PtrTy->getAddressSpace());
2197 Type *GEPTy = PointerType::get(Ty, PtrTy->getAddressSpace());
2266 Type *IdxTy = Combined->getType();
2273 Type *CommonTy =
2274 Type::getIntNTy(IdxTy->getContext(), CommonExtendedWidth);
2333 Type *Ty = PointeeTy;
2334 Type *Prev = C->getType();
2436 Type *ExtendedTy = Type::getIntNTy(Div->getContext(), CommonExtendedWidth);
2436 Type *ExtendedTy = Type::getIntNTy(Div->getContext(), CommonExtendedWidth);
lib/IR/ConstantFold.h 33 Type *DestTy ///< The destination type
51 Constant *ConstantFoldGetElementPtr(Type *Ty, Constant *C, bool InBounds,
lib/IR/Constants.cpp 289 Constant *Constant::getNullValue(Type *Ty) {
291 case Type::IntegerTyID:
293 case Type::HalfTyID:
296 case Type::FloatTyID:
299 case Type::DoubleTyID:
302 case Type::X86_FP80TyID:
305 case Type::FP128TyID:
308 case Type::PPC_FP128TyID:
312 case Type::PointerTyID:
314 case Type::StructTyID:
315 case Type::ArrayTyID:
316 case Type::VectorTyID:
318 case Type::TokenTyID:
326 Constant *Constant::getIntegerValue(Type *Ty, const APInt &V) {
327 Type *ScalarTy = Ty->getScalarType();
343 Constant *Constant::getAllOnesValue(Type *Ty) {
612 pImpl->TheTrueVal = ConstantInt::get(Type::getInt1Ty(Context), 1);
619 pImpl->TheFalseVal = ConstantInt::get(Type::getInt1Ty(Context), 0);
623 Constant *ConstantInt::getTrue(Type *Ty) {
631 Constant *ConstantInt::getFalse(Type *Ty) {
653 Constant *ConstantInt::get(Type *Ty, uint64_t V, bool isSigned) {
671 Constant *ConstantInt::getSigned(Type *Ty, int64_t V) {
675 Constant *ConstantInt::get(Type *Ty, const APInt& V) {
700 static const fltSemantics *TypeToFloatSemantics(Type *Ty) {
716 Constant *ConstantFP::get(Type *Ty, double V) {
732 Constant *ConstantFP::get(Type *Ty, const APFloat &V) {
744 Constant *ConstantFP::get(Type *Ty, StringRef Str) {
757 Constant *ConstantFP::getNaN(Type *Ty, bool Negative, uint64_t Payload) {
768 Constant *ConstantFP::getQNaN(Type *Ty, bool Negative, APInt *Payload) {
779 Constant *ConstantFP::getSNaN(Type *Ty, bool Negative, APInt *Payload) {
790 Constant *ConstantFP::getNegativeZero(Type *Ty) {
802 Constant *ConstantFP::getZeroValueForNegation(Type *Ty) {
817 Type *Ty;
819 Ty = Type::getHalfTy(Context);
821 Ty = Type::getFloatTy(Context);
823 Ty = Type::getDoubleTy(Context);
825 Ty = Type::getX86_FP80Ty(Context);
827 Ty = Type::getFP128Ty(Context);
831 Ty = Type::getPPC_FP128Ty(Context);
839 Constant *ConstantFP::getInfinity(Type *Ty, bool Negative) {
849 ConstantFP::ConstantFP(Type *Ty, const APFloat &V)
889 Type *Ty = getType();
922 Type *Ty = getType();
1053 SmallVector<Type*, 16> EltTypes(VecSize);
1237 Constant *ConstantExpr::getWithOperands(ArrayRef<Constant *> Ops, Type *Ty,
1238 bool OnlyIfReduced, Type *SrcTy) const {
1245 Type *OnlyIfReducedTy = OnlyIfReduced ? Ty : nullptr;
1298 bool ConstantInt::isValueValidForType(Type *Ty, uint64_t Val) {
1305 bool ConstantInt::isValueValidForType(Type *Ty, int64_t Val) {
1312 bool ConstantFP::isValueValidForType(Type *Ty, const APFloat& Val) {
1321 case Type::HalfTyID: {
1327 case Type::FloatTyID: {
1333 case Type::DoubleTyID: {
1341 case Type::X86_FP80TyID:
1346 case Type::FP128TyID:
1351 case Type::PPC_FP128TyID:
1363 ConstantAggregateZero *ConstantAggregateZero::get(Type *Ty) {
1446 UndefValue *UndefValue::get(Type *Ty) {
1476 : Constant(Type::getInt8PtrTy(F->getContext()), Value::BlockAddressVal,
1543 static Constant *getFoldedCast(Instruction::CastOps opc, Constant *C, Type *Ty,
1561 Constant *ConstantExpr::getCast(unsigned oc, Constant *C, Type *Ty,
1600 Constant *ConstantExpr::getZExtOrBitCast(Constant *C, Type *Ty) {
1606 Constant *ConstantExpr::getSExtOrBitCast(Constant *C, Type *Ty) {
1612 Constant *ConstantExpr::getTruncOrBitCast(Constant *C, Type *Ty) {
1618 Constant *ConstantExpr::getPointerCast(Constant *S, Type *Ty) {
1634 Type *Ty) {
1644 Constant *ConstantExpr::getIntegerCast(Constant *C, Type *Ty, bool isSigned) {
1656 Constant *ConstantExpr::getFPCast(Constant *C, Type *Ty) {
1668 Constant *ConstantExpr::getTrunc(Constant *C, Type *Ty, bool OnlyIfReduced) {
1670 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1671 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1682 Constant *ConstantExpr::getSExt(Constant *C, Type *Ty, bool OnlyIfReduced) {
1684 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1685 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1696 Constant *ConstantExpr::getZExt(Constant *C, Type *Ty, bool OnlyIfReduced) {
1698 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1699 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1710 Constant *ConstantExpr::getFPTrunc(Constant *C, Type *Ty, bool OnlyIfReduced) {
1712 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1713 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1722 Constant *ConstantExpr::getFPExtend(Constant *C, Type *Ty, bool OnlyIfReduced) {
1724 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1725 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1734 Constant *ConstantExpr::getUIToFP(Constant *C, Type *Ty, bool OnlyIfReduced) {
1736 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1737 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1745 Constant *ConstantExpr::getSIToFP(Constant *C, Type *Ty, bool OnlyIfReduced) {
1747 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1748 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1756 Constant *ConstantExpr::getFPToUI(Constant *C, Type *Ty, bool OnlyIfReduced) {
1758 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1759 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1767 Constant *ConstantExpr::getFPToSI(Constant *C, Type *Ty, bool OnlyIfReduced) {
1769 bool fromVec = C->getType()->getTypeID() == Type::VectorTyID;
1770 bool toVec = Ty->getTypeID() == Type::VectorTyID;
1778 Constant *ConstantExpr::getPtrToInt(Constant *C, Type *DstTy,
1791 Constant *ConstantExpr::getIntToPtr(Constant *C, Type *DstTy,
1804 Constant *ConstantExpr::getBitCast(Constant *C, Type *DstTy,
1816 Constant *ConstantExpr::getAddrSpaceCast(Constant *C, Type *DstTy,
1825 Type *DstElemTy = DstScalarTy->getElementType();
1827 Type *MidTy = PointerType::get(DstElemTy, SrcScalarTy->getAddressSpace());
1838 Type *OnlyIfReducedTy) {
1869 unsigned Flags, Type *OnlyIfReducedTy) {
1927 Constant *ConstantExpr::getSizeOf(Type* Ty) {
1930 Constant *GEPIdx = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
1934 Type::getInt64Ty(Ty->getContext()));
1937 Constant *ConstantExpr::getAlignOf(Type* Ty) {
1940 Type *AligningTy = StructType::get(Type::getInt1Ty(Ty->getContext()), Ty);
1940 Type *AligningTy = StructType::get(Type::getInt1Ty(Ty->getContext()), Ty);
1942 Constant *Zero = ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0);
1943 Constant *One = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1);
1947 Type::getInt64Ty(Ty->getContext()));
1951 return getOffsetOf(STy, ConstantInt::get(Type::getInt32Ty(STy->getContext()),
1955 Constant *ConstantExpr::getOffsetOf(Type* Ty, Constant *FieldNo) {
1959 ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0),
1965 Type::getInt64Ty(Ty->getContext()));
1991 Type *OnlyIfReducedTy) {
2007 Constant *ConstantExpr::getGetElementPtr(Type *Ty, Constant *C,
2010 Type *OnlyIfReducedTy) {
2022 Type *DestTy = GetElementPtrInst::getIndexedType(Ty, Idxs);
2025 Type *ReqTy = DestTy->getPointerTo(AS);
2082 Type *ResultTy = Type::getInt1Ty(LHS->getContext());
2082 Type *ResultTy = Type::getInt1Ty(LHS->getContext());
2107 Type *ResultTy = Type::getInt1Ty(LHS->getContext());
2107 Type *ResultTy = Type::getInt1Ty(LHS->getContext());
2116 Type *OnlyIfReducedTy) {
2125 Type *ReqTy = Val->getType()->getVectorElementType();
2138 Constant *Idx, Type *OnlyIfReducedTy) {
2161 Constant *Mask, Type *OnlyIfReducedTy) {
2169 Type *EltTy = V1->getType()->getVectorElementType();
2170 Type *ShufTy = VectorType::get(EltTy, NElts);
2185 Type *OnlyIfReducedTy) {
2192 Type *ReqTy = Val->getType();
2208 Type *OnlyIfReducedTy) {
2212 Type *ReqTy = ExtractValueInst::getIndexedType(Agg->getType(), Idxs);
2338 Constant *ConstantExpr::getBinOpIdentity(unsigned Opcode, Type *Ty,
2384 Constant *ConstantExpr::getBinOpAbsorber(unsigned Opcode, Type *Ty) {
2409 Type *SrcElementTy, Constant *C, ArrayRef<Constant *> IdxList, Type *DestTy)
2409 Type *SrcElementTy, Constant *C, ArrayRef<Constant *> IdxList, Type *DestTy)
2422 Type *GetElementPtrConstantExpr::getSourceElementType() const {
2426 Type *GetElementPtrConstantExpr::getResultElementType() const {
2433 Type *ConstantDataSequential::getElementType() const {
2441 bool ConstantDataSequential::isElementTypeCompatible(Type *Ty) {
2486 Constant *ConstantDataSequential::getImpl(StringRef Elements, Type *Ty) {
2562 Type *Ty = ArrayType::get(Type::getHalfTy(Context), Elts.size());
2562 Type *Ty = ArrayType::get(Type::getHalfTy(Context), Elts.size());
2568 Type *Ty = ArrayType::get(Type::getFloatTy(Context), Elts.size());
2568 Type *Ty = ArrayType::get(Type::getFloatTy(Context), Elts.size());
2574 Type *Ty = ArrayType::get(Type::getDoubleTy(Context), Elts.size());
2574 Type *Ty = ArrayType::get(Type::getDoubleTy(Context), Elts.size());
2596 Type *Ty = VectorType::get(Type::getInt8Ty(Context), Elts.size());
2596 Type *Ty = VectorType::get(Type::getInt8Ty(Context), Elts.size());
2601 Type *Ty = VectorType::get(Type::getInt16Ty(Context), Elts.size());
2601 Type *Ty = VectorType::get(Type::getInt16Ty(Context), Elts.size());
2606 Type *Ty = VectorType::get(Type::getInt32Ty(Context), Elts.size());
2606 Type *Ty = VectorType::get(Type::getInt32Ty(Context), Elts.size());
2611 Type *Ty = VectorType::get(Type::getInt64Ty(Context), Elts.size());
2611 Type *Ty = VectorType::get(Type::getInt64Ty(Context), Elts.size());
2616 Type *Ty = VectorType::get(Type::getFloatTy(Context), Elts.size());
2616 Type *Ty = VectorType::get(Type::getFloatTy(Context), Elts.size());
2621 Type *Ty = VectorType::get(Type::getDoubleTy(Context), Elts.size());
2621 Type *Ty = VectorType::get(Type::getDoubleTy(Context), Elts.size());
2633 Type *Ty = VectorType::get(Type::getHalfTy(Context), Elts.size());
2633 Type *Ty = VectorType::get(Type::getHalfTy(Context), Elts.size());
2639 Type *Ty = VectorType::get(Type::getFloatTy(Context), Elts.size());
2639 Type *Ty = VectorType::get(Type::getFloatTy(Context), Elts.size());
2645 Type *Ty = VectorType::get(Type::getDoubleTy(Context), Elts.size());
2645 Type *Ty = VectorType::get(Type::getDoubleTy(Context), Elts.size());
2746 case Type::HalfTyID: {
2750 case Type::FloatTyID: {
2754 case Type::DoubleTyID: {
lib/IR/ConstantsContext.h 47 UnaryConstantExpr(unsigned Opcode, Constant *C, Type *Ty)
175 Type *DestTy)
206 ArrayRef<unsigned> IdxList, Type *DestTy)
235 Type *SrcElementTy;
236 Type *ResElementTy;
238 GetElementPtrConstantExpr(Type *SrcElementTy, Constant *C,
239 ArrayRef<Constant *> IdxList, Type *DestTy);
242 static GetElementPtrConstantExpr *Create(Type *SrcElementTy, Constant *C,
244 Type *DestTy, unsigned Flags) {
251 Type *getSourceElementType() const;
252 Type *getResultElementType() const;
271 CompareConstantExpr(Type *ty, Instruction::OtherOps opc,
353 using TypeClass = Type;
468 Type *ExplicitTy;
474 Type *ExplicitTy = nullptr)
lib/IR/Core.cpp 479 case Type::VoidTyID:
481 case Type::HalfTyID:
483 case Type::FloatTyID:
485 case Type::DoubleTyID:
487 case Type::X86_FP80TyID:
489 case Type::FP128TyID:
491 case Type::PPC_FP128TyID:
493 case Type::LabelTyID:
495 case Type::MetadataTyID:
497 case Type::IntegerTyID:
499 case Type::FunctionTyID:
501 case Type::StructTyID:
503 case Type::ArrayTyID:
505 case Type::PointerTyID:
507 case Type::VectorTyID:
509 case Type::X86_MMXTyID:
511 case Type::TokenTyID:
547 return (LLVMTypeRef) Type::getInt1Ty(*unwrap(C));
550 return (LLVMTypeRef) Type::getInt8Ty(*unwrap(C));
553 return (LLVMTypeRef) Type::getInt16Ty(*unwrap(C));
556 return (LLVMTypeRef) Type::getInt32Ty(*unwrap(C));
559 return (LLVMTypeRef) Type::getInt64Ty(*unwrap(C));
562 return (LLVMTypeRef) Type::getInt128Ty(*unwrap(C));
597 return (LLVMTypeRef) Type::getHalfTy(*unwrap(C));
600 return (LLVMTypeRef) Type::getFloatTy(*unwrap(C));
603 return (LLVMTypeRef) Type::getDoubleTy(*unwrap(C));
606 return (LLVMTypeRef) Type::getX86_FP80Ty(*unwrap(C));
609 return (LLVMTypeRef) Type::getFP128Ty(*unwrap(C));
612 return (LLVMTypeRef) Type::getPPC_FP128Ty(*unwrap(C));
615 return (LLVMTypeRef) Type::getX86_MMXTy(*unwrap(C));
645 ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
672 ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount);
697 ArrayRef<Type*> Tys(unwrap(ElementTypes), ElementCount);
737 for (auto *T : unwrap(Tp)->subtypes()) {
756 auto *Ty = unwrap<Type>(WrappedTy);
756 auto *Ty = unwrap<Type>(WrappedTy);
781 return wrap(Type::getVoidTy(*unwrap(C)));
784 return wrap(Type::getLabelTy(*unwrap(C)));
787 return wrap(Type::getTokenTy(*unwrap(C)));
790 return wrap(Type::getMetadataTy(*unwrap(C)));
1347 Type *Ty = cFP->getType();
1645 Type *Ty =
1656 Type *Ty =
2327 ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
2342 ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
2351 ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
3154 Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
3154 Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
3170 Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
3170 Type *Ty = Type::getTokenTy(unwrap(B)->getContext());
3422 Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext());
3422 Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext());
3433 Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext());
3433 Type* ITy = Type::getInt32Ty(unwrap(B)->GetInsertBlock()->getContext());
3588 Type *Ty =
3605 Type *Ty =
3621 Type *Ty =
lib/IR/DataLayout.cpp 54 Type *Ty = ST->getElementType(i);
541 bool ABIInfo, Type *Ty) const {
671 unsigned DataLayout::getPointerTypeSizeInBits(Type *Ty) const {
687 unsigned DataLayout::getIndexTypeSizeInBits(Type *Ty) const {
702 Align DataLayout::getAlignment(Type *Ty, bool abi_or_pref) const {
708 case Type::LabelTyID:
710 case Type::PointerTyID: {
715 case Type::ArrayTyID:
718 case Type::StructTyID: {
728 case Type::IntegerTyID:
731 case Type::HalfTyID:
732 case Type::FloatTyID:
733 case Type::DoubleTyID:
736 case Type::PPC_FP128TyID:
737 case Type::FP128TyID:
738 case Type::X86_FP80TyID:
741 case Type::X86_MMXTyID:
742 case Type::VectorTyID:
755 unsigned DataLayout::getABITypeAlignment(Type *Ty) const {
765 unsigned DataLayout::getPrefTypeAlignment(Type *Ty) const {
774 Type *DataLayout::getIntPtrType(Type *Ty) const {
774 Type *DataLayout::getIntPtrType(Type *Ty) const {
784 Type *DataLayout::getSmallestLegalIntType(LLVMContext &C, unsigned Width) const {
787 return Type::getIntNTy(C, LegalIntWidth);
796 Type *DataLayout::getIndexType(Type *Ty) const {
796 Type *DataLayout::getIndexType(Type *Ty) const {
806 int64_t DataLayout::getIndexedOffsetInType(Type *ElemTy,
850 Type *ElemType = GV->getValueType();
lib/IR/DebugInfoMetadata.cpp 320 ConstantInt::getSigned(Type::getInt64Ty(Context), Count));
lib/IR/DiagnosticInfo.cpp 183 DiagnosticInfoOptimizationBase::Argument::Argument(StringRef Key, const Type *T)
lib/IR/Function.cpp 66 Argument::Argument(Type *Ty, const Twine &Name, Function *Par, unsigned ArgNo)
116 Type *Argument::getParamByValType() const {
288 Type *ArgTy = FT->getParamType(i);
588 static std::string getMangledTypeStr(Type* Ty) {
623 case Type::VoidTyID: Result += "isVoid"; break;
624 case Type::MetadataTyID: Result += "Metadata"; break;
625 case Type::HalfTyID: Result += "f16"; break;
626 case Type::FloatTyID: Result += "f32"; break;
627 case Type::DoubleTyID: Result += "f64"; break;
628 case Type::X86_FP80TyID: Result += "f80"; break;
629 case Type::FP128TyID: Result += "f128"; break;
630 case Type::PPC_FP128TyID: Result += "ppcf128"; break;
631 case Type::X86_MMXTyID: Result += "x86mmx"; break;
632 case Type::IntegerTyID:
647 std::string Intrinsic::getName(ID id, ArrayRef<Type*> Tys) {
650 for (Type *Ty : Tys) {
946 static Type *DecodeFixedType(ArrayRef<Intrinsic::IITDescriptor> &Infos,
947 ArrayRef<Type*> Tys, LLVMContext &Context) {
954 case IITDescriptor::Void: return Type::getVoidTy(Context);
955 case IITDescriptor::VarArg: return Type::getVoidTy(Context);
956 case IITDescriptor::MMX: return Type::getX86_MMXTy(Context);
957 case IITDescriptor::Token: return Type::getTokenTy(Context);
958 case IITDescriptor::Metadata: return Type::getMetadataTy(Context);
959 case IITDescriptor::Half: return Type::getHalfTy(Context);
960 case IITDescriptor::Float: return Type::getFloatTy(Context);
961 case IITDescriptor::Double: return Type::getDoubleTy(Context);
962 case IITDescriptor::Quad: return Type::getFP128Ty(Context);
972 SmallVector<Type *, 8> Elts;
980 Type *Ty = Tys[D.getArgumentNumber()];
987 Type *Ty = Tys[D.getArgumentNumber()];
997 Type *Ty = Tys[D.getArgumentNumber()];
1007 Type *EltTy = DecodeFixedType(Infos, Tys, Context);
1008 Type *Ty = Tys[D.getArgumentNumber()];
1014 Type *Ty = Tys[D.getArgumentNumber()];
1018 Type *Ty = Tys[D.getArgumentNumber()];
1022 Type *EltTy = VTy->getVectorElementType();
1026 Type *Ty = Tys[D.getArgumentNumber()];
1032 Type *Ty = Tys[D.getArgumentNumber()];
1041 Type *Ty = DecodeFixedType(Infos, Tys, Context);
1050 ID id, ArrayRef<Type*> Tys) {
1055 Type *ResultTy = DecodeFixedType(TableRef, Tys, Context);
1057 SmallVector<Type*, 8> ArgTys;
1093 Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) {
1113 std::pair<Type *, ArrayRef<Intrinsic::IITDescriptor>>;
1116 Type *Ty, ArrayRef<Intrinsic::IITDescriptor> &Infos,
1117 SmallVectorImpl<Type *> &ArgTys,
1200 Type *NewTy = ArgTys[D.getArgumentNumber()];
1215 Type *NewTy = ArgTys[D.getArgumentNumber()];
1243 Type *EltTy = Ty;
1256 Type * ReferenceType = ArgTys[D.getArgumentNumber()];
1315 Type *NewTy = ArgTys[D.getArgumentNumber()];
1346 SmallVectorImpl<Type *> &ArgTys) {
1396 SmallVector<Type *, 4> ArgTys;
1504 auto *CPN = ConstantPointerNull::get(Type::getInt1PtrTy(getContext(), 0));
1517 ConstantPointerNull::get(Type::getInt1PtrTy(getContext(), 0)));
lib/IR/Globals.cpp 336 GlobalVariable::GlobalVariable(Type *Ty, bool constant, LinkageTypes Link,
355 GlobalVariable::GlobalVariable(Module &M, Type *Ty, bool constant,
427 GlobalIndirectSymbol::GlobalIndirectSymbol(Type *Ty, ValueTy VTy,
476 GlobalAlias::GlobalAlias(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
485 GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,
491 GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,
497 GlobalAlias *GlobalAlias::create(Type *Ty, unsigned AddressSpace,
532 GlobalIFunc::GlobalIFunc(Type *Ty, unsigned AddressSpace, LinkageTypes Link,
541 GlobalIFunc *GlobalIFunc::create(Type *Ty, unsigned AddressSpace,
lib/IR/IRBuilder.cpp 56 Type *IRBuilderBase::getCurrentFunctionReturnType() const {
105 Type *Tys[] = { Ptr->getType(), Size->getType() };
135 Type *Tys[] = {Ptr->getType(), Size->getType()};
167 Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() };
208 Type *Tys[] = {Dst->getType(), Src->getType(), Size->getType()};
247 Type *Tys[] = { Dst->getType(), Src->getType(), Size->getType() };
284 Type *Tys[] = {Dst->getType(), Src->getType(), Size->getType()};
318 Type *Tys[] = { Src->getType() };
326 Type *Tys[] = {Acc->getType(), Src->getType()};
335 Type *Tys[] = {Acc->getType(), Src->getType()};
445 Type *ObjectPtr[1] = {Ptr->getType()};
474 Type *DataTy = PtrTy->getElementType();
479 Type *OverloadedTypes[] = { DataTy, PtrTy };
494 Type *DataTy = PtrTy->getElementType();
497 Type *OverloadedTypes[] = { DataTy, PtrTy };
507 ArrayRef<Type *> OverloadedTypes,
528 Type *DataTy = VectorType::get(PtrTy->getElementType(), NumElts);
531 Mask = Constant::getAllOnesValue(VectorType::get(Type::getInt1Ty(Context),
537 Type *OverloadedTypes[] = {DataTy, PtrsTy};
567 Mask = Constant::getAllOnesValue(VectorType::get(Type::getInt1Ty(Context),
570 Type *OverloadedTypes[] = {DataTy, PtrsTy};
613 Type *ArgTypes[] = { FuncPtrType };
706 Type *ResultType,
710 Type *Types[] = {ResultType};
720 Type *ResultType,
723 Type *Types[] = {ResultType};
751 ArrayRef<Type *> Types,
lib/IR/Instruction.cpp 23 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
35 Instruction::Instruction(Type *ty, unsigned it, Use *Ops, unsigned NumOps,
lib/IR/Instructions.cpp 88 if (VT->getElementType() != Type::getInt1Ty(Op0->getContext()))
96 } else if (Op0->getType() != Type::getInt1Ty(Op0->getContext())) {
193 LandingPadInst::LandingPadInst(Type *RetTy, unsigned NumReservedValues,
199 LandingPadInst::LandingPadInst(Type *RetTy, unsigned NumReservedValues,
218 LandingPadInst *LandingPadInst::Create(Type *RetTy, unsigned NumReservedClauses,
224 LandingPadInst *LandingPadInst::Create(Type *RetTy, unsigned NumReservedClauses,
497 Type::getInt64Ty(getContext()), Val.udiv(APT).getLimitedValue())));
509 ConstantInt::get(Type::getInt64Ty(getContext()),
523 BasicBlock *InsertAtEnd, Type *IntPtrTy,
524 Type *AllocTy, Value *AllocSize,
569 Type *BPTy = Type::getInt8PtrTy(BB->getContext());
569 Type *BPTy = Type::getInt8PtrTy(BB->getContext());
611 Type *IntPtrTy, Type *AllocTy,
611 Type *IntPtrTy, Type *AllocTy,
619 Type *IntPtrTy, Type *AllocTy,
619 Type *IntPtrTy, Type *AllocTy,
637 Type *IntPtrTy, Type *AllocTy,
637 Type *IntPtrTy, Type *AllocTy,
644 Type *IntPtrTy, Type *AllocTy,
644 Type *IntPtrTy, Type *AllocTy,
664 Type *VoidTy = Type::getVoidTy(M->getContext());
664 Type *VoidTy = Type::getVoidTy(M->getContext());
665 Type *IntPtrTy = Type::getInt8PtrTy(M->getContext());
665 Type *IntPtrTy = Type::getInt8PtrTy(M->getContext());
865 : Instruction(Type::getVoidTy(RI.getContext()), Instruction::Ret,
874 : Instruction(Type::getVoidTy(C), Instruction::Ret,
882 : Instruction(Type::getVoidTy(C), Instruction::Ret,
890 : Instruction(Type::getVoidTy(Context), Instruction::Ret,
898 : Instruction(Type::getVoidTy(RI.getContext()), Instruction::Resume,
904 : Instruction(Type::getVoidTy(Exn->getContext()), Instruction::Resume,
910 : Instruction(Type::getVoidTy(Exn->getContext()), Instruction::Resume,
941 : Instruction(Type::getVoidTy(CleanupPad->getContext()),
950 : Instruction(Type::getVoidTy(CleanupPad->getContext()),
966 : Instruction(Type::getVoidTy(CRI.getContext()), Instruction::CatchRet,
974 : Instruction(Type::getVoidTy(BB->getContext()), Instruction::CatchRet,
982 : Instruction(Type::getVoidTy(BB->getContext()), Instruction::CatchRet,
1115 : Instruction(Type::getVoidTy(Context), Instruction::Unreachable, nullptr,
1118 : Instruction(Type::getVoidTy(Context), Instruction::Unreachable, nullptr,
1132 : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
1141 : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
1153 : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
1161 : Instruction(Type::getVoidTy(IfTrue->getContext()), Instruction::Br,
1172 : Instruction(Type::getVoidTy(BI.getContext()), Instruction::Br,
1200 Amt = ConstantInt::get(Type::getInt32Ty(Context), 1);
1210 AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
1214 AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, const Twine &Name,
1218 AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
1223 AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
1227 AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
1238 AllocaInst::AllocaInst(Type *Ty, unsigned AddrSpace, Value *ArraySize,
1290 LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name,
1294 LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name,
1298 LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
1302 LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
1306 LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
1311 LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
1316 LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
1328 LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
1394 : Instruction(Type::getVoidTy(val->getContext()), Store,
1408 : Instruction(Type::getVoidTy(val->getContext()), Store,
1474 StructType::get(Cmp->getType(), Type::getInt1Ty(Cmp->getContext())),
1486 StructType::get(Cmp->getType(), Type::getInt1Ty(Cmp->getContext())),
1580 : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertBefore) {
1588 : Instruction(Type::getVoidTy(C), Fence, nullptr, 0, InsertAtEnd) {
1627 static Type *getIndexedTypeInternal(Type *Agg, ArrayRef<IndexTy> IdxList) {
1627 static Type *getIndexedTypeInternal(Type *Agg, ArrayRef<IndexTy> IdxList) {
1648 Type *GetElementPtrInst::getIndexedType(Type *Ty, ArrayRef<Value *> IdxList) {
1648 Type *GetElementPtrInst::getIndexedType(Type *Ty, ArrayRef<Value *> IdxList) {
1652 Type *GetElementPtrInst::getIndexedType(Type *Ty,
1652 Type *GetElementPtrInst::getIndexedType(Type *Ty,
1657 Type *GetElementPtrInst::getIndexedType(Type *Ty, ArrayRef<uint64_t> IdxList) {
1657 Type *GetElementPtrInst::getIndexedType(Type *Ty, ArrayRef<uint64_t> IdxList) {
1828 Type *Int32Ty = Type::getInt32Ty(getContext());
1828 Type *Int32Ty = Type::getInt32Ty(getContext());
2162 Type *ExtractValueInst::getIndexedType(Type *Agg,
2162 Type *ExtractValueInst::getIndexedType(Type *Agg,
2192 Type *Ty, const Twine &Name,
2201 Type *Ty, const Twine &Name,
2245 Type *Ty, const Twine &Name,
2258 Type *Ty, const Twine &Name,
2470 Type *SrcTy = getOperand(0)->getType();
2471 Type *DstTy = getType();
2490 Type *SrcTy,
2491 Type *DestTy,
2532 Type *SrcTy, Type *MidTy, Type *DstTy, Type *SrcIntPtrTy, Type *MidIntPtrTy,
2532 Type *SrcTy, Type *MidTy, Type *DstTy, Type *SrcIntPtrTy, Type *MidIntPtrTy,
2532 Type *SrcTy, Type *MidTy, Type *DstTy, Type *SrcIntPtrTy, Type *MidIntPtrTy,
2532 Type *SrcTy, Type *MidTy, Type *DstTy, Type *SrcIntPtrTy, Type *MidIntPtrTy,
2532 Type *SrcTy, Type *MidTy, Type *DstTy, Type *SrcIntPtrTy, Type *MidIntPtrTy,
2533 Type *DstIntPtrTy) {
2747 CastInst *CastInst::Create(Instruction::CastOps op, Value *S, Type *Ty,
2769 CastInst *CastInst::Create(Instruction::CastOps op, Value *S, Type *Ty,
2791 CastInst *CastInst::CreateZExtOrBitCast(Value *S, Type *Ty,
2799 CastInst *CastInst::CreateZExtOrBitCast(Value *S, Type *Ty,
2807 CastInst *CastInst::CreateSExtOrBitCast(Value *S, Type *Ty,
2815 CastInst *CastInst::CreateSExtOrBitCast(Value *S, Type *Ty,
2823 CastInst *CastInst::CreateTruncOrBitCast(Value *S, Type *Ty,
2831 CastInst *CastInst::CreateTruncOrBitCast(Value *S, Type *Ty,
2839 CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty,
2857 CastInst *CastInst::CreatePointerCast(Value *S, Type *Ty,
2875 Value *S, Type *Ty,
2888 Value *S, Type *Ty,
2900 CastInst *CastInst::CreateBitOrPointerCast(Value *S, Type *Ty,
2911 CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty,
2925 CastInst *CastInst::CreateIntegerCast(Value *C, Type *Ty,
2939 CastInst *CastInst::CreateFPCast(Value *C, Type *Ty,
2952 CastInst *CastInst::CreateFPCast(Value *C, Type *Ty,
2967 bool CastInst::isCastable(Type *SrcTy, Type *DestTy) {
2967 bool CastInst::isCastable(Type *SrcTy, Type *DestTy) {
3022 bool CastInst::isBitCastable(Type *SrcTy, Type *DestTy) {
3022 bool CastInst::isBitCastable(Type *SrcTy, Type *DestTy) {
3062 bool CastInst::isBitOrNoopPointerCastable(Type *SrcTy, Type *DestTy,
3062 bool CastInst::isBitOrNoopPointerCastable(Type *SrcTy, Type *DestTy,
3086 const Value *Src, bool SrcIsSigned, Type *DestTy, bool DestIsSigned) {
3087 Type *SrcTy = Src->getType();
3188 CastInst::castIsValid(Instruction::CastOps op, Value *S, Type *DstTy) {
3190 Type *SrcTy = S->getType();
3303 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
3309 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
3315 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
3321 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
3326 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
3332 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
3338 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
3344 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
3350 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
3356 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
3362 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
3368 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
3374 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
3380 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
3386 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
3392 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
3398 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
3404 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
3410 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
3416 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
3422 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
3428 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
3434 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
3440 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
3446 Value *S, Type *Ty, const Twine &Name, Instruction *InsertBefore
3452 Value *S, Type *Ty, const Twine &Name, BasicBlock *InsertAtEnd
3461 CmpInst::CmpInst(Type *ty, OtherOps op, Predicate predicate, Value *LHS,
3476 CmpInst::CmpInst(Type *ty, OtherOps op, Predicate predicate, Value *LHS,
3812 : Instruction(Type::getVoidTy(Value->getContext()), Instruction::Switch,
3823 : Instruction(Type::getVoidTy(Value->getContext()), Instruction::Switch,
4043 : Instruction(Type::getVoidTy(Address->getContext()),
4050 : Instruction(Type::getVoidTy(Address->getContext()),
4056 : Instruction(Type::getVoidTy(IBI.getContext()), Instruction::IndirectBr,
lib/IR/IntrinsicInst.cpp 102 return ConstantInt::get(Type::getInt64Ty(Context), 1);
lib/IR/LLVMContextImpl.cpp 25 VoidTy(C, Type::VoidTyID),
26 LabelTy(C, Type::LabelTyID),
27 HalfTy(C, Type::HalfTyID),
28 FloatTy(C, Type::FloatTyID),
29 DoubleTy(C, Type::DoubleTyID),
30 MetadataTy(C, Type::MetadataTyID),
31 TokenTy(C, Type::TokenTyID),
32 X86_FP80Ty(C, Type::X86_FP80TyID),
33 FP128Ty(C, Type::FP128TyID),
34 PPC_FP128Ty(C, Type::PPC_FP128TyID),
35 X86_MMXTy(C, Type::X86_MMXTyID),
lib/IR/LLVMContextImpl.h 99 ArrayRef<Type*> ETypes;
102 KeyTy(const ArrayRef<Type*>& E, bool P) :
151 const Type *ReturnType;
152 ArrayRef<Type*> Params;
155 KeyTy(const Type* R, const ArrayRef<Type*>& P, bool V) :
155 KeyTy(const Type* R, const ArrayRef<Type*>& P, bool V) :
1291 DenseMap<Type *, std::unique_ptr<ConstantAggregateZero>> CAZConstants;
1304 DenseMap<Type *, std::unique_ptr<UndefValue>> UVConstants;
1320 Type VoidTy, LabelTy, HalfTy, FloatTy, DoubleTy, MetadataTy, TokenTy;
1321 Type X86_FP80Ty, FP128Ty, PPC_FP128Ty, X86_MMXTy;
1336 DenseMap<std::pair<Type *, uint64_t>, ArrayType*> ArrayTypes;
1337 DenseMap<std::pair<Type *, ElementCount>, VectorType*> VectorTypes;
1338 DenseMap<Type*, PointerType*> PointerTypes; // Pointers in AddrSpace = 0
1339 DenseMap<std::pair<Type*, unsigned>, PointerType*> ASPointerTypes;
lib/IR/MDBuilder.cpp 33 createConstant(ConstantFP::get(Type::getFloatTy(Context), Accuracy));
48 Type *Int32Ty = Type::getInt32Ty(Context);
48 Type *Int32Ty = Type::getInt32Ty(Context);
62 Type *Int64Ty = Type::getInt64Ty(Context);
62 Type *Int64Ty = Type::getInt64Ty(Context);
87 Type *Ty = IntegerType::get(Context, Lo.getBitWidth());
112 Type *Int64 = Type::getInt64Ty(Context);
112 Type *Int64 = Type::getInt64Ty(Context);
118 Type *Int1 = Type::getInt1Ty(Context);
118 Type *Int1 = Type::getInt1Ty(Context);
184 Constant *Flags = ConstantInt::get(Type::getInt64Ty(Context), 1);
203 Type *Int64 = Type::getInt64Ty(Context);
203 Type *Int64 = Type::getInt64Ty(Context);
217 Type *Int64 = Type::getInt64Ty(Context);
217 Type *Int64 = Type::getInt64Ty(Context);
230 ConstantInt *Off = ConstantInt::get(Type::getInt64Ty(Context), Offset);
239 IntegerType *Int64 = Type::getInt64Ty(Context);
252 Type *Int64 = Type::getInt64Ty(Context);
252 Type *Int64 = Type::getInt64Ty(Context);
267 IntegerType *Int64 = Type::getInt64Ty(Context);
308 createConstant(ConstantInt::get(Type::getInt64Ty(Context), Weight)),
315 auto *IntType = Type::getInt64Ty(Context);
lib/IR/Mangler.cpp 99 Type *Ty = AI->getType();
lib/IR/Metadata.cpp 62 MetadataAsValue::MetadataAsValue(Type *Ty, Metadata *MD)
109 Entry = new MetadataAsValue(Type::getMetadataTy(Context), MD);
957 Type *Ty = High->getType();
1496 Type::getInt64Ty(getContext()), Offset)),
1504 Type::getInt64Ty(getContext()), Visibility))}));
lib/IR/Module.cpp 205 StringRef Name, Type *Ty,
215 Type *GVTy = GV->getType();
225 Constant *Module::getOrInsertGlobal(StringRef Name, Type *Ty) {
339 Type *Int32Ty = Type::getInt32Ty(Context);
339 Type *Int32Ty = Type::getInt32Ty(Context);
351 Type *Int32Ty = Type::getInt32Ty(Context);
351 Type *Int32Ty = Type::getInt32Ty(Context);
lib/IR/Operator.cpp 22 Type *GEPOperator::getSourceElementType() const {
28 Type *GEPOperator::getResultElementType() const {
lib/IR/ProfileSummary.cpp 28 Type *Int64Ty = Type::getInt64Ty(Context);
28 Type *Int64Ty = Type::getInt64Ty(Context);
49 Type *Int32Ty = Type::getInt32Ty(Context);
49 Type *Int32Ty = Type::getInt32Ty(Context);
50 Type *Int64Ty = Type::getInt64Ty(Context);
50 Type *Int64Ty = Type::getInt64Ty(Context);
lib/IR/SafepointIRVerifier.cpp 253 static bool isGCPointerType(Type *T) {
262 static bool containsGCPtrType(Type *Ty) {
lib/IR/Type.cpp 39 Type *Type::getPrimitiveType(LLVMContext &C, TypeID IDNumber) {
61 bool Type::canLosslesslyBitCastTo(Type *Ty) const {
76 if (Ty->getTypeID() == Type::X86_MMXTyID &&
81 if (this->getTypeID() == Type::X86_MMXTyID)
117 case Type::HalfTyID: return TypeSize::Fixed(16);
118 case Type::FloatTyID: return TypeSize::Fixed(32);
119 case Type::DoubleTyID: return TypeSize::Fixed(64);
120 case Type::X86_FP80TyID: return TypeSize::Fixed(80);
121 case Type::FP128TyID: return TypeSize::Fixed(128);
122 case Type::PPC_FP128TyID: return TypeSize::Fixed(128);
123 case Type::X86_MMXTyID: return TypeSize::Fixed(64);
124 case Type::IntegerTyID:
126 case Type::VectorTyID: {
151 bool Type::isSizedDerivedType(SmallPtrSetImpl<Type*> *Visited) const {
165 Type *Type::getVoidTy(LLVMContext &C) { return &C.pImpl->VoidTy; }
166 Type *Type::getLabelTy(LLVMContext &C) { return &C.pImpl->LabelTy; }
167 Type *Type::getHalfTy(LLVMContext &C) { return &C.pImpl->HalfTy; }
168 Type *Type::getFloatTy(LLVMContext &C) { return &C.pImpl->FloatTy; }
169 Type *Type::getDoubleTy(LLVMContext &C) { return &C.pImpl->DoubleTy; }
170 Type *Type::getMetadataTy(LLVMContext &C) { return &C.pImpl->MetadataTy; }
171 Type *Type::getTokenTy(LLVMContext &C) { return &C.pImpl->TokenTy; }
172 Type *Type::getX86_FP80Ty(LLVMContext &C) { return &C.pImpl->X86_FP80Ty; }
173 Type *Type::getFP128Ty(LLVMContext &C) { return &C.pImpl->FP128Ty; }
174 Type *Type::getPPC_FP128Ty(LLVMContext &C) { return &C.pImpl->PPC_FP128Ty; }
175 Type *Type::getX86_MMXTy(LLVMContext &C) { return &C.pImpl->X86_MMXTy; }
250 case 1: return cast<IntegerType>(Type::getInt1Ty(C));
251 case 8: return cast<IntegerType>(Type::getInt8Ty(C));
252 case 16: return cast<IntegerType>(Type::getInt16Ty(C));
253 case 32: return cast<IntegerType>(Type::getInt32Ty(C));
254 case 64: return cast<IntegerType>(Type::getInt64Ty(C));
255 case 128: return cast<IntegerType>(Type::getInt128Ty(C));
281 FunctionType::FunctionType(Type *Result, ArrayRef<Type*> Params,
281 FunctionType::FunctionType(Type *Result, ArrayRef<Type*> Params,
284 Type **SubTys = reinterpret_cast<Type**>(this+1);
301 FunctionType *FunctionType::get(Type *ReturnType,
302 ArrayRef<Type*> Params, bool isVarArg) {
316 sizeof(FunctionType) + sizeof(Type *) * (Params.size() + 1),
327 FunctionType *FunctionType::get(Type *Result, bool isVarArg) {
331 bool FunctionType::isValidReturnType(Type *RetTy) {
336 bool FunctionType::isValidArgumentType(Type *ArgTy) {
346 StructType *StructType::get(LLVMContext &Context, ArrayRef<Type*> ETypes,
373 void StructType::setBody(ArrayRef<Type*> Elements, bool isPacked) {
452 StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements,
459 StructType *StructType::create(LLVMContext &Context, ArrayRef<Type*> Elements) {
467 StructType *StructType::create(ArrayRef<Type*> Elements, StringRef Name,
474 StructType *StructType::create(ArrayRef<Type*> Elements) {
480 bool StructType::isSized(SmallPtrSetImpl<Type*> *Visited) const {
511 bool StructType::isValidElementType(Type *ElemTy) {
536 Type *CompositeType::getTypeAtIndex(const Value *V) const {
547 Type *CompositeType::getTypeAtIndex(unsigned Idx) const{
584 ArrayType::ArrayType(Type *ElType, uint64_t NumEl)
587 ArrayType *ArrayType::get(Type *ElementType, uint64_t NumElements) {
599 bool ArrayType::isValidElementType(Type *ElemTy) {
611 VectorType::VectorType(Type *ElType, ElementCount EC)
614 VectorType *VectorType::get(Type *ElementType, ElementCount EC) {
628 bool VectorType::isValidElementType(Type *ElemTy) {
637 PointerType *PointerType::get(Type *EltTy, unsigned AddressSpace) {
652 PointerType::PointerType(Type *E, unsigned AddrSpace)
663 bool PointerType::isValidElementType(Type *ElemTy) {
668 bool PointerType::isLoadableOrStorableType(Type *ElemTy) {
lib/IR/TypeFinder.cpp 92 void TypeFinder::incorporateType(Type *Ty) {
97 SmallVector<Type *, 4> TypeWorklist;
108 for (Type::subtype_reverse_iterator I = Ty->subtype_rbegin(),
lib/IR/Value.cpp 47 static inline Type *checkType(Type *Ty) {
47 static inline Type *checkType(Type *Ty) {
52 Value::Value(Type *ty, unsigned scid)
617 Type *PT = cast<PointerType>(A->getType())->getElementType();
690 Type *ObjectType = GVar->getValueType();
707 Type *EltTy = cast<PointerType>(A->getType())->getElementType();
715 Type *AllocatedType = AI->getAllocatedType();
lib/IR/Verifier.cpp 175 void Write(Type *T) {
274 Type *LandingPadResultTy;
311 void checkAtomicMemAccessSize(Type *Ty, const Instruction *I);
419 void visitRangeMetadata(Instruction &I, MDNode *Range, Type *Ty);
499 bool performTypeCheck(Intrinsic::ID ID, Function *F, Type *Ty, int VT,
504 void verifyParameterAttrs(AttributeSet Attrs, Type *Ty, const Value *V);
646 FunctionType::get(Type::getVoidTy(Context), false)->
656 Type *ETy = STy->getTypeAtIndex(2);
667 Type *GVType = GV.getValueType();
1585 void Verifier::verifyParameterAttrs(AttributeSet Attrs, Type *Ty,
1663 SmallPtrSet<Type*, 4> Visited;
1723 Type *Ty = FT->getParamType(i);
1919 auto *PtrTy = CE->getOpcode() == Instruction::IntToPtr
1991 Type *ParamType = TargetFuncType->getParamType(i);
1992 Type *ArgType = Call.getArgOperand(5 + i)->getType();
2470 Type *SwitchTy = SI.getCondition()->getType();
2540 Type *SrcTy = I.getOperand(0)->getType();
2541 Type *DestTy = I.getType();
2558 Type *SrcTy = I.getOperand(0)->getType();
2559 Type *DestTy = I.getType();
2576 Type *SrcTy = I.getOperand(0)->getType();
2577 Type *DestTy = I.getType();
2594 Type *SrcTy = I.getOperand(0)->getType();
2595 Type *DestTy = I.getType();
2611 Type *SrcTy = I.getOperand(0)->getType();
2612 Type *DestTy = I.getType();
2629 Type *SrcTy = I.getOperand(0)->getType();
2630 Type *DestTy = I.getType();
2652 Type *SrcTy = I.getOperand(0)->getType();
2653 Type *DestTy = I.getType();
2675 Type *SrcTy = I.getOperand(0)->getType();
2676 Type *DestTy = I.getType();
2698 Type *SrcTy = I.getOperand(0)->getType();
2699 Type *DestTy = I.getType();
2721 Type *SrcTy = I.getOperand(0)->getType();
2722 Type *DestTy = I.getType();
2746 Type *SrcTy = I.getOperand(0)->getType();
2747 Type *DestTy = I.getType();
2776 Type *SrcTy = I.getOperand(0)->getType();
2777 Type *DestTy = I.getType();
2925 Type *Ty = Call.getArgOperand(Idx)->getType();
2961 for (Type *ParamTy : FTy->params()) {
3024 static bool isTypeCongruent(Type *L, Type *R) {
3024 static bool isTypeCongruent(Type *L, Type *R) {
3222 Type *Op0Ty = IC.getOperand(0)->getType();
3223 Type *Op1Ty = IC.getOperand(1)->getType();
3238 Type *Op0Ty = FC.getOperand(0)->getType();
3239 Type *Op1Ty = FC.getOperand(1)->getType();
3274 Type *TargetTy = GEP.getPointerOperandType()->getScalarType();
3284 Type *ElTy =
3299 Type *IndexTy = Idx->getType();
3321 void Verifier::visitRangeMetadata(Instruction &I, MDNode *Range, Type *Ty) {
3369 void Verifier::checkAtomicMemAccessSize(Type *Ty, const Instruction *I) {
3379 Type *ElTy = LI.getType();
3405 Type *ElTy = PTy->getElementType();
3463 SmallPtrSet<Type*, 4> Visited;
3504 Type *ElTy = PTy->getElementType();
3524 Type *ElTy = PTy->getElementType();
4247 SmallVector<Type *, 4> ArgTys;
4623 Type *DataTy = cast<PointerType>(Ptr->getType())->getElementType();
4644 Type *DataTy = cast<PointerType>(Ptr->getType())->getElementType();
4729 Type *ValTy = Call.getArgOperand(0)->getType();
4730 Type *ResultTy = Call.getType();
4786 Type *ValTy = FPI.getArgOperand(0)->getType();
4787 Type *ResultTy = FPI.getType();
4799 Type *ValTy = FPI.getArgOperand(0)->getType();
4800 Type *ResultTy = FPI.getType();
4869 Type *OperandTy = Operand->getType();
4871 Type *ResultTy = Result->getType();
lib/LTO/LTO.cpp 969 ArrayType::get(Type::getInt8Ty(RegularLTO.Ctx), I.second.Size);
lib/Linker/IRMover.cpp 32 DenseMap<Type *, Type *> MappedTypes;
32 DenseMap<Type *, Type *> MappedTypes;
37 SmallVector<Type *, 16> SpeculativeTypes;
56 void addTypeMapping(Type *DstTy, Type *SrcTy);
56 void addTypeMapping(Type *DstTy, Type *SrcTy);
64 Type *get(Type *SrcTy);
64 Type *get(Type *SrcTy);
65 Type *get(Type *SrcTy, SmallPtrSet<StructType *, 8> &Visited);
65 Type *get(Type *SrcTy, SmallPtrSet<StructType *, 8> &Visited);
67 void finishType(StructType *DTy, StructType *STy, ArrayRef<Type *> ETypes);
74 Type *remapType(Type *SrcTy) override { return get(SrcTy); }
74 Type *remapType(Type *SrcTy) override { return get(SrcTy); }
76 bool areTypesIsomorphic(Type *DstTy, Type *SrcTy);
76 bool areTypesIsomorphic(Type *DstTy, Type *SrcTy);
80 void TypeMapTy::addTypeMapping(Type *DstTy, Type *SrcTy) {
80 void TypeMapTy::addTypeMapping(Type *DstTy, Type *SrcTy) {
89 for (Type *Ty : SpeculativeTypes)
103 for (Type *Ty : SpeculativeTypes)
114 bool TypeMapTy::areTypesIsomorphic(Type *DstTy, Type *SrcTy) {
114 bool TypeMapTy::areTypesIsomorphic(Type *DstTy, Type *SrcTy) {
120 Type *&Entry = MappedTypes[SrcTy];
197 SmallVector<Type *, 16> Elements;
215 ArrayRef<Type *> ETypes) {
228 Type *TypeMapTy::get(Type *Ty) {
228 Type *TypeMapTy::get(Type *Ty) {
233 Type *TypeMapTy::get(Type *Ty, SmallPtrSet<StructType *, 8> &Visited) {
233 Type *TypeMapTy::get(Type *Ty, SmallPtrSet<StructType *, 8> &Visited) {
235 Type **Entry = &MappedTypes[Ty];
267 SmallVector<Type *, 4> ElementTypes;
303 case Type::ArrayTyID:
306 case Type::VectorTyID:
309 case Type::PointerTyID:
312 case Type::FunctionTyID:
316 case Type::StructTyID: {
640 Type *Ty = Attrs.getAttribute(i, Attribute::ByVal).getValueAsType();
671 auto *Ty = TypeMap.get(SGIS->getValueType());
842 Type *EltTy = cast<ArrayType>(TypeMap.get(SrcGV->getValueType()))
859 PointerType *VoidPtrTy = Type::getInt8Ty(SrcGV->getContext())->getPointerTo();
862 Type *Tys[3] = {ST.getElementType(0), ST.getElementType(1), VoidPtrTy};
1460 IRMover::StructTypeKeyInfo::KeyTy::KeyTy(ArrayRef<Type *> E, bool P)
1524 IRMover::IdentifiedStructTypeSet::findNonOpaque(ArrayRef<Type *> ETypes,
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)));
1135 Type *IntTy64 = Type::getInt64Ty(M.getContext());
1135 Type *IntTy64 = Type::getInt64Ty(M.getContext());
lib/Target/AArch64/AArch64CallLowering.cpp 246 Type *SplitTy = SplitVTs[i].getTypeForEVT(Ctx);
lib/Target/AArch64/AArch64CallLowering.h 56 using RegHandler = std::function<void(MachineIRBuilder &, Type *, unsigned,
lib/Target/AArch64/AArch64FastISel.cpp 182 bool isTypeLegal(Type *Ty, MVT &VT);
183 bool isTypeSupported(Type *Ty, MVT &VT, bool IsVectorAllowed = false);
185 bool computeAddress(const Value *Obj, Address &Addr, Type *Ty = nullptr);
536 return materializeInt(ConstantInt::get(Type::getInt64Ty(*Context), 0), VT);
579 bool AArch64FastISel::computeAddress(const Value *Obj, Address &Addr, Type *Ty)
977 bool AArch64FastISel::isTypeLegal(Type *Ty, MVT &VT) {
1001 bool AArch64FastISel::isTypeSupported(Type *Ty, MVT &VT, bool IsVectorAllowed) {
1486 Type *Ty = LHS->getType();
2978 Type *ArgTy = Arg.getType();
3394 Type *RetTy =
3659 Type *RetTy = II->getCalledFunction()->getReturnType();
3686 Type *RetTy = Ty->getTypeAtIndex(0U);
3941 Type *DestTy = I->getType();
3943 Type *SrcTy = Op->getType();
5032 Type *Ty = GTI.getIndexedType();
5087 Type *RetTy = RetPairTy->getTypeAtIndex(0U);
lib/Target/AArch64/AArch64ISelDAGToDAG.cpp 802 Type *Ty = GV->getValueType();
lib/Target/AArch64/AArch64ISelLowering.cpp 2572 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
5466 Type *ArgTy = VT.getTypeForEVT(*DAG.getContext());
5951 Type *type = CallOperandVal->getType();
8402 Type *ArgTy = I.getArgOperand(ArgI)->getType();
8494 bool AArch64TargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
8494 bool AArch64TargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
8538 bool AArch64TargetLowering::isZExtFree(Type *Ty1, Type *Ty2) const {
8538 bool AArch64TargetLowering::isZExtFree(Type *Ty1, Type *Ty2) const {
8593 Type *IdxTy = GTI.getIndexedType();
8806 Type *EltTy = VecTy->getVectorElementType();
8830 Type *PtrTy = VecTy->getPointerTo(LI->getPointerAddressSpace());
8831 Type *Tys[2] = {VecTy, PtrTy};
8922 Type *EltTy = VecTy->getVectorElementType();
8942 Type *IntTy = DL.getIntPtrType(EltTy);
8946 Type *IntVecTy = VectorType::get(IntTy, NumOpElts);
8972 Type *PtrTy = SubVecTy->getPointerTo(SI->getPointerAddressSpace());
8973 Type *Tys[2] = {SubVecTy, PtrTy};
9118 const AddrMode &AM, Type *Ty,
9172 const AddrMode &AM, Type *Ty,
9235 Type *Ty) const {
11704 Type *T = GV->getValueType();
12172 Type *ValTy = cast<PointerType>(Addr->getType())->getElementType();
12183 Addr = Builder.CreateBitCast(Addr, Type::getInt8PtrTy(M->getContext()));
12194 Type *Tys[] = { Addr->getType() };
12199 Type *EltTy = cast<PointerType>(Addr->getType())->getElementType();
12227 Type *Int64Ty = Type::getInt64Ty(M->getContext());
12227 Type *Int64Ty = Type::getInt64Ty(M->getContext());
12231 Addr = Builder.CreateBitCast(Addr, Type::getInt8PtrTy(M->getContext()));
12237 Type *Tys[] = { Addr->getType() };
12251 Type *Ty, CallingConv::ID CallConv, bool isVarArg) const {
12290 Type::getInt8PtrTy(M.getContext()));
12294 "__security_check_cookie", Type::getVoidTy(M.getContext()),
12295 Type::getInt8PtrTy(M.getContext()));
lib/Target/AArch64/AArch64ISelLowering.h 346 bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
346 bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
351 bool isZExtFree(Type *Ty1, Type *Ty2) const override;
351 bool isZExtFree(Type *Ty1, Type *Ty2) const override;
384 bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty,
393 int getScalingFactorCost(const DataLayout &DL, const AddrMode &AM, Type *Ty,
410 Type *Ty) const override;
567 bool functionArgumentNeedsConsecutiveRegisters(Type *Ty,
lib/Target/AArch64/AArch64InstructionSelector.cpp 3067 Type *CPTy = CPVal->getType();
3682 CstIdxs.emplace_back(ConstantInt::get(Type::getInt8Ty(Ctx), Offset));
lib/Target/AArch64/AArch64PromoteConstant.cpp 239 static bool isConstantUsingVectorTy(const Type *CstTy) {
lib/Target/AArch64/AArch64SelectionDAGInfo.cpp 35 Type *IntPtrTy = Type::getInt8PtrTy(*DAG.getContext());
35 Type *IntPtrTy = Type::getInt8PtrTy(*DAG.getContext());
46 .setLibCallee(CallingConv::C, Type::getVoidTy(*DAG.getContext()),
lib/Target/AArch64/AArch64StackTagging.cpp 255 Type *EltTy = VecTy->getElementType();
258 Type *NewTy = VectorType::get(IntegerType::get(Ctx, EltSize),
472 Type *AllocatedType =
478 Type *PaddingType =
479 ArrayType::get(Type::getInt8Ty(F->getContext()), AlignedSize - Size);
480 Type *TypeWithPadding = StructType::get(AllocatedType, PaddingType);
lib/Target/AArch64/AArch64TargetTransformInfo.cpp 59 int AArch64TTIImpl::getIntImmCost(const APInt &Imm, Type *Ty) {
84 const APInt &Imm, Type *Ty) {
150 const APInt &Imm, Type *Ty) {
198 bool AArch64TTIImpl::isWideningInstruction(Type *DstTy, unsigned Opcode,
247 Type *SrcTy = toVectorTy(Extend->getSrcTy());
262 int AArch64TTIImpl::getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
262 int AArch64TTIImpl::getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
398 int AArch64TTIImpl::getExtractWithExtendCost(unsigned Opcode, Type *Dst,
408 auto *Src = VecTy->getElementType();
453 int AArch64TTIImpl::getVectorInstrCost(unsigned Opcode, Type *Val,
479 unsigned Opcode, Type *Ty, TTI::OperandValueKind Opd1Info,
572 int AArch64TTIImpl::getAddressComputationCost(Type *Ty, ScalarEvolution *SE,
590 int AArch64TTIImpl::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
591 Type *CondTy, const Instruction *I) {
634 int AArch64TTIImpl::getMemoryOpCost(unsigned Opcode, Type *Ty,
672 int AArch64TTIImpl::getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
700 int AArch64TTIImpl::getCostOfKeepingLiveOverCall(ArrayRef<Type *> Tys) {
702 for (auto *I : Tys) {
788 Type *ExpectedType) {
874 Type *ConsideredSExtType =
875 Type::getInt64Ty(I.getParent()->getParent()->getContext());
895 bool AArch64TTIImpl::useReductionIntrinsic(unsigned Opcode, Type *Ty,
920 int AArch64TTIImpl::getArithmeticReductionCost(unsigned Opcode, Type *ValTy,
948 int AArch64TTIImpl::getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index,
949 Type *SubTp) {
lib/Target/AArch64/AArch64TargetTransformInfo.h 59 bool isWideningInstruction(Type *Ty, unsigned Opcode,
75 int getIntImmCost(const APInt &Imm, Type *Ty);
76 int getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm, Type *Ty);
78 Type *Ty);
113 int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
113 int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
116 int getExtractWithExtendCost(unsigned Opcode, Type *Dst, VectorType *VecTy,
119 int getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index);
122 unsigned Opcode, Type *Ty,
129 int getAddressComputationCost(Type *Ty, ScalarEvolution *SE, const SCEV *Ptr);
131 int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
131 int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
137 int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
140 int getCostOfKeepingLiveOverCall(ArrayRef<Type *> Tys);
146 Type *ExpectedType);
150 bool isLegalMaskedLoad(Type *DataType, MaybeAlign Alignment) {
154 Type *Ty = DataType->getVectorElementType();
165 int getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy, unsigned Factor,
183 bool useReductionIntrinsic(unsigned Opcode, Type *Ty,
186 int getArithmeticReductionCost(unsigned Opcode, Type *Ty,
189 int getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index, Type *SubTp);
189 int getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index, Type *SubTp);
lib/Target/AMDGPU/AMDGPUAnnotateUniformValues.cpp 144 Type::getInt32Ty(Ptr->getContext()), APInt(64, 0));
lib/Target/AMDGPU/AMDGPUAtomicOptimizer.cpp 284 Type *const Ty = V->getType();
343 Type *const Ty = V->getType();
438 Type *const Ty = I.getType();
440 Type *const VecTy = VectorType::get(B.getInt32Ty(), 2);
448 Type *const WaveTy = B.getIntNTy(ST->getWavefrontSize());
lib/Target/AMDGPU/AMDGPUCallLowering.cpp 171 Type *Ty = VT.getTypeForEVT(Ctx);
190 Type *PartTy = PartVT.getTypeForEVT(Ctx);
341 Type *ParamTy,
365 Type *ParamTy, uint64_t Offset,
461 Type *ArgTy = Arg.getType();
lib/Target/AMDGPU/AMDGPUCallLowering.h 26 Register lowerParameterPtr(MachineIRBuilder &B, Type *ParamTy,
29 void lowerParameter(MachineIRBuilder &B, Type *ParamTy, uint64_t Offset,
lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp 78 unsigned getBaseElementBitWidth(const Type *T) const;
83 Type *getI32Ty(IRBuilder<> &B, const Type *T) const;
83 Type *getI32Ty(IRBuilder<> &B, const Type *T) const;
95 bool needsPromotionToI32(const Type *T) const;
202 unsigned AMDGPUCodeGenPrepare::getBaseElementBitWidth(const Type *T) const {
210 Type *AMDGPUCodeGenPrepare::getI32Ty(IRBuilder<> &B, const Type *T) const {
210 Type *AMDGPUCodeGenPrepare::getI32Ty(IRBuilder<> &B, const Type *T) const {
228 bool AMDGPUCodeGenPrepare::needsPromotionToI32(const Type *T) const {
274 Type *Ty = I.getType();
296 Type *I32Ty = getI32Ty(Builder, I.getType());
337 Type *I32Ty = getI32Ty(Builder, I.getOperand(0)->getType());
364 Type *I32Ty = getI32Ty(Builder, I.getType());
396 Type *I32Ty = getI32Ty(Builder, I.getType());
448 Type *Ty,
464 Type *Ty = I.getType();
544 Type *Ty = FDiv.getType();
617 Type *I32Ty = Builder.getInt32Ty();
618 Type *I64Ty = Builder.getInt64Ty();
656 Type *Ty = Num->getType();
657 Type *I32Ty = Builder.getInt32Ty();
658 Type *F32Ty = Builder.getFloatTy();
756 Type *Ty = Num->getType();
757 Type *I32Ty = Builder.getInt32Ty();
758 Type *F32Ty = Builder.getFloatTy();
895 Type *Ty = I.getType();
940 Type *I32Ty = Builder.getInt32Ty();
941 Type *PT = PointerType::get(I32Ty, I.getPointerAddressSpace());
967 Type *IntNTy = Builder.getIntNTy(TySize);
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.cpp 102 ValueKind MetadataStreamerV2::getValueKind(Type *Ty, StringRef TypeQual,
130 ValueType MetadataStreamerV2::getValueType(Type *Ty, StringRef TypeName) const {
132 case Type::IntegerTyID: {
147 case Type::HalfTyID:
149 case Type::FloatTyID:
151 case Type::DoubleTyID:
153 case Type::PointerTyID:
155 case Type::VectorTyID:
162 std::string MetadataStreamerV2::getTypeName(Type *Ty, bool Signed) const {
164 case Type::IntegerTyID: {
182 case Type::HalfTyID:
184 case Type::FloatTyID:
186 case Type::DoubleTyID:
188 case Type::VectorTyID: {
345 Type *Ty = Arg.getType();
361 void MetadataStreamerV2::emitKernelArg(const DataLayout &DL, Type *Ty,
407 auto Int64Ty = Type::getInt64Ty(Func.getContext());
416 auto Int8PtrTy = Type::getInt8PtrTy(Func.getContext(),
544 StringRef MetadataStreamerV3::getValueKind(Type *Ty, StringRef TypeQual,
571 StringRef MetadataStreamerV3::getValueType(Type *Ty, StringRef TypeName) const {
573 case Type::IntegerTyID: {
588 case Type::HalfTyID:
590 case Type::FloatTyID:
592 case Type::DoubleTyID:
594 case Type::PointerTyID:
596 case Type::VectorTyID:
603 std::string MetadataStreamerV3::getTypeName(Type *Ty, bool Signed) const {
605 case Type::IntegerTyID: {
623 case Type::HalfTyID:
625 case Type::FloatTyID:
627 case Type::DoubleTyID:
629 case Type::VectorTyID: {
762 Type *Ty = Arg.getType();
780 void MetadataStreamerV3::emitKernelArg(const DataLayout &DL, Type *Ty,
840 auto Int64Ty = Type::getInt64Ty(Func.getContext());
850 Type::getInt8PtrTy(Func.getContext(), AMDGPUAS::GLOBAL_ADDRESS);
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.h 65 StringRef getValueKind(Type *Ty, StringRef TypeQual,
68 StringRef getValueType(Type *Ty, StringRef TypeName) const;
70 std::string getTypeName(Type *Ty, bool Signed) const;
90 void emitKernelArg(const DataLayout &DL, Type *Ty, StringRef ValueKind,
133 ValueKind getValueKind(Type *Ty, StringRef TypeQual,
136 ValueType getValueType(Type *Ty, StringRef TypeName) const;
138 std::string getTypeName(Type *Ty, bool Signed) const;
161 void emitKernelArg(const DataLayout &DL, Type *Ty, ValueKind ValueKind,
lib/Target/AMDGPU/AMDGPUISelLowering.cpp 785 bool AMDGPUTargetLowering::isTruncateFree(Type *Source, Type *Dest) const {
785 bool AMDGPUTargetLowering::isTruncateFree(Type *Source, Type *Dest) const {
797 bool AMDGPUTargetLowering::isZExtFree(Type *Src, Type *Dest) const {
797 bool AMDGPUTargetLowering::isZExtFree(Type *Src, Type *Dest) const {
925 Type *BaseArgTy = Arg.getType();
lib/Target/AMDGPU/AMDGPUISelLowering.h 169 bool isTruncateFree(Type *Src, Type *Dest) const override;
169 bool isTruncateFree(Type *Src, Type *Dest) const override;
171 bool isZExtFree(Type *Src, Type *Dest) const override;
171 bool isZExtFree(Type *Src, Type *Dest) const override;
lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp 1190 Type::getInt8Ty(MF.getFunction().getContext()),
lib/Target/AMDGPU/AMDGPULibCalls.cpp 600 Type *PtrElemTy;
602 PtrElemTy = Type::getIntNTy(Ctx, Size * 8);
604 PtrElemTy = VectorType::get(Type::getInt64Ty(Ctx), Size / 8);
610 SmallVector<llvm::Type *, 6> ArgTys;
880 Type *eltType;
1129 Type* rTy = opr0->getType();
1130 Type* nTyS = eltType->isDoubleTy() ? B.getInt64Ty() : B.getInt32Ty();
1131 Type *nTy = nTyS;
1353 Type *PTy = Fsincos.getFunctionType()->getParamType(1);
1418 Type *RetType = UCallee->getReturnType();
lib/Target/AMDGPU/AMDGPULibFunc.cpp 872 static Type* getIntrinsicParamType(
876 Type* T = nullptr;
879 case AMDGPULibFunc::I8: T = Type::getInt8Ty(C); break;
881 case AMDGPULibFunc::I16: T = Type::getInt16Ty(C); break;
883 case AMDGPULibFunc::I32: T = Type::getInt32Ty(C); break;
885 case AMDGPULibFunc::I64: T = Type::getInt64Ty(C); break;
886 case AMDGPULibFunc::F16: T = Type::getHalfTy(C); break;
887 case AMDGPULibFunc::F32: T = Type::getFloatTy(C); break;
888 case AMDGPULibFunc::F64: T = Type::getDoubleTy(C); break;
916 std::vector<Type*> Args;
976 const Type* argTy = static_cast<const Type*>(*PI);
lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp 96 Type *ArgTy = Arg.getType();
135 Type *AdjustedArgTy;
lib/Target/AMDGPU/AMDGPUOpenCLEnqueuedBlockLowering.cpp 119 auto T = ArrayType::get(Type::getInt64Ty(C), 2);
lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp 59 bool shouldPrintAsStr(char Specifier, Type *OpType) const;
135 Type *OpType) const {
141 Type *ElemType = PT->getContainedType(0);
142 if (ElemType->getTypeID() != Type::IntegerTyID)
152 Type *I32Ty = Type::getInt32Ty(Ctx);
152 Type *I32Ty = Type::getInt32Ty(Ctx);
211 Type *ArgType = Arg->getType();
219 llvm::Type *ResType = llvm::Type::getInt32Ty(Ctx);
219 llvm::Type *ResType = llvm::Type::getInt32Ty(Ctx);
325 Type *SizetTy = Type::getInt32Ty(Ctx);
325 Type *SizetTy = Type::getInt32Ty(Ctx);
327 Type *Tys_alloc[1] = {SizetTy};
328 Type *I8Ptr = PointerType::get(Type::getInt8Ty(Ctx), 1);
328 Type *I8Ptr = PointerType::get(Type::getInt8Ty(Ctx), 1);
360 ConstantPointerNull::get(PointerType::get(Type::getInt8Ty(Ctx), 1));
385 Type *idPointer = PointerType::get(I32Ty, AMDGPUAS::GLOBAL_ADDRESS);
402 Type *Int32Ty = Type::getInt32Ty(Ctx);
402 Type *Int32Ty = Type::getInt32Ty(Ctx);
403 Type *Int64Ty = Type::getInt64Ty(Ctx);
403 Type *Int64Ty = Type::getInt64Ty(Ctx);
408 Type *ArgType = Arg->getType();
411 (ArgType->getTypeID() != Type::VectorTyID)) {
412 Type *IType = (ArgType->isFloatTy()) ? Int32Ty : Int64Ty;
433 } else if (ArgType->getTypeID() == Type::PointerTyID) {
476 Type *DstType = (Size == 32) ? Int32Ty : Int64Ty;
480 } else if (ArgType->getTypeID() == Type::VectorTyID) {
481 Type *IType = NULL;
486 IntegerType *Int32Ty = Type::getInt32Ty(ArgType->getContext());
500 IType = dyn_cast<Type>(Type::getInt64Ty(ArgType->getContext()));
500 IType = dyn_cast<Type>(Type::getInt64Ty(ArgType->getContext()));
505 IType = dyn_cast<Type>(Type::getInt64Ty(ArgType->getContext()));
505 IType = dyn_cast<Type>(Type::getInt64Ty(ArgType->getContext()));
508 IType = dyn_cast<Type>(Type::getInt32Ty(ArgType->getContext()));
508 IType = dyn_cast<Type>(Type::getInt32Ty(ArgType->getContext()));
511 IType = dyn_cast<Type>(Type::getInt16Ty(ArgType->getContext()));
511 IType = dyn_cast<Type>(Type::getInt16Ty(ArgType->getContext()));
517 IType = dyn_cast<Type>(Type::getInt64Ty(ArgType->getContext()));
517 IType = dyn_cast<Type>(Type::getInt64Ty(ArgType->getContext()));
520 IType = dyn_cast<Type>(Type::getInt32Ty(ArgType->getContext()));
520 IType = dyn_cast<Type>(Type::getInt32Ty(ArgType->getContext()));
525 IType = dyn_cast<Type>(VectorType::get(IType, EleCount));
539 Type *ArgPointer = PointerType::get(TheBtCast->getType(), 1);
lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp 244 Type *I32Ty = Type::getInt32Ty(Mod->getContext());
244 Type *I32Ty = Type::getInt32Ty(Mod->getContext());
365 Type *AT = Alloca->getAllocatedType();
428 Type *VecPtrTy = VectorTy->getPointerTo(AMDGPUAS::PRIVATE_ADDRESS);
444 Type *VecPtrTy = VectorTy->getPointerTo(AMDGPUAS::PRIVATE_ADDRESS);
632 for (Type *ParamTy : FTy->params()) {
726 Type *AllocaTy = I.getAllocatedType();
795 Type *GVTy = ArrayType::get(I.getAllocatedType(), WorkGroupSize);
820 Constant::getNullValue(Type::getInt32Ty(Mod->getContext())),
834 Type *EltTy = Src0->getType()->getPointerElementType();
851 Type *EltTy = V->getType()->getPointerElementType();
918 Type *SrcTy = Src->getType()->getPointerElementType();
lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp 108 bool isVec3ToVec4Shuffle(Type *Ty0, Type* Ty1) const;
108 bool isVec3ToVec4Shuffle(Type *Ty0, Type* Ty1) const;
151 Type *DestEltTy = BCI->getType()->getPointerElementType();
157 Type *SrcEltTy = Arg.getType()->getPointerElementType();
209 bool AMDGPURewriteOutArguments::isVec3ToVec4Shuffle(Type *Ty0, Type* Ty1) const {
209 bool AMDGPURewriteOutArguments::isVec3ToVec4Shuffle(Type *Ty0, Type* Ty1) const {
237 SmallVector<Type *, 4> ReturnTypes;
238 Type *RetTy = F.getReturnType();
289 Type *ArgTy = OutArg->getType()->getPointerElementType();
399 Type *EltTy = Arg->getType()->getPointerElementType();
401 Type *EffectiveEltTy = EltTy;
454 auto *EltTy = ArgType->getElementType();
460 Type *PtrTy = Val->getType()->getPointerTo(ArgType->getAddressSpace());
lib/Target/AMDGPU/AMDGPUSubtarget.cpp 504 Type *ArgTy = Arg.getType();
lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp 159 Type *Ty = Alloca->getAllocatedType();
341 unsigned Opcode, Type *Ty, TTI::OperandValueKind Opd1Info,
461 int GCNTTIImpl::getArithmeticReductionCost(unsigned Opcode, Type *Ty,
476 int GCNTTIImpl::getMinMaxReductionCost(Type *Ty, Type *CondTy,
476 int GCNTTIImpl::getMinMaxReductionCost(Type *Ty, Type *CondTy,
492 int GCNTTIImpl::getVectorInstrCost(unsigned Opcode, Type *ValTy,
623 Type *DestTy = II->getType();
624 Type *SrcTy = NewV->getType();
648 unsigned GCNTTIImpl::getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index,
649 Type *SubTp) {
804 int R600TTIImpl::getVectorInstrCost(unsigned Opcode, Type *ValTy,
lib/Target/AMDGPU/AMDGPUTargetTransformInfo.h 173 unsigned Opcode, Type *Ty,
182 int getVectorInstrCost(unsigned Opcode, Type *ValTy, unsigned Index);
201 unsigned getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index,
202 Type *SubTp);
212 Type *Ty,
214 int getMinMaxReductionCost(Type *Ty, Type *CondTy,
214 int getMinMaxReductionCost(Type *Ty, Type *CondTy,
257 int getVectorInstrCost(unsigned Opcode, Type *ValTy, unsigned Index);
lib/Target/AMDGPU/AMDGPUUnifyDivergentExitNodes.cpp 188 Type *RetTy = F.getReturnType();
232 Type *RetTy = F.getReturnType();
lib/Target/AMDGPU/R600ISelLowering.cpp 1178 Type::getInt32PtrTy(*DAG.getContext(), AMDGPUAS::PRIVATE_ADDRESS)));
1409 Type::getInt32PtrTy(*DAG.getContext(), AMDGPUAS::PRIVATE_ADDRESS)));
lib/Target/AMDGPU/R600OpenCLImageTypeLoweringPass.cpp 159 Type *Int32Type;
160 Type *ImageSizeType;
161 Type *ImageFormatType;
273 SmallVector<Type *, 8> ArgTypes;
370 Int32Type = Type::getInt32Ty(M.getContext());
lib/Target/AMDGPU/SIAnnotateControlFlow.cpp 58 Type *Boolean;
59 Type *Void;
60 Type *IntMask;
61 Type *ReturnStruct;
140 Void = Type::getVoidTy(Context);
141 Boolean = Type::getInt1Ty(Context);
142 IntMask = ST.isWave32() ? Type::getInt32Ty(Context)
143 : Type::getInt64Ty(Context);
lib/Target/AMDGPU/SIFrameLowering.cpp 582 PointerType::get(Type::getInt64Ty(MF.getFunction().getContext()),
627 PointerType::get(Type::getInt64Ty(MF.getFunction().getContext()),
lib/Target/AMDGPU/SIISelLowering.cpp 863 static MVT memVTFromAggregate(Type *Ty) {
868 Type *ElementType = nullptr;
887 case Type::IntegerTyID:
890 case Type::HalfTyID:
893 case Type::FloatTyID:
1046 Type *&AccessTy) const {
1142 const AddrMode &AM, Type *Ty,
1366 Type *Ty) const {
1462 Type *Ty = MemVT.getTypeForEVT(*DAG.getContext());
2864 MachinePointerInfo(UndefValue::get(Type::getInt8PtrTy(
4690 Value *V = UndefValue::get(PointerType::get(Type::getInt8Ty(*DAG.getContext()),
5095 Type *Ty = PtrVT.getTypeForEVT(*DAG.getContext());
5766 Type *Type = VT.getTypeForEVT(*DAG.getContext());
8069 Type *Ty = MemVT.getTypeForEVT(*DCI.DAG.getContext());
10914 Type *Ty = RMW->getType();
lib/Target/AMDGPU/SIISelLowering.h 235 Type *&/*AccessTy*/) const override;
238 bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty,
278 Type *Ty) const override;
lib/Target/ARC/ARCISelLowering.cpp 698 const AddrMode &AM, Type *Ty,
lib/Target/ARC/ARCISelLowering.h 73 bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty,
lib/Target/ARM/ARMBaseRegisterInfo.cpp 466 ConstantInt::get(Type::getInt32Ty(MF.getFunction().getContext()), Val);
lib/Target/ARM/ARMCallLowering.cpp 56 Type *T) {
215 Type *SplitTy = SplitVT.getTypeForEVT(Ctx);
lib/Target/ARM/ARMCodeGenPrepare.cpp 112 DenseMap<Value*, SmallVector<Type*, 4>> TruncTysMap;
138 ExtTy(Type::getInt32Ty(Ctx)) { }
141 void Mutate(Type *OrigTy,
164 Type *OrigTy = nullptr;
211 Type *Ty = V->getType();
633 Type *Ty = TruncTysMap[Call][i];
644 Type *Ty = TruncTysMap[Switch][0];
654 Type *Ty = TruncTysMap[I][i];
734 void IRPromoter::Mutate(Type *OrigTy,
lib/Target/ARM/ARMConstantPoolValue.cpp 33 ARMConstantPoolValue::ARMConstantPoolValue(Type *Ty, unsigned id,
47 : MachineConstantPoolValue((Type*)Type::getInt32Ty(C)),
120 ARMConstantPoolConstant::ARMConstantPoolConstant(Type *Ty,
162 return new ARMConstantPoolConstant((Type*)Type::getInt32Ty(GV->getContext()),
lib/Target/ARM/ARMConstantPoolValue.h 70 ARMConstantPoolValue(Type *Ty, unsigned id, ARMCP::ARMCPKind Kind,
153 ARMConstantPoolConstant(Type *Ty, const Constant *C,
lib/Target/ARM/ARMFastISel.cpp 191 bool isTypeLegal(Type *Ty, MVT &VT);
192 bool isLoadTypeLegal(Type *Ty, MVT &VT);
689 bool ARMFastISel::isTypeLegal(Type *Ty, MVT &VT) {
701 bool ARMFastISel::isLoadTypeLegal(Type *Ty, MVT &VT) {
1352 Type *Ty = Src1Value->getType();
1488 Constant *Zero = ConstantInt::get(Type::getInt32Ty(*Context), 0);
1542 Type *Ty = I->getType();
1587 Type *RetTy = I->getType();
1595 Type *OpTy = I->getOperand(0)->getType();
1693 Type *Ty = I->getType();
1722 Type *Ty = I->getType();
1802 Type *Ty = I->getType();
2186 Type *GVTy = Type::getInt32PtrTy(*Context, /*AS=*/0);
2186 Type *GVTy = Type::getInt32PtrTy(*Context, /*AS=*/0);
2190 GlobalValue *GV = new GlobalVariable(M, Type::getInt32Ty(*Context), false,
2208 Type *RetTy = I->getType();
2237 Type *ArgTy = Op->getType();
2314 Type *RetTy = I->getType();
2365 Type *ArgTy = (*i)->getType();
2741 Type *DestTy = I->getType();
2743 Type *SrcTy = Src->getType();
2961 MF->getDataLayout().getPrefTypeAlignment(Type::getInt32PtrTy(*Context));
3035 Type *ArgTy = Arg.getType();
lib/Target/ARM/ARMISelDAGToDAG.cpp 2989 ConstantInt::get(Type::getInt32Ty(*CurDAG->getContext()), Val),
lib/Target/ARM/ARMISelLowering.cpp 3202 Entry.Ty = (Type *) Type::getInt32Ty(*DAG.getContext());
3208 CallingConv::C, Type::getInt32Ty(*DAG.getContext()),
8733 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
8740 Type *RetTy = StructType::get(ArgTy, ArgTy);
8760 RetTy = Type::getVoidTy(*DAG.getContext());
9123 Type *LCRTy = Val.getValueType().getTypeForEVT(*DAG.getContext());
9642 Type *Int32Ty = Type::getInt32Ty(MF->getFunction().getContext());
9642 Type *Int32Ty = Type::getInt32Ty(MF->getFunction().getContext());
9743 Type *Int32Ty = Type::getInt32Ty(MF->getFunction().getContext());
9743 Type *Int32Ty = Type::getInt32Ty(MF->getFunction().getContext());
10145 Type *Int32Ty = Type::getInt32Ty(MF->getFunction().getContext());
10145 Type *Int32Ty = Type::getInt32Ty(MF->getFunction().getContext());
14675 bool ARMTargetLowering::isTruncateFree(Type *SrcTy, Type *DstTy) const {
14675 bool ARMTargetLowering::isTruncateFree(Type *SrcTy, Type *DstTy) const {
14836 bool ARMTargetLowering::allowTruncateForTailCall(Type *Ty1, Type *Ty2) const {
14836 bool ARMTargetLowering::allowTruncateForTailCall(Type *Ty1, Type *Ty2) const {
14851 const AddrMode &AM, Type *Ty,
15031 const AddrMode &AM, Type *Ty,
15651 Type *type = CallOperandVal->getType();
15945 Type *ArgTy = ArgVT.getTypeForEVT(*Context);
15967 Type *Ty = VT.getTypeForEVT(*DAG.getContext());
16001 Type *RetTy = StructType::get(Ty, Ty);
16019 std::vector<Type*> RetTyParams;
16020 Type *RetTyElement;
16024 case MVT::i8: RetTyElement = Type::getInt8Ty(*DAG.getContext()); break;
16025 case MVT::i16: RetTyElement = Type::getInt16Ty(*DAG.getContext()); break;
16026 case MVT::i32: RetTyElement = Type::getInt32Ty(*DAG.getContext()); break;
16027 case MVT::i64: RetTyElement = Type::getInt64Ty(*DAG.getContext()); break;
16032 ArrayRef<Type*> ret = ArrayRef<Type*>(RetTyParams);
16033 Type *RetTy = StructType::get(*DAG.getContext(), ret);
16295 Type *ArgTy = I.getArgOperand(ArgI)->getType();
16317 Type *ArgTy = I.getArgOperand(ArgI)->getType();
16384 Type *Ty) const {
16541 Type::getInt8PtrTy(M.getContext()));
16545 "__security_check_cookie", Type::getVoidTy(M.getContext()),
16546 Type::getInt8PtrTy(M.getContext()));
16565 bool ARMTargetLowering::canCombineStoreAndExtract(Type *VectorTy, Value *Idx,
16609 Type *ValTy = cast<PointerType>(Addr->getType())->getElementType();
16620 Addr = Builder.CreateBitCast(Addr, Type::getInt8PtrTy(M->getContext()));
16633 Type *Tys[] = { Addr->getType() };
16663 Type *Int32Ty = Type::getInt32Ty(M->getContext());
16663 Type *Int32Ty = Type::getInt32Ty(M->getContext());
16669 Addr = Builder.CreateBitCast(Addr, Type::getInt8PtrTy(M->getContext()));
16674 Type *Tys[] = { Addr->getType() };
16748 Type *EltTy = VecTy->getVectorElementType();
16787 Type *Int8Ptr = Builder.getInt8PtrTy(LI->getPointerAddressSpace());
16788 Type *Tys[] = {VecTy, Int8Ptr};
16883 Type *EltTy = VecTy->getVectorElementType();
16903 Type *IntTy = DL.getIntPtrType(EltTy);
16906 Type *IntVecTy =
16935 Type *Int8Ptr = Builder.getInt8PtrTy(SI->getPointerAddressSpace());
16936 Type *Tys[] = {Int8Ptr, SubVecTy};
16994 static bool isHomogeneousAggregate(Type *Ty, HABaseType &Base,
17046 Align ARMTargetLowering::getABIAlignmentForCallingConv(Type *ArgTy,
17061 Type *Ty, CallingConv::ID CallConv, bool isVarArg) const {
lib/Target/ARM/ARMISelLowering.h 352 bool isTruncateFree(Type *SrcTy, Type *DstTy) const override;
352 bool isTruncateFree(Type *SrcTy, Type *DstTy) const override;
362 bool allowTruncateForTailCall(Type *Ty1, Type *Ty2) const override;
362 bool allowTruncateForTailCall(Type *Ty1, Type *Ty2) const override;
368 Type *Ty, unsigned AS,
375 int getScalingFactorCost(const DataLayout &DL, const AddrMode &AM, Type *Ty,
516 Type *Ty) const override;
526 Type *Ty, CallingConv::ID CallConv, bool isVarArg) const override;
575 bool canCombineStoreAndExtract(Type *VectorTy, Value *Idx,
620 Align getABIAlignmentForCallingConv(Type *ArgTy,
lib/Target/ARM/ARMLegalizerInfo.cpp 385 Type *ArgTy = Type::getInt32Ty(Ctx);
385 Type *ArgTy = Type::getInt32Ty(Ctx);
418 auto *ArgTy = OpSize == 32 ? Type::getFloatTy(Ctx) : Type::getDoubleTy(Ctx);
418 auto *ArgTy = OpSize == 32 ? Type::getFloatTy(Ctx) : Type::getDoubleTy(Ctx);
418 auto *ArgTy = OpSize == 32 ? Type::getFloatTy(Ctx) : Type::getDoubleTy(Ctx);
419 auto *RetTy = Type::getInt32Ty(Ctx);
lib/Target/ARM/ARMLoadStoreOptimizer.cpp 2182 ? TD->getABITypeAlignment(Type::getInt64Ty(Func.getContext()))
lib/Target/ARM/ARMParallelDSP.cpp 162 Type *getType() const { return Root->getType(); }
528 const auto *Ty = I.getType();
lib/Target/ARM/ARMSelectionDAGInfo.cpp 96 Entry.Ty = Type::getInt32Ty(*DAG.getContext());
117 TLI->getLibcallCallingConv(LC), Type::getVoidTy(*DAG.getContext()),
lib/Target/ARM/ARMTargetTransformInfo.cpp 65 int ARMTTIImpl::getIntImmCost(const APInt &Imm, Type *Ty) {
100 const APInt &Imm, Type *Ty) {
108 Type *Ty) {
148 int ARMTTIImpl::getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
148 int ARMTTIImpl::getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
406 int ARMTTIImpl::getVectorInstrCost(unsigned Opcode, Type *ValTy,
442 int ARMTTIImpl::getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
442 int ARMTTIImpl::getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
473 int ARMTTIImpl::getAddressComputationCost(Type *Ty, ScalarEvolution *SE,
494 bool ARMTTIImpl::isLegalMaskedLoad(Type *DataTy, MaybeAlign Alignment) {
549 int ARMTTIImpl::getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index,
550 Type *SubTp) {
644 unsigned Opcode, Type *Ty, TTI::OperandValueKind Op1Info,
738 int ARMTTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
756 int ARMTTIImpl::getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
998 HWLoopInfo.CountType = Type::getInt32Ty(C);
1075 bool ARMTTIImpl::useReductionIntrinsic(unsigned Opcode, Type *Ty,
lib/Target/ARM/ARMTargetTransformInfo.h 113 Type *Ty);
116 int getIntImmCost(const APInt &Imm, Type *Ty);
118 int getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm, Type *Ty);
156 bool isLegalMaskedLoad(Type *DataTy, MaybeAlign Alignment);
158 bool isLegalMaskedStore(Type *DataTy, MaybeAlign Alignment) {
164 int getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index, Type *SubTp);
164 int getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index, Type *SubTp);
166 bool useReductionIntrinsic(unsigned Opcode, Type *Ty,
173 int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
173 int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
176 int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
176 int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
179 int getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index);
181 int getAddressComputationCost(Type *Val, ScalarEvolution *SE,
185 unsigned Opcode, Type *Ty,
192 int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
195 int getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy, unsigned Factor,
lib/Target/ARM/MVETailPredication.cpp 451 Type *Ty = IntegerType::get(M->getContext(), 32);
lib/Target/ARM/ThumbRegisterInfo.cpp 72 Type::getInt32Ty(MBB.getParent()->getFunction().getContext()), Val);
91 Type::getInt32Ty(MBB.getParent()->getFunction().getContext()), Val);
lib/Target/AVR/AVRISelLowering.cpp 345 Type *Ty = VT.getTypeForEVT(*DAG.getContext());
383 Type *RetTy = (Type *)StructType::get(Ty, Ty);
745 const AddrMode &AM, Type *Ty,
lib/Target/AVR/AVRISelLowering.h 91 bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty,
lib/Target/BPF/BPFAbstractMemberAccess.cpp 289 ConstantInt::get(Type::getInt32Ty(Call->getParent()->getContext()), 0);
855 VarType = Type::getInt32Ty(BB->getContext()); // 32bit return value
857 VarType = Type::getInt64Ty(BB->getContext()); // 64bit ptr arith
870 auto *LDInst = new LoadInst(Type::getInt32Ty(BB->getContext()), GV);
888 auto *LDInst = new LoadInst(Type::getInt64Ty(BB->getContext()), GV);
892 auto *BCInst = new BitCastInst(Base, Type::getInt8PtrTy(BB->getContext()));
896 auto *GEP = GetElementPtrInst::Create(Type::getInt8Ty(BB->getContext()),
lib/Target/BPF/BPFISelLowering.h 109 Type *Ty) const override {
lib/Target/Hexagon/HexagonBitTracker.cpp 64 Type *ATy = Arg.getType();
lib/Target/Hexagon/HexagonCommonGEP.cpp 190 Type *PTy = nullptr; // Type of the pointer operand.
203 Type *next_type(Type *Ty, Value *Idx) {
203 Type *next_type(Type *Ty, Value *Idx) {
208 Type *NexTy = cast<SequentialType>(Ty)->getElementType();
215 Type *NextTy = cast<StructType>(Ty)->getElementType(i);
382 Type *PtrTy = cast<PointerType>(PtrOp->getType())->getElementType();
1108 Type *Int32Ty = Type::getInt32Ty(*Ctx);
1108 Type *Int32Ty = Type::getInt32Ty(*Ctx);
1120 Type *NextTy = next_type(N->PTy, N->Idx);
1126 Type *InpTy = Input->getType();
1127 Type *ElTy = cast<PointerType>(InpTy->getScalarType())->getElementType();
lib/Target/Hexagon/HexagonConstPropagation.cpp 1986 IntegerType *Ty = (W == 32) ? Type::getInt32Ty(CX)
1987 : Type::getInt64Ty(CX);
2030 IntegerType *Ty = Type::getInt64Ty(CX);
2243 IntegerType *Ty = Type::getInt32Ty(CX);
lib/Target/Hexagon/HexagonGenExtract.cpp 119 CSR = ConstantInt::get(Type::getInt32Ty(Ctx), 0);
128 CSL = ConstantInt::get(Type::getInt32Ty(Ctx), 0);
135 CSL = ConstantInt::get(Type::getInt32Ty(Ctx), 0);
156 Type *Ty = BF->getType();
lib/Target/Hexagon/HexagonISelLowering.cpp 923 Type *CValTy = ConstVal->getType();
1793 Type *ElTy = I.getCalledFunction()->getReturnType()->getStructElementType(0);
1819 Type *VecTy = I.getArgOperand(1)->getType();
1840 bool HexagonTargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
1840 bool HexagonTargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
2617 HexagonTargetLowering::allowTruncateForTailCall(Type *Ty1, Type *Ty2) const {
2617 HexagonTargetLowering::allowTruncateForTailCall(Type *Ty1, Type *Ty2) const {
3061 const AddrMode &AM, Type *Ty,
3244 Type *Ty = PT->getElementType();
3266 Type *Ty = Val->getType();
3269 Type *CastTy = Builder.getIntNTy(SZ);
3281 Value *Ext = Builder.CreateZExt(Cmp, Type::getInt32Ty(M->getContext()));
lib/Target/Hexagon/HexagonISelLowering.h 125 bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
125 bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
134 bool allowTruncateForTailCall(Type *Ty1, Type *Ty2) const override;
134 bool allowTruncateForTailCall(Type *Ty1, Type *Ty2) const override;
288 Type *Ty, unsigned AS,
lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp 1002 Type *OrigTy = In->getType();
1094 Type *Ty0 = P->getIncomingValue(0)->getType();
1095 Type *PTy = P->getType();
1377 using CastMapType = std::map<std::pair<Value *, Type *>, Value *>;
2034 Type *IntPtrTy = Builder.getIntPtrTy(*DL, SI->getPointerAddressSpace());
2048 Type *BECountTy = BECount->getType();
2213 Type *Ty = NumBytes->getType();
2252 Type *Int32Ty = Type::getInt32Ty(Ctx);
2252 Type *Int32Ty = Type::getInt32Ty(Ctx);
2253 Type *Int32PtrTy = Type::getInt32PtrTy(Ctx);
2253 Type *Int32PtrTy = Type::getInt32PtrTy(Ctx);
2254 Type *VoidTy = Type::getVoidTy(Ctx);
2254 Type *VoidTy = Type::getVoidTy(Ctx);
lib/Target/Hexagon/HexagonSelectionDAGInfo.cpp 55 Type::getVoidTy(*DAG.getContext()),
lib/Target/Hexagon/HexagonTargetObjectFile.cpp 241 Type *GType = GVar->getValueType();
289 unsigned HexagonTargetObjectFile::getSmallestAddressableSize(const Type *Ty,
298 case Type::StructTyID: {
307 case Type::ArrayTyID: {
311 case Type::VectorTyID: {
315 case Type::PointerTyID:
316 case Type::HalfTyID:
317 case Type::FloatTyID:
318 case Type::DoubleTyID:
319 case Type::IntegerTyID: {
324 case Type::FunctionTyID:
325 case Type::VoidTyID:
326 case Type::X86_FP80TyID:
327 case Type::FP128TyID:
328 case Type::PPC_FP128TyID:
329 case Type::LabelTyID:
330 case Type::MetadataTyID:
331 case Type::X86_MMXTyID:
332 case Type::TokenTyID:
341 const Type *GTy = GO->getValueType();
lib/Target/Hexagon/HexagonTargetObjectFile.h 44 unsigned getSmallestAddressableSize(const Type *Ty, const GlobalValue *GV,
lib/Target/Hexagon/HexagonTargetTransformInfo.cpp 46 bool HexagonTTIImpl::isTypeForHVX(Type *VecTy) const {
62 unsigned HexagonTTIImpl::getTypeNumElements(Type *Ty) const {
118 unsigned HexagonTTIImpl::getScalarizationOverhead(Type *Ty, bool Insert,
128 unsigned HexagonTTIImpl::getCallInstrCost(Function *F, Type *RetTy,
129 ArrayRef<Type*> Tys) {
133 unsigned HexagonTTIImpl::getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
138 unsigned HexagonTTIImpl::getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
139 ArrayRef<Type*> Tys, FastMathFlags FMF,
149 unsigned HexagonTTIImpl::getAddressComputationCost(Type *Tp,
154 unsigned HexagonTTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
202 Type *Src, unsigned Alignment, unsigned AddressSpace) {
206 unsigned HexagonTTIImpl::getShuffleCost(TTI::ShuffleKind Kind, Type *Tp,
207 int Index, Type *SubTp) {
211 unsigned HexagonTTIImpl::getGatherScatterOpCost(unsigned Opcode, Type *DataTy,
218 Type *VecTy, unsigned Factor, ArrayRef<unsigned> Indices,
229 unsigned HexagonTTIImpl::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
230 Type *CondTy, const Instruction *I) {
239 unsigned HexagonTTIImpl::getArithmeticInstrCost(unsigned Opcode, Type *Ty,
252 unsigned HexagonTTIImpl::getCastInstrCost(unsigned Opcode, Type *DstTy,
253 Type *SrcTy, const Instruction *I) {
265 unsigned HexagonTTIImpl::getVectorInstrCost(unsigned Opcode, Type *Val,
267 Type *ElemTy = Val->isVectorTy() ? cast<VectorType>(Val)->getElementType()
lib/Target/Hexagon/HexagonTargetTransformInfo.h 46 bool isTypeForHVX(Type *VecTy) const;
51 unsigned getTypeNumElements(Type *Ty) const;
104 unsigned getScalarizationOverhead(Type *Ty, bool Insert, bool Extract);
107 unsigned getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type*> Tys);
107 unsigned getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type*> Tys);
108 unsigned getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
110 unsigned getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
111 ArrayRef<Type*> Tys, FastMathFlags FMF,
113 unsigned getAddressComputationCost(Type *Tp, ScalarEvolution *SE,
115 unsigned getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
118 unsigned getMaskedMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
120 unsigned getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index,
121 Type *SubTp);
122 unsigned getGatherScatterOpCost(unsigned Opcode, Type *DataTy, Value *Ptr,
124 unsigned getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
128 unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
128 unsigned getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
130 unsigned getArithmeticInstrCost(unsigned Opcode, Type *Ty,
136 unsigned getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
136 unsigned getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
138 unsigned getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index);
lib/Target/Lanai/LanaiTargetObjectFile.cpp 97 Type *Ty = GVA->getValueType();
lib/Target/Lanai/LanaiTargetTransformInfo.h 52 int getIntImmCost(const APInt &Imm, Type *Ty) {
69 int getIntImmCost(unsigned Opc, unsigned Idx, const APInt &Imm, Type *Ty) {
74 Type *Ty) {
79 unsigned Opcode, Type *Ty,
lib/Target/MSP430/MSP430ISelLowering.cpp 1376 bool MSP430TargetLowering::isTruncateFree(Type *Ty1,
1377 Type *Ty2) const {
1391 bool MSP430TargetLowering::isZExtFree(Type *Ty1, Type *Ty2) const {
1391 bool MSP430TargetLowering::isZExtFree(Type *Ty1, Type *Ty2) const {
lib/Target/MSP430/MSP430ISelLowering.h 112 bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
112 bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
123 bool isZExtFree(Type *Ty1, Type *Ty2) const override;
123 bool isZExtFree(Type *Ty1, Type *Ty2) const override;
lib/Target/Mips/Mips16HardFloat.cpp 47 std::vector<Type *> AsmArgTypes;
51 FunctionType::get(Type::getVoidTy(C), AsmArgTypes, false);
70 static FPReturnVariant whichFPReturnVariant(Type *T) {
72 case Type::FloatTyID:
74 case Type::DoubleTyID:
76 case Type::StructTyID: {
102 using TypeID = Type::TypeID;
103 const Type::TypeID FloatTyID = Type::FloatTyID;
103 const Type::TypeID FloatTyID = Type::FloatTyID;
104 const Type::TypeID DoubleTyID = Type::DoubleTyID;
104 const Type::TypeID DoubleTyID = Type::DoubleTyID;
158 Type *ArgType = F.getFunctionType()->getParamType(0);
160 case Type::FloatTyID:
161 case Type::DoubleTyID:
171 Type* RetType = F.getReturnType();
176 Type* RetType = FT.getReturnType();
381 Type *MyVoid = Type::getVoidTy(C);
381 Type *MyVoid = Type::getVoidTy(C);
394 Type *T = RVal->getType();
lib/Target/Mips/Mips16ISelLowering.cpp 295 Type *t = Args[0].Ty;
305 Type *t = Args[1].Ty;
370 (Type* RetTy, ArgListTy &Args, bool &needHelper) const {
lib/Target/Mips/Mips16ISelLowering.h 44 (Type* RetTy, ArgListTy &Args, bool &needHelper) const;
lib/Target/Mips/MipsCCState.cpp 40 static bool originalTypeIsF128(const Type *Ty, const char *Func) {
62 static bool originalTypeIsVectorFloat(const Type * Ty) {
88 const Type *RetTy, const char *Call) {
112 const SmallVectorImpl<ISD::InputArg> &Ins, const Type *RetTy) {
lib/Target/Mips/MipsCCState.h 33 const Type *RetTy, const char * Func);
53 const Type *RetTy);
120 CCAssignFn Fn, const Type *RetTy,
lib/Target/Mips/MipsCallLowering.cpp 361 static bool isSupportedArgumentType(Type *T) {
371 static bool isSupportedReturnType(Type *T) {
lib/Target/Mips/MipsConstantIslandPass.cpp 1656 Type *Int32Ty =
1657 Type::getInt32Ty(MF->getFunction().getContext());
lib/Target/Mips/MipsFastISel.cpp 172 bool isTypeLegal(Type *Ty, MVT &VT);
173 bool isTypeSupported(Type *Ty, MVT &VT);
174 bool isLoadTypeLegal(Type *Ty, MVT &VT);
596 bool MipsFastISel::isTypeLegal(Type *Ty, MVT &VT) {
608 bool MipsFastISel::isTypeSupported(Type *Ty, MVT &VT) {
623 bool MipsFastISel::isLoadTypeLegal(Type *Ty, MVT &VT) {
1106 Type *DstTy = I->getType();
1114 Type *SrcTy = Src->getType();
1360 Type *ArgTy = FormalArg.getType();
1594 Type *RetTy = II->getCalledFunction()->getReturnType();
1805 Type *DestTy = I->getType();
1807 Type *SrcTy = Src->getType();
lib/Target/Mips/MipsISelLowering.cpp 2038 IntegerType *PtrTy = Type::getIntNTy(*DAG.getContext(), PtrSize);
3803 Type *type = CallOperandVal->getType();
4115 const AddrMode &AM, Type *Ty,
lib/Target/Mips/MipsISelLowering.h 307 Align getABIAlignmentForCallingConv(Type *ArgTy,
667 Type *Ty, unsigned AS,
lib/Target/Mips/MipsOs16.cpp 50 Type* RetType = F.getReturnType();
52 case Type::FloatTyID:
53 case Type::DoubleTyID:
61 case Type::FloatTyID:
62 case Type::DoubleTyID:
lib/Target/Mips/MipsTargetObjectFile.cpp 138 Type *Ty = GVA->getValueType();
lib/Target/NVPTX/NVPTXAsmPrinter.cpp 265 case Type::HalfTyID:
269 case Type::FloatTyID:
273 case Type::DoubleTyID:
336 Type *Ty = F->getReturnType();
340 if (Ty->getTypeID() == Type::VoidTyID)
1013 Type *ETy = GVar->getValueType();
1184 case Type::IntegerTyID: // Integers larger than 64 bits
1185 case Type::StructTyID:
1186 case Type::ArrayTyID:
1187 case Type::VectorTyID:
1282 NVPTXAsmPrinter::getPTXFundamentalTypeStr(Type *Ty, bool useB4PTR) const {
1287 case Type::IntegerTyID: {
1300 case Type::HalfTyID:
1303 case Type::FloatTyID:
1305 case Type::DoubleTyID:
1307 case Type::PointerTyID:
1327 Type *ETy = GVar->getValueType();
1359 case Type::StructTyID:
1360 case Type::ArrayTyID:
1361 case Type::VectorTyID:
1376 static unsigned int getOpenCLAlignment(const DataLayout &DL, Type *Ty) {
1390 Type *ETy = STy->getElementType(i);
1431 Type *Ty = I->getType();
1495 Type *ETy = PTy->getElementType();
1555 Type *ETy = PTy->getElementType();
1696 if (Fp->getType()->getTypeID() == Type::FloatTyID) {
1700 } else if (Fp->getType()->getTypeID() == Type::DoubleTyID) {
1801 case Type::IntegerTyID: {
1802 Type *ETy = CPV->getType();
1803 if (ETy == Type::getInt8Ty(CPV->getContext())) {
1807 } else if (ETy == Type::getInt16Ty(CPV->getContext())) {
1811 } else if (ETy == Type::getInt32Ty(CPV->getContext())) {
1833 } else if (ETy == Type::getInt64Ty(CPV->getContext())) {
1859 case Type::HalfTyID:
1860 case Type::FloatTyID:
1861 case Type::DoubleTyID: {
1863 Type *Ty = CFP->getType();
1864 if (Ty == Type::getHalfTy(CPV->getContext())) {
1869 } else if (Ty == Type::getFloatTy(CPV->getContext())) {
1873 } else if (Ty == Type::getDoubleTy(CPV->getContext())) {
1882 case Type::PointerTyID: {
1894 case Type::ArrayTyID:
1895 case Type::VectorTyID:
1896 case Type::StructTyID: {
2071 Type *Ty = CE->getType();
lib/Target/NVPTX/NVPTXAsmPrinter.h 260 std::string getPTXFundamentalTypeStr(Type *Ty, bool = true) const;
lib/Target/NVPTX/NVPTXGenericToNVVM.cpp 221 Value *Idx = ConstantInt::get(Type::getInt32Ty(M->getContext()), i);
lib/Target/NVPTX/NVPTXISelLowering.cpp 163 Type *Ty, SmallVectorImpl<EVT> &ValueVTs,
186 for(auto *EI : STy->elements()) {
1259 const DataLayout &DL, Type *retTy, const ArgListTy &Args,
1272 if (retTy->getTypeID() == Type::VoidTyID) {
1309 Type *Ty = Args[i].Ty;
1358 Type *ETy = PTy->getElementType();
1372 Type *Ty, unsigned Idx,
1433 Type *RetTy = CLI.RetTy;
1461 Type *Ty = Args[i].Ty;
2445 Type *Ty = arg->getType();
2482 std::vector<Type *> argTypes;
2501 Type *Ty = argTypes[i];
2666 Type *RetTy = MF.getFunction().getReturnType();
4217 const AddrMode &AM, Type *Ty,
lib/Target/NVPTX/NVPTXISelLowering.h 459 bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty,
463 bool isTruncateFree(Type *SrcTy, Type *DstTy) const override {
463 bool isTruncateFree(Type *SrcTy, Type *DstTy) const override {
492 std::string getPrototype(const DataLayout &DL, Type *, const ArgListTy &,
579 unsigned getArgumentAlignment(SDValue Callee, ImmutableCallSite CS, Type *Ty,
lib/Target/NVPTX/NVPTXLowerAggrCopies.cpp 111 ConstantInt::get(Type::getInt32Ty(Context), NumLoads);
lib/Target/NVPTX/NVPTXLowerArgs.cpp 161 Type *StructType = PType->getElementType();
lib/Target/NVPTX/NVPTXTargetTransformInfo.cpp 114 unsigned Opcode, Type *Ty, TTI::OperandValueKind Opd1Info,
lib/Target/NVPTX/NVPTXTargetTransformInfo.h 89 unsigned Opcode, Type *Ty,
lib/Target/NVPTX/NVVMIntrRange.cpp 72 IntegerType *Int32Ty = Type::getInt32Ty(Context);
lib/Target/PowerPC/PPCBoolRetToInt.cpp 93 Type *IntTy = ST->isPPC64() ? Type::getInt64Ty(V->getContext())
93 Type *IntTy = ST->isPPC64() ? Type::getInt64Ty(V->getContext())
94 : Type::getInt32Ty(V->getContext());
263 Type *Int1Ty = Type::getInt1Ty(U->getContext());
263 Type *Int1Ty = Type::getInt1Ty(U->getContext());
lib/Target/PowerPC/PPCFastISel.cpp 145 bool isTypeLegal(Type *Ty, MVT &VT);
146 bool isLoadTypeLegal(Type *Ty, MVT &VT);
274 bool PPCFastISel::isTypeLegal(Type *Ty, MVT &VT) {
288 bool PPCFastISel::isLoadTypeLegal(Type *Ty, MVT &VT) {
443 IntegerType *OffsetTy = Type::getInt64Ty(*Context);
824 Type *Ty = SrcValue1->getType();
1066 Type *DstTy = I->getType();
1191 Type *DstTy = I->getType();
1204 Type *SrcTy = Src->getType();
1569 Type *RetTy = CLI.RetTy;
1617 Type *ArgTy = ArgValue->getType();
1898 Type *DestTy = I->getType();
1900 Type *SrcTy = Src->getType();
lib/Target/PowerPC/PPCISelLowering.cpp 1246 static void getMaxByValAlign(Type *Ty, unsigned &MaxAlign,
1261 for (auto *EltTy : STy->elements()) {
1274 unsigned PPCTargetLowering::getByValTypeAlignment(Type *Ty,
3154 Type *IntPtrTy = DAG.getDataLayout().getIntPtrType(*DAG.getContext());
3173 CallingConv::C, Type::getVoidTy(*DAG.getContext()),
8292 ConstantFP::get(Type::getFloatTy(*DAG.getContext()), 1.0);
8294 ConstantFP::get(Type::getFloatTy(*DAG.getContext()), -1.0);
8299 CV[i] = UndefValue::get(Type::getFloatTy(*DAG.getContext()));
13621 Type *Ty = MemVT.getTypeForEVT(*DAG.getContext());
13623 Type *STy = MemVT.getScalarType().getTypeForEVT(*DAG.getContext());
14258 Type *type = CallOperandVal->getType();
14469 const AddrMode &AM, Type *Ty,
14850 Type *Ty) const {
14857 bool PPCTargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
14857 bool PPCTargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
lib/Target/PowerPC/PPCISelLowering.h 795 unsigned getByValTypeAlignment(Type *Ty,
823 Type *Ty, unsigned AS,
841 bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
841 bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
851 Type *Ty) const override;
923 Type *Ty, CallingConv::ID CallConv, bool isVarArg) const override {
lib/Target/PowerPC/PPCLoopPreIncPrep.cpp 344 Type *I8Ty = Type::getInt8Ty(MemI->getParent()->getContext());
344 Type *I8Ty = Type::getInt8Ty(MemI->getParent()->getContext());
345 Type *I8PtrTy = Type::getInt8PtrTy(MemI->getParent()->getContext(),
345 Type *I8PtrTy = Type::getInt8PtrTy(MemI->getParent()->getContext(),
lib/Target/PowerPC/PPCTargetTransformInfo.cpp 58 int PPCTTIImpl::getIntImmCost(const APInt &Imm, Type *Ty) {
88 Type *Ty) {
122 Type *Ty) {
550 Type::getInt64Ty(C) : Type::getInt32Ty(C);
550 Type::getInt64Ty(C) : Type::getInt32Ty(C);
612 unsigned PPCTTIImpl::getRegisterClassForType(bool Vector, Type *Ty) const {
699 int PPCTTIImpl::vectorCostAdjustment(int Cost, unsigned Opcode, Type *Ty1,
700 Type *Ty2) {
724 unsigned Opcode, Type *Ty, TTI::OperandValueKind Op1Info,
735 int PPCTTIImpl::getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index,
736 Type *SubTp) {
749 int PPCTTIImpl::getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
749 int PPCTTIImpl::getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
757 int PPCTTIImpl::getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
757 int PPCTTIImpl::getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
763 int PPCTTIImpl::getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index) {
836 int PPCTTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
909 int PPCTTIImpl::getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
lib/Target/PowerPC/PPCTargetTransformInfo.h 47 int getIntImmCost(const APInt &Imm, Type *Ty);
49 int getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm, Type *Ty);
51 Type *Ty);
80 unsigned getRegisterClassForType(bool Vector, Type *Ty = nullptr) const;
86 int vectorCostAdjustment(int Cost, unsigned Opcode, Type *Ty1, Type *Ty2);
86 int vectorCostAdjustment(int Cost, unsigned Opcode, Type *Ty1, Type *Ty2);
88 unsigned Opcode, Type *Ty,
94 int getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index, Type *SubTp);
94 int getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index, Type *SubTp);
95 int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
95 int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
97 int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
97 int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
99 int getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index);
100 int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
102 int getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
lib/Target/RISCV/RISCVISelLowering.cpp 253 const AddrMode &AM, Type *Ty,
289 bool RISCVTargetLowering::isTruncateFree(Type *SrcTy, Type *DstTy) const {
289 bool RISCVTargetLowering::isTruncateFree(Type *SrcTy, Type *DstTy) const {
548 IntegerType *CallTy = Type::getIntNTy(*DAG.getContext(), Ty.getSizeInBits());
1450 bool IsRet, Type *OrigTy) {
1628 Type *ArgTy = nullptr;
1653 Type *OrigTy = CLI ? CLI->getArgs()[Outs[i].OrigArgIndex].Ty : nullptr;
2810 Type *Tys[] = {AlignedAddr->getType()};
2868 Type *Tys[] = {AlignedAddr->getType()};
lib/Target/RISCV/RISCVISelLowering.h 68 bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty,
73 bool isTruncateFree(Type *SrcTy, Type *DstTy) const override;
73 bool isTruncateFree(Type *SrcTy, Type *DstTy) const override;
174 Type *Ty) const override {
lib/Target/RISCV/RISCVTargetObjectFile.cpp 64 Type *Ty = GVA->getValueType();
lib/Target/RISCV/RISCVTargetTransformInfo.cpp 18 int RISCVTTIImpl::getIntImmCost(const APInt &Imm, Type *Ty) {
33 Type *Ty) {
89 const APInt &Imm, Type *Ty) {
lib/Target/RISCV/RISCVTargetTransformInfo.h 44 int getIntImmCost(const APInt &Imm, Type *Ty);
45 int getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm, Type *Ty);
47 Type *Ty);
lib/Target/Sparc/SparcISelLowering.cpp 831 Type *ElementTy = Ty->getElementType();
2126 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
2157 Type *RetTy = Op.getValueType().getTypeForEVT(*DAG.getContext());
2158 Type *RetTyABI = RetTy;
2173 RetTyABI = Type::getVoidTy(*DAG.getContext());
2225 Type *RetTy = Type::getInt32Ty(*DAG.getContext());
2225 Type *RetTy = Type::getInt32Ty(*DAG.getContext());
lib/Target/SystemZ/SystemZISelLowering.cpp 823 Type *Ty) {
877 Type *MemAccessTy = (isa<LoadInst>(I) ? I->getType() :
906 const AddrMode &AM, Type *Ty, unsigned AS, Instruction *I) const {
931 bool SystemZTargetLowering::isTruncateFree(Type *FromType, Type *ToType) const {
931 bool SystemZTargetLowering::isTruncateFree(Type *FromType, Type *ToType) const {
993 Type *type = CallOperandVal->getType();
1210 bool SystemZTargetLowering::allowTruncateForTailCall(Type *FromType,
1211 Type *ToType) const {
lib/Target/SystemZ/SystemZISelLowering.h 412 bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty,
419 bool isTruncateFree(Type *, Type *) const override;
419 bool isTruncateFree(Type *, Type *) const override;
485 bool allowTruncateForTailCall(Type *, Type *) const override;
485 bool allowTruncateForTailCall(Type *, Type *) const override;
lib/Target/SystemZ/SystemZTDC.cpp 101 if (LI && LI->getType() == Type::getInt1Ty(Ctx) &&
345 Value *Zero32 = ConstantInt::get(Type::getInt32Ty(Ctx), 0);
361 Value *MaskVal = ConstantInt::get(Type::getInt64Ty(Ctx), Mask);
lib/Target/SystemZ/SystemZTargetTransformInfo.cpp 33 int SystemZTTIImpl::getIntImmCost(const APInt &Imm, Type *Ty) {
66 const APInt &Imm, Type *Ty) {
184 const APInt &Imm, Type *Ty) {
261 Type *MemAccessTy = I.getOperand(0)->getType();
326 bool SystemZTTIImpl::hasDivRemOp(Type *DataType, bool IsSigned) {
333 static unsigned getScalarSizeInBits(Type *Ty) {
343 static unsigned getNumVectorRegs(Type *Ty) {
351 unsigned Opcode, Type *Ty,
514 int SystemZTTIImpl::getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index,
515 Type *SubTp) {
552 static unsigned getElSizeLog2Diff(Type *Ty0, Type *Ty1) {
552 static unsigned getElSizeLog2Diff(Type *Ty0, Type *Ty1) {
564 getVectorTruncCost(Type *SrcTy, Type *DstTy) {
564 getVectorTruncCost(Type *SrcTy, Type *DstTy) {
604 getVectorBitmaskConversionCost(Type *SrcTy, Type *DstTy) {
604 getVectorBitmaskConversionCost(Type *SrcTy, Type *DstTy) {
628 static Type *getCmpOpsType(const Instruction *I, unsigned VF = 1) {
629 Type *OpTy = nullptr;
645 Type *ElTy = OpTy->getScalarType();
655 getBoolVecToIntConversionCost(unsigned Opcode, Type *Dst,
662 Type *CmpOpTy = ((I != nullptr) ? getCmpOpsType(I, VF) : nullptr);
671 int SystemZTTIImpl::getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
671 int SystemZTTIImpl::getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
785 Type *CmpOpTy = ((I != nullptr) ? getCmpOpsType(I) : nullptr);
808 int SystemZTTIImpl::getCmpSelInstrCost(unsigned Opcode, Type *ValTy,
809 Type *CondTy, const Instruction *I) {
852 Type *CmpOpTy = ((I != nullptr) ? getCmpOpsType(I, VF) : nullptr);
889 getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index) {
997 int SystemZTTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
1062 int SystemZTTIImpl::getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
1123 static int getVectorIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy) {
1129 int SystemZTTIImpl::getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
1138 int SystemZTTIImpl::getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
1139 ArrayRef<Type *> Tys,
lib/Target/SystemZ/SystemZTargetTransformInfo.h 41 int getIntImmCost(const APInt &Imm, Type *Ty);
43 int getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm, Type *Ty);
45 Type *Ty);
66 bool hasDivRemOp(Type *DataType, bool IsSigned);
73 unsigned Opcode, Type *Ty,
79 int getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index, Type *SubTp);
79 int getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index, Type *SubTp);
80 unsigned getVectorTruncCost(Type *SrcTy, Type *DstTy);
80 unsigned getVectorTruncCost(Type *SrcTy, Type *DstTy);
81 unsigned getVectorBitmaskConversionCost(Type *SrcTy, Type *DstTy);
81 unsigned getVectorBitmaskConversionCost(Type *SrcTy, Type *DstTy);
82 unsigned getBoolVecToIntConversionCost(unsigned Opcode, Type *Dst,
84 int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
84 int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
86 int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
86 int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
88 int getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index);
90 int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
93 int getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
101 int getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
104 int getIntrinsicInstrCost(Intrinsic::ID ID, Type *RetTy,
105 ArrayRef<Type *> Tys, FastMathFlags FMF,
lib/Target/WebAssembly/WebAssemblyFastISel.cpp 117 MVT::SimpleValueType getSimpleType(Type *Ty) {
653 Type *ArgTy = Arg.getType();
lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp 135 Type *ExpectedRtnType = F->getFunctionType()->getReturnType();
136 Type *RtnType = Ty->getReturnType();
144 Type *ArgType = AI->getType();
145 Type *ParamType = *PI;
179 Type *ExpectedRtnType = F->getFunctionType()->getReturnType();
180 Type *RtnType = Ty->getReturnType();
256 Type *MainArgTys[] = {Type::getInt32Ty(C),
256 Type *MainArgTys[] = {Type::getInt32Ty(C),
257 PointerType::get(Type::getInt8PtrTy(C), 0)};
258 FunctionType *MainTy = FunctionType::get(Type::getInt32Ty(C), MainArgTys,
lib/Target/WebAssembly/WebAssemblyISelLowering.cpp 352 Type *Ty = Float64 ? Type::getDoubleTy(Context) : Type::getFloatTy(Context);
352 Type *Ty = Float64 ? Type::getDoubleTy(Context) : Type::getFloatTy(Context);
352 Type *Ty = Float64 ? Type::getDoubleTy(Context) : Type::getFloatTy(Context);
514 Type *Ty, unsigned AS,
662 Type *RetTy = F.getReturnType();
749 Type *Ty = VT.getTypeForEVT(*DAG.getContext());
lib/Target/WebAssembly/WebAssemblyISelLowering.h 59 bool isLegalAddressingMode(const DataLayout &DL, const AddrMode &AM, Type *Ty,
lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp 334 for (Type *ParamTy : FTy->params())
356 PointerType *Int8PtrTy = Type::getInt8PtrTy(M.getContext());
357 SmallVector<Type *, 16> Args(NumClauses, Int8PtrTy);
448 SmallVector<Type *, 16> ArgTys;
454 auto *CalleeTy = cast<PointerType>(Callee->getType())->getElementType();
565 Value *ThrewInt = IRB.CreateIntToPtr(Threw, Type::getInt32PtrTy(C),
690 SmallVector<Type *, 4> Params = {SetjmpFTy->getParamType(0),
691 IRB.getInt32Ty(), Type::getInt32PtrTy(C),
694 FunctionType::get(Type::getInt32PtrTy(C), Params, false);
699 Params = {IRB.getInt32Ty(), Type::getInt32PtrTy(C), IRB.getInt32Ty()};
1073 SetjmpTableSSA.Initialize(Type::getInt32PtrTy(C), "setjmpTable");
1074 SetjmpTableSizeSSA.Initialize(Type::getInt32Ty(C), "setjmpTableSize");
lib/Target/WebAssembly/WebAssemblyLowerGlobalDtors.cpp 106 PointerType *VoidStar = Type::getInt8PtrTy(C);
107 Type *AtExitFuncArgs[] = {VoidStar};
109 FunctionType::get(Type::getVoidTy(C), AtExitFuncArgs,
114 FunctionType::get(Type::getInt32Ty(C),
121 Type *DsoHandleTy = Type::getInt8Ty(C);
121 Type *DsoHandleTy = Type::getInt8Ty(C);
146 FunctionType *VoidVoid = FunctionType::get(Type::getVoidTy(C),
lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp 200 Type *RetTy = F.getReturnType();
lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.cpp 30 Type *Ty, SmallVectorImpl<MVT> &ValueVTs) {
62 for (auto *Param : Ty->params())
lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.h 139 void computeLegalValueVTs(const Function &F, const TargetMachine &TM, Type *Ty,
lib/Target/WebAssembly/WebAssemblyRegStackify.cpp 115 Type::getFloatTy(MF.getFunction().getContext())));
120 Type::getDoubleTy(MF.getFunction().getContext())));
lib/Target/WebAssembly/WebAssemblyTargetTransformInfo.cpp 47 unsigned Opcode, Type *Ty, TTI::OperandValueKind Opd1Info,
74 unsigned WebAssemblyTTIImpl::getVectorInstrCost(unsigned Opcode, Type *Val,
lib/Target/WebAssembly/WebAssemblyTargetTransformInfo.h 59 unsigned Opcode, Type *Ty,
65 unsigned getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index);
lib/Target/X86/X86CallLowering.cpp 82 Type *PartTy = PartVT.getTypeForEVT(Context);
lib/Target/X86/X86FastISel.cpp 164 bool isTypeLegal(Type *Ty, MVT &VT, bool AllowI1 = false);
249 Type *RetTy =
291 bool X86FastISel::isTypeLegal(Type *Ty, MVT &VT, bool AllowI1) {
2673 Type *RetTy = II->getCalledFunction()->getReturnType();
2807 Type *RetTy = II->getCalledFunction()->getReturnType();
2868 Type *RetTy = Ty->getTypeAtIndex(0U);
3005 Type *RetTy = II->getCalledFunction()->getReturnType();
3090 Type *ArgTy = Arg.getType();
3260 Val = ConstantExpr::getSExt(CI, Type::getInt32Ty(CI->getContext()));
3262 Val = ConstantExpr::getZExt(CI, Type::getInt32Ty(CI->getContext()));
lib/Target/X86/X86ISelDAGToDAG.cpp 1319 .setCallee(CallingConv::C, Type::getVoidTy(*CurDAG->getContext()),
lib/Target/X86/X86ISelLowering.cpp 2028 static void getMaxByValAlign(Type *Ty, unsigned &MaxAlign) {
2040 for (auto *EltTy : STy->elements()) {
2055 unsigned X86TargetLowering::getByValTypeAlignment(Type *Ty,
2204 Type *T = Args[Idx].Ty;
2294 ConstantInt::get(Type::getInt32Ty(IRB.getContext()), Offset),
2295 Type::getInt8PtrTy(IRB.getContext())->getPointerTo(AddressSpace));
2323 Type::getInt8PtrTy(M.getContext()));
2327 "__security_check_cookie", Type::getVoidTy(M.getContext()),
2328 Type::getInt8PtrTy(M.getContext()));
4303 bool isCalleeStructRet, bool isCallerStructRet, Type *RetTy,
4896 Type *Ty) const {
6103 Type *CstTy = Cst->getType();
8087 Const = Constant::getIntegerValue(Type::getIntNTy(C, ScalarSize), Val);
8226 Type *ScalarTy = Type::getIntNTy(*Ctx, SplatBitSize);
8226 Type *ScalarTy = Type::getIntNTy(*Ctx, SplatBitSize);
9650 Type *EltType = Op.getValueType().getScalarType().getTypeForEVT(Context);
18033 Value *Ptr = Constant::getNullValue(Type::getInt8PtrTy(*DAG.getContext(),
18176 ? Type::getInt8PtrTy(*DAG.getContext(),
18178 : Type::getInt32PtrTy(*DAG.getContext(),
22349 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
25414 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
26436 bool X86TargetLowering::needsCmpXchgNb(Type *MemType) const {
26450 Type *MemType = SI->getValueOperand()->getType();
26465 Type *MemType = LI->getType();
26484 Type *MemType = AI->getType();
26525 Type *MemType = AI->getType();
27289 Type *ArgTy = ArgVT.getTypeForEVT(*DAG.getContext());
27310 Type *RetTy = isF64 ? (Type *)StructType::get(ArgTy, ArgTy)
28902 const AddrMode &AM, Type *Ty,
28953 bool X86TargetLowering::isVectorShiftByScalarCheap(Type *Ty) const {
29012 bool X86TargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
29012 bool X86TargetLowering::isTruncateFree(Type *Ty1, Type *Ty2) const {
29020 bool X86TargetLowering::allowTruncateForTailCall(Type *Ty1, Type *Ty2) const {
29020 bool X86TargetLowering::allowTruncateForTailCall(Type *Ty1, Type *Ty2) const {
29055 bool X86TargetLowering::isZExtFree(Type *Ty1, Type *Ty2) const {
29055 bool X86TargetLowering::isZExtFree(Type *Ty1, Type *Ty2) const {
38987 Type *Ty = Init->getType();
45430 Type *type = CallOperandVal->getType();
45692 if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
45706 if (ConstantInt::isValueValidForType(Type::getInt32Ty(*DAG.getContext()),
46124 const AddrMode &AM, Type *Ty,
lib/Target/X86/X86ISelLowering.h 728 unsigned getByValTypeAlignment(Type *Ty,
999 Type *Ty, unsigned AS,
1021 int getScalingFactorCost(const DataLayout &DL, const AddrMode &AM, Type *Ty,
1024 bool isVectorShiftByScalarCheap(Type *Ty) const override;
1035 bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
1035 bool isTruncateFree(Type *Ty1, Type *Ty2) const override;
1038 bool allowTruncateForTailCall(Type *Ty1, Type *Ty2) const override;
1038 bool allowTruncateForTailCall(Type *Ty1, Type *Ty2) const override;
1048 bool isZExtFree(Type *Ty1, Type *Ty2) const override;
1048 bool isZExtFree(Type *Ty1, Type *Ty2) const override;
1119 Type *Ty) const override;
1303 Type *RetTy,
1419 bool needsCmpXchgNb(Type *MemType) const;
lib/Target/X86/X86InstrInfo.cpp 5317 Type *Ty;
5320 Ty = Type::getFloatTy(MF.getFunction().getContext());
5322 Ty = Type::getDoubleTy(MF.getFunction().getContext());
5324 Ty = Type::getFP128Ty(MF.getFunction().getContext());
5326 Ty = VectorType::get(Type::getInt32Ty(MF.getFunction().getContext()),16);
5329 Ty = VectorType::get(Type::getInt32Ty(MF.getFunction().getContext()), 8);
5331 Ty = VectorType::get(Type::getInt32Ty(MF.getFunction().getContext()), 2);
5333 Ty = VectorType::get(Type::getInt32Ty(MF.getFunction().getContext()), 4);
lib/Target/X86/X86InterleavedAccess.cpp 130 Type *ShuffleEltTy = ShuffleVecTy->getVectorElementType();
173 Type *VecWidth = VecInst->getType();
196 Type *VecBaseTy, *VecBasePtrTy;
204 VecBaseTy = VectorType::get(Type::getInt8Ty(LI->getContext()), 16);
730 Type *ShuffleEltTy = Inst->getType();
759 Type *ShuffleEltTy = ShuffleTy->getVectorElementType();
lib/Target/X86/X86RetpolineThunks.cpp 200 auto Type = FunctionType::get(Type::getVoidTy(Ctx), false);
lib/Target/X86/X86SelectionDAGInfo.cpp 78 Type *IntPtrTy = DAG.getDataLayout().getIntPtrType(*DAG.getContext());
90 .setLibCallee(CallingConv::C, Type::getVoidTy(*DAG.getContext()),
lib/Target/X86/X86ShuffleDecodeConstantPool.cpp 37 Type *CstTy = C->getType();
41 Type *CstEltTy = CstTy->getVectorElementType();
190 Type *MaskTy = C->getType();
245 Type *MaskTy = C->getType();
lib/Target/X86/X86TargetTransformInfo.cpp 173 unsigned Opcode, Type *Ty,
888 int X86TTIImpl::getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index,
889 Type *SubTp) {
930 Type *VecTy = VectorType::get(Tp->getVectorElementType(),
932 Type *SubTy = VectorType::get(Tp->getVectorElementType(),
968 Type *SingleOpTy = VectorType::get(Tp->getVectorElementType(),
1272 int X86TTIImpl::getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
1272 int X86TTIImpl::getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
1694 int X86TTIImpl::getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
1694 int X86TTIImpl::getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
1877 int X86TTIImpl::getIntrinsicInstrCost(Intrinsic::ID IID, Type *RetTy,
1878 ArrayRef<Type *> Tys, FastMathFlags FMF,
2147 Type *OpTy = RetTy;
2281 int X86TTIImpl::getIntrinsicInstrCost(Intrinsic::ID IID, Type *RetTy,
2376 int X86TTIImpl::getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index) {
2379 Type *ScalarType = Val->getScalarType();
2407 int X86TTIImpl::getMemoryOpCost(unsigned Opcode, Type *Src,
2451 int X86TTIImpl::getMaskedMemoryOpCost(unsigned Opcode, Type *SrcTy,
2464 VectorType::get(Type::getInt8Ty(SrcVTy->getContext()), NumElem);
2471 Instruction::ICmp, Type::getInt8Ty(SrcVTy->getContext()), nullptr);
2507 int X86TTIImpl::getAddressComputationCost(Type *Ty, ScalarEvolution *SE,
2532 int X86TTIImpl::getArithmeticReductionCost(unsigned Opcode, Type *ValTy,
2683 int X86TTIImpl::getMinMaxReductionCost(Type *ValTy, Type *CondTy,
2683 int X86TTIImpl::getMinMaxReductionCost(Type *ValTy, Type *CondTy,
2926 int X86TTIImpl::getIntImmCost(const APInt &Imm, Type *Ty) {
2961 Type *Ty) {
3058 Type *Ty) {
3108 int X86TTIImpl::getGSVectorCost(unsigned Opcode, Type *SrcVTy, Value *Ptr,
3132 Type *IndxTy = GEP->getOperand(i)->getType();
3150 Type *IndexVTy = VectorType::get(IntegerType::get(SrcVTy->getContext(),
3157 Type *SplitSrcTy = VectorType::get(SrcVTy->getScalarType(), VF / SplitFactor);
3179 int X86TTIImpl::getGSScalarCost(unsigned Opcode, Type *SrcVTy,
3187 VectorType::get(Type::getInt1Ty(SrcVTy->getContext()), VF);
3190 getCmpSelInstrCost(Instruction::ICmp, Type::getInt1Ty(SrcVTy->getContext()),
3216 int X86TTIImpl::getGatherScatterOpCost(unsigned Opcode, Type *SrcVTy,
3262 bool X86TTIImpl::isLegalMaskedLoad(Type *DataTy, MaybeAlign Alignment) {
3269 Type *ScalarTy = DataTy->getScalarType();
3285 bool X86TTIImpl::isLegalMaskedStore(Type *DataType, MaybeAlign Alignment) {
3289 bool X86TTIImpl::isLegalNTLoad(Type *DataType, Align Alignment) {
3300 bool X86TTIImpl::isLegalNTStore(Type *DataType, Align Alignment) {
3324 bool X86TTIImpl::isLegalMaskedExpandLoad(Type *DataTy) {
3335 Type *ScalarTy = DataTy->getVectorElementType();
3348 bool X86TTIImpl::isLegalMaskedCompressStore(Type *DataTy) {
3352 bool X86TTIImpl::isLegalMaskedGather(Type *DataTy) {
3376 Type *ScalarTy = DataTy->getScalarType();
3390 bool X86TTIImpl::isLegalMaskedScatter(Type *DataType) {
3397 bool X86TTIImpl::hasDivRemOp(Type *DataType, bool IsSigned) {
3402 bool X86TTIImpl::isFCmpOrdCheaperThanFCmpZero(Type *Ty) {
3481 int X86TTIImpl::getInterleavedMemoryOpCostAVX2(unsigned Opcode, Type *VecTy,
3513 Type *ScalarTy = VecTy->getVectorElementType();
3522 Type *SingleMemOpTy = VectorType::get(VecTy->getVectorElementType(),
3597 int X86TTIImpl::getInterleavedMemoryOpCostAVX512(unsigned Opcode, Type *VecTy,
3622 Type *SingleMemOpTy = VectorType::get(VecTy->getVectorElementType(),
3659 Type *ResultTy = VectorType::get(VecTy->getVectorElementType(),
3722 int X86TTIImpl::getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
3730 Type *EltTy = VecTy->getVectorElementType();
lib/Target/X86/X86TargetTransformInfo.h 125 unsigned Opcode, Type *Ty,
131 int getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index, Type *SubTp);
131 int getShuffleCost(TTI::ShuffleKind Kind, Type *Tp, int Index, Type *SubTp);
132 int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
132 int getCastInstrCost(unsigned Opcode, Type *Dst, Type *Src,
134 int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
134 int getCmpSelInstrCost(unsigned Opcode, Type *ValTy, Type *CondTy,
136 int getVectorInstrCost(unsigned Opcode, Type *Val, unsigned Index);
137 int getMemoryOpCost(unsigned Opcode, Type *Src, MaybeAlign Alignment,
139 int getMaskedMemoryOpCost(unsigned Opcode, Type *Src, unsigned Alignment,
141 int getGatherScatterOpCost(unsigned Opcode, Type *DataTy, Value *Ptr,
143 int getAddressComputationCost(Type *PtrTy, ScalarEvolution *SE,
148 int getIntrinsicInstrCost(Intrinsic::ID IID, Type *RetTy,
149 ArrayRef<Type *> Tys, FastMathFlags FMF,
151 int getIntrinsicInstrCost(Intrinsic::ID IID, Type *RetTy,
155 int getArithmeticReductionCost(unsigned Opcode, Type *Ty,
158 int getMinMaxReductionCost(Type *Ty, Type *CondTy, bool IsPairwiseForm,
158 int getMinMaxReductionCost(Type *Ty, Type *CondTy, bool IsPairwiseForm,
161 int getInterleavedMemoryOpCost(unsigned Opcode, Type *VecTy,
166 int getInterleavedMemoryOpCostAVX512(unsigned Opcode, Type *VecTy,
171 int getInterleavedMemoryOpCostAVX2(unsigned Opcode, Type *VecTy,
179 int getIntImmCost(const APInt &Imm, Type *Ty);
183 int getIntImmCost(unsigned Opcode, unsigned Idx, const APInt &Imm, Type *Ty);
185 Type *Ty);
189 bool isLegalMaskedLoad(Type *DataType, MaybeAlign Alignment);
190 bool isLegalMaskedStore(Type *DataType, MaybeAlign Alignment);
191 bool isLegalNTLoad(Type *DataType, Align Alignment);
192 bool isLegalNTStore(Type *DataType, Align Alignment);
193 bool isLegalMaskedGather(Type *DataType);
194 bool isLegalMaskedScatter(Type *DataType);
195 bool isLegalMaskedExpandLoad(Type *DataType);
196 bool isLegalMaskedCompressStore(Type *DataType);
197 bool hasDivRemOp(Type *DataType, bool IsSigned);
198 bool isFCmpOrdCheaperThanFCmpZero(Type *Ty);
208 int getGSScalarCost(unsigned Opcode, Type *DataTy, bool VariableMask,
210 int getGSVectorCost(unsigned Opcode, Type *DataTy, Value *Ptr,
lib/Target/X86/X86WinEHState.cpp 78 Type *getEHLinkRegistrationType();
79 Type *getSEHRegistrationType();
80 Type *getCXXEHRegistrationType();
174 Type *Int8PtrType = Type::getInt8PtrTy(TheModule->getContext());
174 Type *Int8PtrType = Type::getInt8PtrTy(TheModule->getContext());
177 Type::getInt32Ty(TheModule->getContext()),
178 {Int8PtrType, Type::getInt32Ty(TheModule->getContext())},
213 Type *WinEHStatePass::getEHLinkRegistrationType() {
218 Type *FieldTys[] = {
220 Type::getInt8PtrTy(Context) // EXCEPTION_DISPOSITION (*Handler)(...)
232 Type *WinEHStatePass::getCXXEHRegistrationType() {
236 Type *FieldTys[] = {
237 Type::getInt8PtrTy(Context), // void *SavedESP
239 Type::getInt32Ty(Context) // int32_t TryLevel
254 Type *WinEHStatePass::getSEHRegistrationType() {
258 Type *FieldTys[] = {
259 Type::getInt8PtrTy(Context), // void *SavedESP
260 Type::getInt8PtrTy(Context), // void *ExceptionPointers
262 Type::getInt32Ty(Context), // int32_t EncodedScopeTable
263 Type::getInt32Ty(Context) // int32_t TryLevel
278 Type *RegNodeTy;
281 Type *Int8PtrType = Builder.getInt8PtrTy();
282 Type *Int32Ty = Builder.getInt32Ty();
283 Type *VoidTy = Builder.getVoidTy();
358 FunctionType::get(Type::getVoidTy(TheModule->getContext()), Int8PtrType,
377 Value *FI8 = Builder.CreateBitCast(F, Type::getInt8PtrTy(F->getContext()));
391 Type *Int32Ty = Type::getInt32Ty(Context);
391 Type *Int32Ty = Type::getInt32Ty(Context);
392 Type *Int8PtrType = Type::getInt8PtrTy(Context);
392 Type *Int8PtrType = Type::getInt8PtrTy(Context);
393 Type *ArgTys[5] = {Int8PtrType, Int8PtrType, Int8PtrType, Int8PtrType,
429 Type *LinkTy = getEHLinkRegistrationType();
449 Type *LinkTy = getEHLinkRegistrationType();
lib/Target/XCore/XCoreISelDAGToDAG.cpp 147 ConstantInt::get(Type::getInt32Ty(*CurDAG->getContext()), Val),
lib/Target/XCore/XCoreISelLowering.cpp 268 Type *ObjType = GV->getValueType();
297 Type *Ty = Type::getInt8PtrTy(*DAG.getContext());
297 Type *Ty = Type::getInt8PtrTy(*DAG.getContext());
299 Ty = Type::getInt32Ty(*DAG.getContext());
302 Type::getInt8Ty(*DAG.getContext()), GA, Idx);
465 Type *IntPtrTy = DAG.getDataLayout().getIntPtrType(Context);
516 Type *IntPtrTy = DAG.getDataLayout().getIntPtrType(Context);
529 CallingConv::C, Type::getVoidTy(Context),
1884 const AddrMode &AM, Type *Ty,
1887 if (Ty->getTypeID() == Type::VoidTyID)
lib/Target/XCore/XCoreISelLowering.h 125 Type *Ty, unsigned AS,
lib/Target/XCore/XCoreInstrInfo.cpp 445 Type::getInt32Ty(MBB.getParent()->getFunction().getContext()), Value);
lib/Target/XCore/XCoreLowerThreadLocal.cpp 63 static ArrayType *createLoweredType(Type *OriginalType) {
174 static bool isZeroLengthArray(Type *Ty) {
lib/Target/XCore/XCoreSelectionDAGInfo.cpp 38 Type::getVoidTy(*DAG.getContext()),
lib/Target/XCore/XCoreTargetObjectFile.cpp 120 Type *ObjType = GO->getValueType();
lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp 268 Type *Ty = I.getType();
lib/Transforms/AggressiveInstCombine/AggressiveInstCombineInternal.h 106 Type *getBestTruncatedType();
114 Value *getReducedOperand(Value *V, Type *SclTy);
121 void ReduceExpressionDag(Type *SclTy);
lib/Transforms/AggressiveInstCombine/TruncInstCombine.cpp 142 Type *DstTy = CurrentTruncInst->getType();
211 Type *Ty = DL.getSmallestLegalIntType(DstTy->getContext(), MinBitWidth);
228 Type *TruncInstCombine::getBestTruncatedType() {
277 static Type *getReducedType(Value *V, Type *Ty) {
277 static Type *getReducedType(Value *V, Type *Ty) {
284 Value *TruncInstCombine::getReducedOperand(Value *V, Type *SclTy) {
285 Type *Ty = getReducedType(V, SclTy);
300 void TruncInstCombine::ReduceExpressionDag(Type *SclTy) {
314 Type *Ty = getReducedType(I, SclTy);
364 Type *DstTy = CurrentTruncInst->getType();
406 if (Type *NewDstSclTy = getBestTruncatedType()) {
lib/Transforms/CFGuard/CFGuard.cpp 191 Type *CalledOperandType = CalledOperand->getType();
238 GuardFnType = FunctionType::get(Type::getVoidTy(M.getContext()),
239 {Type::getInt8PtrTy(M.getContext())}, false);
lib/Transforms/Coroutines/CoroEarly.cpp 39 AnyResumeFnPtrTy(FunctionType::get(Type::getVoidTy(Context), Int8Ptr,
68 Type *Int8Ty = Builder.getInt8Ty();
116 auto *FnTy = FunctionType::get(Type::getVoidTy(C), FramePtrTy,
lib/Transforms/Coroutines/CoroElide.cpp 37 void elideHeapAllocations(Function *F, Type *FrameTy, AAResults &AA);
53 Type *IntrTy = Users.front()->getType();
54 Type *ValueTy = Value->getType();
93 static Type *getFrameType(Function *Resume) {
94 auto *ArgType = Resume->arg_begin()->getType();
108 void Lowerer::elideHeapAllocations(Function *F, Type *FrameTy, AAResults &AA) {
132 new BitCastInst(Frame, Type::getInt8PtrTy(C), "vFrame", InsertPt);
246 auto *FrameTy = getFrameType(cast<Function>(ResumeAddrConstant));
lib/Transforms/Coroutines/CoroFrame.cpp 351 void addType(Type *Ty) {
359 void addTypes(SmallVectorImpl<Type *> const &Types) {
360 for (auto *Ty : Types)
364 unsigned computePadding(Type *Ty, unsigned ForcedAlignment) {
378 ArrayType *getPaddingType(Type *Ty, unsigned ForcedAlignment) {
380 return ArrayType::get(Type::getInt8Ty(Context), Padding);
403 SmallVector<Type *, 8> Types;
409 auto *FnTy = FunctionType::get(Type::getVoidTy(C), FramePtrTy,
415 Type *PromiseType = PromiseAlloca
417 : Type::getInt1Ty(C);
418 Type *IndexType = Type::getIntNTy(C, IndexBits);
418 Type *IndexType = Type::getIntNTy(C, IndexBits);
442 Type *Ty = nullptr;
620 ConstantInt::get(Type::getInt32Ty(C), 0),
621 ConstantInt::get(Type::getInt32Ty(C), Index),
628 Indices.push_back(ConstantInt::get(Type::getInt32Ty(C), 0));
1163 static Value *emitGetSwiftErrorValue(IRBuilder<> &Builder, Type *ValueTy,
lib/Transforms/Coroutines/CoroInstr.h 127 ConstantPointerNull::get(Type::getInt8PtrTy(getContext())));
188 auto *const Int8PtrTy = Type::getInt8PtrTy(getContext());
lib/Transforms/Coroutines/CoroInternal.h 171 ArrayRef<Type*> getRetconResultTypes() const {
184 ArrayRef<Type*> getRetconResumeTypes() const {
lib/Transforms/Coroutines/CoroSplit.cpp 734 NewFramePtr, Type::getInt8PtrTy(Builder.getContext()), "vFrame");
837 auto *BC = ConstantExpr::getPointerCast(GV, Type::getInt8PtrTy(C));
1399 auto *Null = ConstantPointerNull::get(Type::getInt8PtrTy(Context));
1402 FunctionType *FnTy = FunctionType::get(Type::getVoidTy(Context),
1403 {Type::getInt8PtrTy(Context)}, false);
1419 auto *FnTy = FunctionType::get(Type::getVoidTy(C), Type::getInt8PtrTy(C),
1419 auto *FnTy = FunctionType::get(Type::getVoidTy(C), Type::getInt8PtrTy(C),
lib/Transforms/Coroutines/Coroutines.cpp 96 Int8Ptr(Type::getInt8PtrTy(Context)),
97 ResumeFnType(FunctionType::get(Type::getVoidTy(Context), Int8Ptr,
109 auto *IndexVal = ConstantInt::get(Type::getInt8Ty(Context), Index);
176 Elide ? ConstantPointerNull::get(Type::getInt8PtrTy(CoroId->getContext()))
328 auto *Undef = UndefValue::get(Type::getInt8PtrTy(F.getContext()));
436 Type *SResultTy = Suspend->getType();
437 ArrayRef<Type*> SuspendResultTys;
lib/Transforms/IPO/ArgumentPromotion.cpp 112 std::vector<Type *> Params;
114 using ScalarizeTable = std::set<std::pair<Type *, IndicesVector>>;
143 Type *AgTy = cast<PointerType>(I->getType())->getElementType();
169 Type *SrcTy;
212 Type *RetTy = FTy->getReturnType();
260 Type *AgTy = cast<PointerType>(I->getType())->getElementType();
263 ConstantInt::get(Type::getInt32Ty(F->getContext()), 0), nullptr};
265 Idxs[1] = ConstantInt::get(Type::getInt32Ty(F->getContext()), i);
285 Type *ElTy = V->getType();
289 Type *IdxTy =
290 (ElTy->isStructTy() ? Type::getInt32Ty(F->getContext())
291 : Type::getInt64Ty(F->getContext()));
388 Type *AgTy = cast<PointerType>(I->getType())->getElementType();
393 Value *Idxs[2] = {ConstantInt::get(Type::getInt32Ty(F->getContext()), 0),
397 Idxs[1] = ConstantInt::get(Type::getInt32Ty(F->getContext()), i);
485 static bool allCallersPassValidPointerForArgument(Argument *Arg, Type *Ty) {
570 static bool isSafeToPromoteArgument(Argument *Arg, Type *ByValTy, AAResults &AAR,
608 Type *BaseTy = ByValTy;
777 static bool isDenselyPacked(Type *type, const DataLayout &DL) {
799 Type *ElTy = StructTy->getElementType(i);
935 Type *AgTy = cast<PointerType>(PtrArg->getType())->getElementType();
969 for (const auto *EltTy : STy->elements()) {
991 for (const auto *EltTy : STy->elements()) {
1003 Type *ByValTy =
lib/Transforms/IPO/Attributor.cpp 1532 Type *PtrTy = UseV->getType();
3584 Instruction *AI = new AllocaInst(Type::getInt8Ty(F->getContext()), AS,
3606 ConstantInt::get(Type::getInt1Ty(F->getContext()), false)};
3608 Type *Tys[] = {BI->getType(), MallocCall->getOperand(0)->getType()};
4749 Type *ReturnType = F.getReturnType();
lib/Transforms/IPO/CrossDSOCFI.cpp 105 "__cfi_check", Type::getVoidTy(Ctx), Type::getInt64Ty(Ctx),
105 "__cfi_check", Type::getVoidTy(Ctx), Type::getInt64Ty(Ctx),
106 Type::getInt8PtrTy(Ctx), Type::getInt8PtrTy(Ctx));
106 Type::getInt8PtrTy(Ctx), Type::getInt8PtrTy(Ctx));
132 M.getOrInsertFunction("__cfi_check_fail", Type::getVoidTy(Ctx),
133 Type::getInt8PtrTy(Ctx), Type::getInt8PtrTy(Ctx));
133 Type::getInt8PtrTy(Ctx), Type::getInt8PtrTy(Ctx));
143 ConstantInt *CaseTypeId = ConstantInt::get(Type::getInt64Ty(Ctx), TypeId);
lib/Transforms/IPO/DeadArgumentElimination.cpp 160 std::vector<Type *> Params(FTy->param_begin(), FTy->param_end());
328 Type *RetTy = F->getReturnType();
342 static Type *getRetComponentType(const Function *F, unsigned Idx) {
343 Type *RetTy = F->getReturnType();
737 std::vector<Type*> Params;
769 Type *RetTy = FTy->getReturnType();
770 Type *NRetTy = nullptr;
775 std::vector<Type*> RetTypes;
828 NRetTy = Type::getVoidTy(F->getContext());
lib/Transforms/IPO/ExtractGV.cpp 131 Type *Ty = CurI->getValueType();
lib/Transforms/IPO/GlobalOpt.cpp 122 SmallVector<Type *, 4> Types;
127 Type *Ty = Types.pop_back_val();
130 case Type::PointerTyID: return true;
131 case Type::ArrayTyID:
132 case Type::VectorTyID: {
137 case Type::StructTyID: {
142 Type *InnerTy = *I;
469 Type *Ty = Init->getType();
548 Constant *NullInt =Constant::getNullValue(Type::getInt32Ty(GV->getContext()));
565 Type *NewTy = NewGlobals[Val]->getValueType();
837 OptimizeGlobalAddressOfMalloc(GlobalVariable *GV, CallInst *CI, Type *AllocTy,
843 Type *GlobalType;
884 new GlobalVariable(Type::getInt1Ty(GV->getContext()), false,
1281 Type *MAT = getMallocAllocatedType(CI, TLI);
1300 Type *FieldTy = STy->getElementType(FieldNo);
1313 Type *IntPtrTy = DL.getIntPtrType(CI->getType());
1415 Type *ValTy = cast<GlobalValue>(FieldGlobals[i])->getValueType();
1470 Type *AllocTy,
1539 Type *IntPtrTy = DL.getIntPtrType(CI->getType());
1592 Type *MallocType = getMallocAllocatedType(CI, TLI);
1607 Type *GVElType = GV->getValueType();
1614 if (GVElType == Type::getInt1Ty(GV->getContext()) ||
1628 GlobalVariable *NewGV = new GlobalVariable(Type::getInt1Ty(GV->getContext()),
1704 StoreVal = ConstantInt::get(Type::getInt1Ty(GV->getContext()),
1847 auto *LTy = L->getType();
1849 auto *STy = S->getValueOperand()->getType();
1949 Type *ElemTy = GV->getValueType();
2526 Type *Ty = Init->getType();
2530 Type *CurrentInitTy = CurrentGV->getInitializer()->getType();
2607 PointerType *Int8PtrTy = Type::getInt8PtrTy(V.getContext(), 0);
lib/Transforms/IPO/GlobalSplit.cpp 73 IntegerType *Int32Ty = Type::getInt32Ty(GV.getContext());
lib/Transforms/IPO/LowerTypeTests.cpp 389 IntegerType *Int1Ty = Type::getInt1Ty(M.getContext());
390 IntegerType *Int8Ty = Type::getInt8Ty(M.getContext());
391 PointerType *Int8PtrTy = Type::getInt8PtrTy(M.getContext());
392 ArrayType *Int8Arr0Ty = ArrayType::get(Type::getInt8Ty(M.getContext()), 0);
393 IntegerType *Int32Ty = Type::getInt32Ty(M.getContext());
395 IntegerType *Int64Ty = Type::getInt64Ty(M.getContext());
465 Type *getJumpTableEntryType();
1231 Type *LowerTypeTestsModule::getJumpTableEntryType() {
1252 FunctionType::get(Type::getVoidTy(M.getContext()),
1387 SmallVector<Type *, 16> ArgTypes;
1489 Function::Create(FunctionType::get(Type::getVoidTy(M.getContext()),
1903 FunctionType::get(Type::getVoidTy(M.getContext()), false),
lib/Transforms/IPO/MergeFunctions.cpp 483 static Value *createCast(IRBuilder<> &Builder, Value *V, Type *DestTy) {
484 Type *SrcTy = V->getType();
lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp 142 FunctionType::get(Type::getVoidTy(M.getContext()), false);
334 llvm::ConstantInt::get(Type::getInt8Ty(Ctx), Linkage)));
357 ConstantInt::get(Type::getInt8Ty(Ctx), A.getVisibility())),
359 ConstantInt::get(Type::getInt8Ty(Ctx), A.isWeakForLinker())),
lib/Transforms/IPO/WholeProgramDevirt.cpp 478 Int8Ty(Type::getInt8Ty(M.getContext())),
479 Int8PtrTy(Type::getInt8PtrTy(M.getContext())),
480 Int32Ty(Type::getInt32Ty(M.getContext())),
481 Int64Ty(Type::getInt64Ty(M.getContext())),
1051 FunctionType::get(Type::getVoidTy(M.getContext()), {Int8PtrTy}, true);
1108 std::vector<Type *> NewArgs;
1110 for (Type *T : CS.getFunctionType()->params())
1697 Type::getVoidTy(M.getContext()))
1744 Type::getVoidTy(M.getContext()))
lib/Transforms/InstCombine/InstCombineAddSub.cpp 74 Value *getValue(Type *) const;
330 Value *FAddendCoef::getValue(Type *Ty) const {
829 Type *Ty = Add.getType();
920 Type *Ty = Add.getType();
1080 Type *Ty = I.getType();
1122 Type *XTy = X->getType();
1226 Type *Ty = I.getType();
1518 Type *FPType = LHSConv->getType();
1524 Type *FScalarTy = FTy->getScalarType();
1525 Type *IScalarTy = ITy->getScalarType();
1590 Type *Ty) {
1994 Type *Ty = I.getType();
2144 Type *Ty = I.getType();
lib/Transforms/InstCombine/InstCombineAndOrXor.cpp 170 Type *Ty = V->getType();
1503 Type *DestTy = Logic.getType();
1504 Type *SrcTy = Cast->getSrcTy();
1546 Type *DestTy = I.getType();
1547 Type *SrcTy = Cast0->getSrcTy();
1700 Type *Ty = And.getType();
1966 Type *Ty = I.getType();
2112 Type *Ty = A->getType();
2170 Type *OrigType = A->getType();
2717 Type *Ty = I.getType();
3224 Type *Ty = I.getType();
lib/Transforms/InstCombine/InstCombineCalls.cpp 85 static Type *getPromotedType(Type *Ty) {
85 static Type *getPromotedType(Type *Ty) {
88 return Type::getInt32Ty(Ty->getContext());
97 IntegerType *BoolTy = Type::getInt1Ty(V->getContext());
164 Type *NewSrcPtrTy = PointerType::get(IntType, SrcAddrSp);
165 Type *NewDstPtrTy = PointerType::get(IntType, DstAddrSp);
263 Type *ITy = IntegerType::get(MI->getContext(), Len*8); // n=1 -> i8.
267 Type *NewDstPtrTy = PointerType::get(ITy, DstAddrSp);
548 Type *ResTy = II.getType();
554 Type *ArgTy = Arg0->getType();
613 Type *ResTy = II.getType();
614 Type *ArgTy = Arg->getType();
630 Type *IntegerVecTy = VectorType::getInteger(cast<VectorType>(ArgTy));
631 Type *IntegerTy = Builder.getIntNTy(NumElts);
645 Type *RetTy = II.getType();
646 Type *OpTy = Op1->getType();
730 Type *IntTy64 = Type::getInt64Ty(II.getContext());
730 Type *IntTy64 = Type::getInt64Ty(II.getContext());
773 Type *IntTy8 = Type::getInt8Ty(II.getContext());
773 Type *IntTy8 = Type::getInt8Ty(II.getContext());
774 Type *IntTy32 = Type::getInt32Ty(II.getContext());
774 Type *IntTy32 = Type::getInt32Ty(II.getContext());
853 Type *IntTy8 = Type::getInt8Ty(II.getContext());
853 Type *IntTy8 = Type::getInt8Ty(II.getContext());
854 Type *IntTy32 = Type::getInt32Ty(II.getContext());
854 Type *IntTy32 = Type::getInt32Ty(II.getContext());
892 Type *IntTy64 = Type::getInt64Ty(II.getContext());
892 Type *IntTy64 = Type::getInt64Ty(II.getContext());
901 Type *IntTy8 = Type::getInt8Ty(II.getContext());
901 Type *IntTy8 = Type::getInt8Ty(II.getContext());
922 auto *MaskEltTy = Type::getInt32Ty(II.getContext());
969 auto *MaskEltTy = Type::getInt32Ty(II.getContext());
1019 auto *MaskEltTy = Type::getInt32Ty(II.getContext());
1719 Type *Tys[] = {II->getArgOperand(0)->getType()};
1833 Type *Tys[3] = { CI.getArgOperand(0)->getType(),
1947 Type *Ty = II->getType();
2081 Type *Ty = SI->getType();
2353 Type *OpPtrTy =
2362 Type *OpPtrTy = PointerType::getUnqual(II->getArgOperand(0)->getType());
2370 Type *VTy = VectorType::get(Builder.getFloatTy(),
2391 Type *VTy = VectorType::get(Builder.getFloatTy(),
2394 Type *OpPtrTy = PointerType::getUnqual(VTy);
2403 Type *OpPtrTy =
2485 VectorType::get(Type::getHalfTy(II->getContext()), RetWidth);
3243 ConstantInt::get(Type::getInt32Ty(II->getContext()),
3517 Type *Ty = II->getType();
3752 Type *Ty = SrcLHS->getType();
3985 auto *OpIntTy = GCR.getOperand(2)->getType();
4110 Type* SrcTy =
4112 Type *DstTy = Call.isByValArgument(ix)
4433 Type *OldRetTy = Caller->getType();
4434 Type *NewRetTy = FT->getReturnType();
4492 Type *ParamTy = FT->getParamType(i);
4493 Type *ActTy = (*AI)->getType();
4512 Type *CurElTy = Call.getParamByValType(i);
4569 Type *ParamTy = FT->getParamType(i);
4598 Type *PTy = getPromotedType((*AI)->getType());
4696 Type *CalleeTy = Callee->getType();
4711 Type *NestTy = nullptr;
4765 std::vector<Type*> NewTypes;
lib/Transforms/InstCombine/InstCombineCasts.cpp 91 Type *AllocElTy = AI.getAllocatedType();
92 Type *CastElTy = PTy->getElementType();
161 Value *InstCombiner::EvaluateInDifferentType(Value *V, Type *Ty,
234 Type *SrcTy = CI1->getSrcTy();
235 Type *MidTy = CI1->getDestTy();
236 Type *DstTy = CI2->getDestTy();
240 Type *SrcIntPtrTy =
242 Type *MidIntPtrTy =
244 Type *DstIntPtrTy =
268 auto *Ty = CI.getType();
305 static bool canAlwaysEvaluateInType(Value *V, Type *Ty) {
318 static bool canNotEvaluateInType(Value *V, Type *Ty) {
341 static bool canEvaluateTruncated(Value *V, Type *Ty, InstCombiner &IC,
349 Type *OrigTy = V->getType();
458 Type *DestType = Trunc.getType();
502 Type *DestTy = Trunc.getType();
580 Type *SrcTy = Trunc.getSrcTy();
581 Type *DestTy = Trunc.getType();
667 Type *DestTy = Trunc.getType();
668 Type *DestScalarTy = DestTy->getScalarType();
689 Type *DestTy = CI.getType(), *SrcTy = Src->getType();
982 static bool canEvaluateZExtd(Value *V, Type *Ty, unsigned &BitsToClear,
1099 Type *SrcTy = Src->getType(), *DestTy = CI.getType();
1312 static bool canEvaluateSExtd(Value *V, Type *Ty) {
1370 Type *SrcTy = Src->getType(), *DestTy = CI.getType();
1456 static Type *shrinkFPConstant(ConstantFP *CFP) {
1457 if (CFP->getType() == Type::getPPC_FP128Ty(CFP->getContext()))
1461 return Type::getHalfTy(CFP->getContext());
1464 return Type::getFloatTy(CFP->getContext());
1468 return Type::getDoubleTy(CFP->getContext());
1476 static Type *shrinkFPConstantVector(Value *V) {
1481 Type *MinType = nullptr;
1489 Type *T = shrinkFPConstant(CFP);
1504 static Type *getMinimumFPType(Value *V) {
1512 if (Type *T = shrinkFPConstant(CFP))
1516 if (Type *T = shrinkFPConstantVector(V))
1533 Type *Ty = FPT.getType();
1536 Type *LHSMinType = getMinimumFPType(BO->getOperand(0));
1537 Type *RHSMinType = getMinimumFPType(BO->getOperand(1));
1693 Type *FITy = FI.getType();
1694 Type *OpITy = OpI->getType();
1695 Type *SrcTy = SrcI->getType();
1764 Type *Ty = DL.getIntPtrType(CI.getContext(), AS);
1808 Type *Ty = CI.getType();
1814 Type *PtrTy = DL.getIntPtrType(CI.getContext(), AS);
1879 static bool isMultipleOfTypeSize(unsigned Value, Type *Ty) {
1883 static unsigned getTypeSizeIndex(unsigned Value, Type *Ty) {
1899 Type *VecEltTy, bool isBigEndian) {
1943 Type *ElementIntTy = IntegerType::get(C->getContext(), ElementSize);
2044 Type *DestType = BitCast.getType();
2058 Type *DestTy = BitCast.getType();
2110 Type *CondTy = Cond->getType();
2111 Type *DestTy = BitCast.getType();
2168 Type *SrcTy = Src->getType(); // Type B
2169 Type *DestTy = CI.getType(); // Type A
2213 Type *TyA = BCI->getOperand(0)->getType();
2214 Type *TyB = BCI->getType();
2275 Type *TyB = BCI->getOperand(0)->getType();
2276 Type *TyA = BCI->getType();
2293 Type *SrcTy = Src->getType();
2294 Type *DestTy = CI.getType();
2303 Type *DstElTy = DstPTy->getElementType();
2304 Type *SrcElTy = SrcPTy->getElementType();
2322 Type *PointeeType =
2365 Constant::getNullValue(Type::getInt32Ty(CI.getContext())));
2397 Constant::getNullValue(Type::getInt32Ty(CI.getContext())));
2479 Type *DestElemTy = DestTy->getElementType();
2481 Type *MidTy = PointerType::get(DestElemTy, SrcTy->getAddressSpace());
lib/Transforms/InstCombine/InstCombineCompares.cpp 173 Type *EltTy = Init->getType()->getArrayElementType();
314 Type *IntPtrTy = DL.getIntPtrType(GEP->getType());
394 Type *Ty = nullptr;
483 Type *IntPtrTy = DL.getIntPtrType(GEP->getOperand(0)->getType());
653 Type *IndexType = IntegerType::get(
764 Type *IndexType = IntegerType::get(V->getContext(),
921 Type *BaseType = GEPLHS->getOperand(0)->getType();
941 Type *LHSIndexTy = LOffset->getType();
942 Type *RHSIndexTy = ROffset->getType();
980 Type *LHSType = GEPLHS->getOperand(i)->getType();
981 Type *RHSType = GEPRHS->getOperand(i)->getType();
1095 Type *CmpTy = CmpInst::makeCmpResultType(Other->getType());
1314 Type *NewType = IntegerType::get(OrigAdd->getContext(), NewWidth);
1368 Type *XTy;
1771 Type *WideType = W->getType();
1865 Type *NTy = IntegerType::get(Cmp.getContext(), ExactLogBase2 + 1);
1967 Type *ShiftType = Shl->getType();
2042 Type *ShType = Shl->getType();
2151 Type *TruncTy = IntegerType::get(Cmp.getContext(), TypeBits - Amt);
2191 Type *ShrTy = Shr->getType();
2277 Type *Ty = SRem->getType();
2566 Type *Ty = Add->getType();
3027 Type *Ty = II->getType();
3115 Type *Ty = II->getType();
3422 auto *XType = X->getType();
3479 Type *WidestTy = WidestShift->getType();
4288 Type *Ty = A->getType();
4317 Type *XTy = X->getType(), *YTy = Y->getType();
4352 Type *SrcTy = CastOp0->getSrcTy();
4353 Type *DestTy = CastOp0->getDestTy();
4399 Type *SrcTy = CastOp0->getSrcTy();
4400 Type *DestTy = CastOp0->getDestTy();
4548 Type *TyA = A->getType(), *TyB = B->getType();
4552 Type *MulType;
4927 Type *Ty = Op0->getType();
4999 Type *XTy = X->getType();
5157 Type *Type = C->getType();
5971 Type *OpType = Op0->getType();
lib/Transforms/InstCombine/InstCombineInternal.h 249 Type *EltTy = In->getType()->getVectorElementType();
372 Value *OptimizePointerDifference(Value *LHS, Value *RHS, Type *Ty);
470 bool shouldChangeType(Type *From, Type *To) const;
470 bool shouldChangeType(Type *From, Type *To) const;
472 Type *FindElementAtOffset(PointerType *PtrTy, int64_t Offset,
695 UndefValue::get(Type::getInt1PtrTy(Ctx)),
994 Value *EvaluateInDifferentType(Value *V, Type *Ty, bool isSigned);
lib/Transforms/InstCombine/InstCombineLoadStoreAlloca.cpp 198 Type *NewTy = ArrayType::get(AI.getAllocatedType(), C->getZExtValue());
212 Type *IdxTy = IC.getDataLayout().getIntPtrType(AI.getType());
230 Type *IntPtrTy = IC.getDataLayout().getIntPtrType(AI.getType());
413 auto *SrcTy = TheSrc->getType();
439 static bool isSupportedAtomicType(Type *Ty) {
452 static LoadInst *combineLoadToNewType(InstCombiner &IC, LoadInst &LI, Type *NewTy,
579 Type *Ty = LI.getType();
601 Type::getIntNTy(LI.getContext(), DL.getTypeStoreSizeInBits(Ty)));
640 Type *T = LI.getType();
672 auto *IdxType = Type::getInt32Ty(T->getContext());
698 auto *ET = AT->getElementType();
723 auto *IdxType = Type::getInt64Ty(T->getContext());
867 Type *AllocTy =
1096 auto *VT = V->getType();
1109 for (const auto *EltT : ST->elements()) {
1176 Type *T = V->getType();
1207 auto *IdxType = Type::getInt32Ty(ST->getContext());
1255 auto *IdxType = Type::getInt64Ty(T->getContext());
lib/Transforms/InstCombine/InstCombineMulDivRem.cpp 102 static Constant *getLogBase2(Type *Ty, Constant *C) {
611 Type *CondTy = SelectCond->getType();
683 Type *Ty = I.getType();
924 Type *Ty = I.getType();
985 Type *Ty = I.getType();
1361 Type *Ty = I.getType();
lib/Transforms/InstCombine/InstCombinePHI.cpp 290 Type *LHSType = LHSVal->getType();
291 Type *RHSType = RHSVal->getType();
665 Type *NarrowType = nullptr;
743 Type *CastSrcTy = nullptr;
912 LoweredPHIRecord(PHINode *pn, unsigned Sh, Type *Ty)
1041 Type *Ty = PHIUsers[UserI].Inst->getType();
lib/Transforms/InstCombine/InstCombineSelect.cpp 84 Type *Ty = BO->getType();
131 Type *SelType = Sel.getType();
296 Type *CondTy = Cond->getType();
298 Type *FIOpndTy = FI->getOperand(0)->getType();
406 Type *ElementType = TGEP->getResultElementType();
501 static Instruction *foldSelectICmpAndAnd(Type *SelType, const ICmpInst *Cmp,
908 Type *SelTy = Sel.getType();
1753 Type *SmallType = X->getType();
1762 Type *SelType = Sel.getType();
1807 Type *Int32Ty = Type::getInt32Ty(CondVal->getContext());
1807 Type *Int32Ty = Type::getInt32Ty(CondVal->getContext());
1840 Type *Ty = Sel.getType();
2016 Type *Ty = MinMax1.getType();
2051 Type *NewTy = Ty->getWithNewBitWidth(NewBitWidth);
2194 Type *SelType = SI.getType();
lib/Transforms/InstCombine/InstCombineShifts.cpp 185 Type *NarrowestTy = OuterShift->getType();
186 Type *WidestTy = Masked->getType();
189 Type *ExtendedTy = WidestTy->getExtendedType();
472 Type *ShType = InnerShift->getType();
862 Type *Ty = I.getType();
979 Type *Ty = I.getType();
1177 Type *Ty = I.getType();
1225 Type *SrcTy = X->getType();
lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp 122 Type *VTy = V->getType();
768 Type *ITy = I->getType();
912 Type *Ty = VarX->getType();
1032 SmallVector<Type *, 6> OverloadTys;
1036 Type *EltTy = II->getType()->getVectorElementType();
1037 Type *NewTy = (NewNumElts == 1) ? EltTy : VectorType::get(EltTy, NewNumElts);
1116 Type *EltTy = cast<VectorType>(V->getType())->getElementType();
1334 Op, Value, ConstantInt::get(Type::getInt32Ty(I->getContext()), Idx),
1345 Elts.push_back(UndefValue::get(Type::getInt32Ty(I->getContext())));
1347 Elts.push_back(ConstantInt::get(Type::getInt32Ty(I->getContext()),
1623 auto *Ty0 = II->getArgOperand(0)->getType();
lib/Transforms/InstCombine/InstCombineVectorOps.cpp 175 Type *SrcTy = X->getType();
176 Type *DestTy = Ext.getType();
235 Type *SrcIntTy = IntegerType::getIntNTy(Scalar->getContext(), SrcWidth);
247 Type *DestIntTy = IntegerType::getIntNTy(Scalar->getContext(), DestWidth);
424 Type *Int32Ty = Type::getInt32Ty(EI.getContext());
424 Type *Int32Ty = Type::getInt32Ty(EI.getContext());
452 Mask.assign(NumElts, UndefValue::get(Type::getInt32Ty(V->getContext())));
458 Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()), i));
464 Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()),
484 Mask[InsertedIdx] = UndefValue::get(Type::getInt32Ty(V->getContext()));
501 ConstantInt::get(Type::getInt32Ty(V->getContext()),
506 ConstantInt::get(Type::getInt32Ty(V->getContext()),
540 IntegerType *IntType = Type::getInt32Ty(InsElt->getContext());
614 Mask.assign(NumElts, UndefValue::get(Type::getInt32Ty(V->getContext())));
620 Mask.assign(NumElts, ConstantInt::get(Type::getInt32Ty(V->getContext()),0));
651 Mask[i] = ConstantInt::get(Type::getInt32Ty(V->getContext()), i);
657 ConstantInt::get(Type::getInt32Ty(V->getContext()),
669 Type::getInt32Ty(V->getContext()),
686 Mask.push_back(ConstantInt::get(Type::getInt32Ty(V->getContext()), i));
799 Type *Int32Ty = Type::getInt32Ty(InsElt.getContext());
799 Type *Int32Ty = Type::getInt32Ty(InsElt.getContext());
839 Type *I32Ty = IntegerType::getInt32Ty(Shuf->getContext());
875 Type *I32Ty = IntegerType::getInt32Ty(Shuf->getContext());
968 Type *Int32Ty = Type::getInt32Ty(Shuf->getContext());
968 Type *Int32Ty = Type::getInt32Ty(Shuf->getContext());
1004 Mask[I] = ConstantInt::get(Type::getInt32Ty(InsElt.getContext()),
1014 Mask[I] = ConstantInt::get(Type::getInt32Ty(InsElt.getContext()), I);
1181 Type *ITy = I->getType();
1270 Type *DestTy =
1293 Type *EltTy = V->getType()->getScalarType();
1294 Type *I32Ty = IntegerType::getInt32Ty(V->getContext());
1445 Type *Ty = BO->getType();
1856 Type *I32Ty = IntegerType::getInt32Ty(Shuf.getContext());
1899 Type *Int32Ty = Type::getInt32Ty(SVI.getContext());
1899 Type *Int32Ty = Type::getInt32Ty(SVI.getContext());
2005 DenseMap<Type *, Value *> NewBCs;
2013 Type *TgtTy = BC->getDestTy();
lib/Transforms/InstCombine/InstructionCombining.cpp 187 bool InstCombiner::shouldChangeType(Type *From, Type *To) const {
187 bool InstCombiner::shouldChangeType(Type *From, Type *To) const {
285 Type *DestTy = C1->getType();
1053 Type *RetTy = CI->getType();
1092 Type *InstCombiner::FindElementAtOffset(PointerType *PtrTy, int64_t Offset,
1094 Type *Ty = PtrTy->getElementType();
1101 Type *IndexTy = DL.getIndexType(PtrTy);
1130 NewIndices.push_back(ConstantInt::get(Type::getInt32Ty(Ty->getContext()),
1620 Type *GEPType = GEP.getType();
1621 Type *GEPEltType = GEP.getSourceElementType();
1650 Type *NewScalarIndexTy =
1660 Type *IndexTy = (*I)->getType();
1661 Type *NewIndexType =
1668 Type *EltTy = GTI.getIndexedType();
1713 Type *CurTy = nullptr;
1828 auto *SO0Ty = SO0->getType();
1966 Type *StrippedPtrEltTy = StrippedPtrTy->getElementType();
2038 Type *IdxType = DL.getIndexType(GEPType);
2117 Type *IndTy = DL.getIndexType(GEPType);
2151 Type *SrcEltType = SrcType->getElementType();
2402 ConstantInt::get(Type::getInt1Ty(C->getContext()),
2544 Type *VTy = ResultOp->getType();
3242 Type *Ty = I->getType();
lib/Transforms/Instrumentation/AddressSanitizer.cpp 593 IntptrTy = Type::getIntNTy(*C, LongSize);
606 Type *Ty = AI.getAllocatedType();
678 Type *IntptrTy;
759 IntptrTy = Type::getIntNTy(*C, LongSize);
808 Type *IntptrTy;
874 Type *IntptrTy;
875 Type *IntptrPtrTy;
1254 ConstantInt::get(Type::getInt32Ty(M.getContext()), MD.LineNo),
1255 ConstantInt::get(Type::getInt32Ty(M.getContext()), MD.ColumnNo),
1415 Type *PtrTy = cast<PointerType>(PtrOperand->getType()->getScalarType());
1509 const DataLayout &DL, Type *IntptrTy,
1515 auto *VTy = cast<PointerType>(Addr->getType())->getElementType();
1695 Type *ShadowTy =
1697 Type *ShadowPtrTy = PointerType::get(ShadowTy, 0);
1803 Type *Ty = G->getValueType();
2032 Function::Create(FunctionType::get(Type::getVoidTy(*C), false),
2268 Type *Ty = G->getValueType();
2279 Type *RightRedZoneTy = ArrayType::get(IRB.getInt8Ty(), RightRedzoneSize);
2479 SmallVector<Type *, 3> Args2 = {IntptrTy, IntptrTy};
2480 SmallVector<Type *, 2> Args1{1, IntptrTy};
2482 Type *ExpType = Type::getInt32Ty(*C);
2482 Type *ExpType = Type::getInt32Ty(*C);
2900 Type *Ty = Arg.getType()->getPointerElementType();
lib/Transforms/Instrumentation/BoundsChecking.cpp 75 Type *IntTy = DL.getIntPtrType(Ptr->getType());
lib/Transforms/Instrumentation/CGProfile.cpp 93 Type::getInt64Ty(Context), E.second))};
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp 165 Type *GType = G.getValueType();
486 SmallVector<Type *, 4> ArgTypes(T->param_begin(), T->param_end());
490 Type *RetType = T->getReturnType();
498 SmallVector<Type *, 4> ArgTypes;
502 Type *RetType = T->getReturnType();
509 SmallVector<Type *, 4> ArgTypes;
517 Type* param_type = T->getParamType(i);
523 ArgTypes.push_back(Type::getInt8PtrTy(*Ctx));
533 Type *RetType = T->getReturnType();
567 Type *DFSanUnionArgs[2] = { ShadowTy, ShadowTy };
570 Type *DFSanUnionLoadArgs[2] = { ShadowPtrTy, IntptrTy };
574 Type::getVoidTy(*Ctx), Type::getInt8PtrTy(*Ctx), /*isVarArg=*/false);
574 Type::getVoidTy(*Ctx), Type::getInt8PtrTy(*Ctx), /*isVarArg=*/false);
575 Type *DFSanSetLabelArgs[3] = { ShadowTy, Type::getInt8PtrTy(*Ctx), IntptrTy };
575 Type *DFSanSetLabelArgs[3] = { ShadowTy, Type::getInt8PtrTy(*Ctx), IntptrTy };
576 DFSanSetLabelFnTy = FunctionType::get(Type::getVoidTy(*Ctx),
579 Type::getVoidTy(*Ctx), None, /*isVarArg=*/false);
581 Type::getVoidTy(*Ctx), Type::getInt8PtrTy(*Ctx), /*isVarArg=*/false);
581 Type::getVoidTy(*Ctx), Type::getInt8PtrTy(*Ctx), /*isVarArg=*/false);
584 Type *ArgTLSTy = ArrayType::get(ShadowTy, 64);
717 Type *ArgTLSTy = ArrayType::get(ShadowTy, 64);
1242 IRB.CreateBitCast(ShadowAddr, Type::getInt64PtrTy(*DFS.Ctx));
1275 WideAddr = NextIRB.CreateGEP(Type::getInt64Ty(*DFS.Ctx), WideAddr,
1357 ShadowVec, Shadow, ConstantInt::get(Type::getInt32Ty(*DFS.Ctx), i));
1485 {ValShadow, IRB.CreateBitCast(I.getDest(), Type::getInt8PtrTy(
1497 Type *Int8Ptr = Type::getInt8PtrTy(*DFSF.DFS.Ctx);
1497 Type *Int8Ptr = Type::getInt8PtrTy(*DFSF.DFS.Ctx);
1523 Type *RT = DFSF.F->getFunctionType()->getReturnType();
1593 Type *T = (*i)->getType();
1605 IRB.CreateBitCast(*i, Type::getInt8PtrTy(*DFSF.DFS.Ctx)));
lib/Transforms/Instrumentation/GCOVProfiling.cpp 800 ArrayType::get(Type::getInt64Ty(*Ctx), Edges);
816 Type *Int64PtrTy = Type::getInt64PtrTy(*Ctx);
816 Type *Int64PtrTy = Type::getInt64PtrTy(*Ctx);
854 FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
866 FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
867 Type *Params[] = {
886 Type *Args[] = {
887 Type::getInt8PtrTy(*Ctx), // const char *orig_filename
888 Type::getInt8PtrTy(*Ctx), // const char version[4]
889 Type::getInt32Ty(*Ctx), // uint32_t checksum
891 FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
900 Type *Args[] = {
901 Type::getInt32Ty(*Ctx), // uint32_t ident
902 Type::getInt8PtrTy(*Ctx), // const char *function_name
903 Type::getInt32Ty(*Ctx), // uint32_t func_checksum
904 Type::getInt8Ty(*Ctx), // uint8_t use_extra_checksum
905 Type::getInt32Ty(*Ctx), // uint32_t cfg_checksum
907 FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
919 Type *Args[] = {
920 Type::getInt32Ty(*Ctx), // uint32_t num_counters
921 Type::getInt64PtrTy(*Ctx), // uint64_t *counters
923 FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
931 FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
936 FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
942 FunctionType *WriteoutFTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
1191 FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
1219 Type *RetTy = FlushF->getReturnType();
1220 if (RetTy == Type::getVoidTy(*Ctx))
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp 220 Value *tagPointer(IRBuilder<> &IRB, Type *Ty, Value *PtrLong, Value *Tag);
234 Value *getHwasanThreadSlotPtr(IRBuilder<> &IRB, Type *Ty);
268 Type *VoidTy = Type::getVoidTy(M.getContext());
268 Type *VoidTy = Type::getVoidTy(M.getContext());
269 Type *IntptrTy;
270 Type *Int8PtrTy;
271 Type *Int8Ty;
272 Type *Int32Ty;
273 Type *Int64Ty = Type::getInt64Ty(M.getContext());
273 Type *Int64Ty = Type::getInt64Ty(M.getContext());
549 Type *PtrTy = cast<PointerType>(PtrOperand->getType()->getScalarType());
769 Type *Ty = AI.getAllocatedType();
871 Value *HWAddressSanitizer::tagPointer(IRBuilder<> &IRB, Type *Ty,
903 Value *HWAddressSanitizer::getHwasanThreadSlotPtr(IRBuilder<> &IRB, Type *Ty) {
1189 Type *AllocatedType = AI->getAllocatedType();
1195 Type *TypeWithPadding = StructType::get(
1350 Type *Int8Arr0Ty = ArrayType::get(Int8Ty, 0);
lib/Transforms/Instrumentation/InstrOrderFile.cpp 76 ArrayType::get(Type::getInt64Ty(Ctx), INSTR_ORDER_FILE_BUFFER_SIZE);
77 Type *IdxTy = Type::getInt32Ty(Ctx);
77 Type *IdxTy = Type::getInt32Ty(Ctx);
78 MapTy = ArrayType::get(Type::getInt8Ty(Ctx), NumFunctions);
120 IntegerType *Int32Ty = Type::getInt32Ty(Ctx);
121 IntegerType *Int8Ty = Type::getInt8Ty(Ctx);
154 updateB.CreateStore(ConstantInt::get(Type::getInt64Ty(Ctx), MD5Hash(F.getName())),
lib/Transforms/Instrumentation/InstrProfiling.cpp 203 Type *Ty = LiveInValue->getType();
554 auto *ReturnTy = Type::getVoidTy(M.getContext());
554 auto *ReturnTy = Type::getVoidTy(M.getContext());
561 Type *ParamTypes[] = {
570 Type *RangeParamTypes[] = {
778 ArrayType *CounterTy = ArrayType::get(Type::getInt64Ty(Ctx), NumCounters);
792 auto *Int8PtrTy = Type::getInt8PtrTy(Ctx);
801 ArrayType *ValuesTy = ArrayType::get(Type::getInt64Ty(Ctx), NS);
813 ConstantExpr::getBitCast(ValuesVar, Type::getInt8PtrTy(Ctx));
818 auto *Int16Ty = Type::getInt16Ty(Ctx);
820 Type *DataTypes[] = {
895 Type *VNodeTypes[] = {
946 auto *VoidTy = Type::getVoidTy(M->getContext());
946 auto *VoidTy = Type::getVoidTy(M->getContext());
947 auto *VoidPtrTy = Type::getInt8PtrTy(M->getContext());
948 auto *Int64Ty = Type::getInt64Ty(M->getContext());
967 Type *ParamTypes[] = {VoidPtrTy, Int64Ty};
991 auto *Int32Ty = Type::getInt32Ty(M->getContext());
1033 auto *VoidTy = Type::getVoidTy(M->getContext());
1033 auto *VoidTy = Type::getVoidTy(M->getContext());
lib/Transforms/Instrumentation/MemorySanitizer.cpp 498 Type *IntptrTy;
499 Type *OriginTy;
719 Type *RetTy = StructType::get(PointerType::get(IRB.getInt8Ty(), 0),
748 static Constant *getOrInsertGlobal(Module &M, StringRef Name, Type *Ty) {
1166 Type *ShadowTy = Shadow->getType();
1332 Type *getShadowTy(Value *V) {
1337 Type *getShadowTy(Type *OrigTy) {
1337 Type *getShadowTy(Type *OrigTy) {
1356 SmallVector<Type*, 4> Elements;
1368 Type *getShadowTyNoVec(Type *ty) {
1368 Type *getShadowTyNoVec(Type *ty) {
1376 Type *Ty = V->getType();
1377 Type *NoVecTy = getShadowTyNoVec(Ty);
1408 Type *ShadowTy,
1439 getShadowOriginPtrKernel(Value *Addr, IRBuilder<> &IRB, Type *ShadowTy,
1464 Type *ShadowTy,
1526 Constant *getCleanShadow(Type *OrigTy) {
1527 Type *ShadowTy = getShadowTy(OrigTy);
1542 Constant *getPoisonedShadow(Type *ShadowTy) {
1562 Type *ShadowTy = getShadowTy(V);
1624 Type *EltType = A->getType()->getPointerElementType();
1707 Type *ShadowTy = Shadow->getType();
1783 Type *ShadowTy = getShadowTy(&I);
2074 size_t VectorOrPrimitiveTypeSizeInBits(Type *Ty) {
2084 Value *CreateShadowCast(IRBuilder<> &IRB, Value *V, Type *dstTy,
2086 Type *srcTy = V->getType();
2097 Value *V1 = IRB.CreateBitCast(V, Type::getIntNTy(*MS.C, srcSizeInBits));
2099 IRB.CreateIntCast(V1, Type::getIntNTy(*MS.C, dstSizeInBits), Signed);
2106 Type *ShadowTy = getShadowTy(V);
2138 Type *Ty = ConstArg->getType();
2141 Type *EltTy = Ty->getSequentialElementType();
2480 Type *ShadowTy = getShadowTy(&I);
2513 Type *RetTy = I.getType();
2522 Type *Ty = I.getArgOperand(i)->getType();
2595 Type *OpType = Op->getType();
2666 Type *EltTy = ResultShadow->getType()->getVectorElementType();
2682 Value *Lower64ShadowExtend(IRBuilder<> &IRB, Value *S, Type *T) {
2692 Value *LowerElementShadowExtend(IRBuilder<> &IRB, Value *S, Type *T) {
2699 Type *T = S->getType();
2731 Type *getMMXVectorTy(unsigned EltSizeInBits) {
2788 Type *T = isX86_MMX ? getMMXVectorTy(EltSizeInBits) : S1->getType();
2798 Type *X86_MMXTy = Type::getX86_MMXTy(*MS.C);
2798 Type *X86_MMXTy = Type::getX86_MMXTy(*MS.C);
2817 Type *ResTy = isX86_MMX ? IntegerType::get(*MS.C, 64) : I.getType();
2836 Type *ResTy = isX86_MMX ? getMMXVectorTy(EltSizeInBits * 2) : I.getType();
2852 Type *ResTy = getShadowTy(&I);
2874 Type *Ty = IRB.getInt32Ty();
2891 Type *Ty = IRB.getInt32Ty();
2943 Type *ShadowTy = getShadowTy(&I);
2993 Type *ShadowTy = getShadowTy(&I);
3542 Type *FlatTy = getShadowTyNoVec(B->getType());
3633 Type *OpType = Operand->getType();
3640 Type *ElType = OpType->getPointerElementType();
3653 Type *RetTy = cast<Value>(CB)->getType();
3770 Type *T = arg->getType();
3806 Type *RealTy = A->getType()->getPointerElementType();
3884 Value *getShadowPtrForVAArgument(Type *Ty, IRBuilder<> &IRB,
3896 Value *getOriginPtrForVAArgument(Type *Ty, IRBuilder<> &IRB, int ArgOffset) {
3947 VAArgTLSCopy = IRB.CreateAlloca(Type::getInt8Ty(*MS.C), CopySize);
3950 VAArgTLSOriginCopy = IRB.CreateAlloca(Type::getInt8Ty(*MS.C), CopySize);
3962 Type *RegSaveAreaPtrTy = Type::getInt64PtrTy(*MS.C);
3962 Type *RegSaveAreaPtrTy = Type::getInt64PtrTy(*MS.C);
3979 Type *OverflowArgAreaPtrTy = Type::getInt64PtrTy(*MS.C);
3979 Type *OverflowArgAreaPtrTy = Type::getInt64PtrTy(*MS.C);
4048 Value *getShadowPtrForVAArgument(Type *Ty, IRBuilder<> &IRB,
4094 VAArgTLSCopy = IRB.CreateAlloca(Type::getInt8Ty(*MS.C), CopySize);
4104 Type *RegSaveAreaPtrTy = Type::getInt64PtrTy(*MS.C);
4104 Type *RegSaveAreaPtrTy = Type::getInt64PtrTy(*MS.C);
4148 Type *T = arg->getType();
4217 Value *getShadowPtrForVAArgument(Type *Ty, IRBuilder<> &IRB,
4258 Type::getInt64PtrTy(*MS.C));
4259 return IRB.CreateLoad(Type::getInt64Ty(*MS.C), SaveAreaPtrPtr);
4268 Type::getInt32PtrTy(*MS.C));
4285 VAArgTLSCopy = IRB.CreateAlloca(Type::getInt8Ty(*MS.C), CopySize);
4420 Type *RealTy = A->getType()->getPointerElementType();
4447 Type *ElementTy = A->getType()->getArrayElementType();
4484 Value *getShadowPtrForVAArgument(Type *Ty, IRBuilder<> &IRB,
4531 VAArgTLSCopy = IRB.CreateAlloca(Type::getInt8Ty(*MS.C), CopySize);
4541 Type *RegSaveAreaPtrTy = Type::getInt64PtrTy(*MS.C);
4541 Type *RegSaveAreaPtrTy = Type::getInt64PtrTy(*MS.C);
lib/Transforms/Instrumentation/PGOInstrumentation.cpp 819 Type *I8PtrTy = Type::getInt8PtrTy(M->getContext());
819 Type *I8PtrTy = Type::getInt8PtrTy(M->getContext());
1350 Type *Int64Ty = Builder.getInt64Ty();
1351 Type *I8PtrTy = Builder.getInt8PtrTy();
lib/Transforms/Instrumentation/PoisonChecking.cpp 245 Type::getVoidTy(M->getContext()),
246 Type::getInt1Ty(M->getContext()));
257 auto * const Int1Ty = Type::getInt1Ty(F.getContext());
lib/Transforms/Instrumentation/SanitizerCoverage.cpp 207 Function &F, Type *Ty,
214 const char *InitFunctionName, Type *Ty,
217 Type *Ty);
236 Type *IntptrTy, *IntptrPtrTy, *Int64Ty, *Int64PtrTy, *Int32Ty, *Int32PtrTy,
304 Type *Ty) {
327 Module &M, const char *CtorName, const char *InitFunctionName, Type *Ty,
370 IntptrTy = Type::getIntNTy(*C, DL->getPointerSizeInBits());
372 Type *VoidTy = Type::getVoidTy(*C);
372 Type *VoidTy = Type::getVoidTy(*C);
644 size_t NumElements, Function &F, Type *Ty, const char *Section) {
795 auto Ty = Type::getIntNTy(*C, TypeSize);
840 auto Ty = Type::getIntNTy(*C, TypeSize);
lib/Transforms/Instrumentation/ThreadSanitizer.cpp 109 Type *IntptrTy;
238 Type *Ty = Type::getIntNTy(M.getContext(), BitSize);
238 Type *Ty = Type::getIntNTy(M.getContext(), BitSize);
239 Type *PtrTy = Ty->getPointerTo();
330 Type *PtrTy = cast<PointerType>(Addr->getType()->getScalarType());
562 Type *OrigTy = cast<PointerType>(Addr->getType())->getElementType();
637 Type *Ty = Type::getIntNTy(IRB.getContext(), BitSize);
637 Type *Ty = Type::getIntNTy(IRB.getContext(), BitSize);
638 Type *PtrTy = Ty->getPointerTo();
641 Type *OrigTy = cast<PointerType>(Addr->getType())->getElementType();
652 Type *Ty = Type::getIntNTy(IRB.getContext(), BitSize);
652 Type *Ty = Type::getIntNTy(IRB.getContext(), BitSize);
653 Type *PtrTy = Ty->getPointerTo();
669 Type *Ty = Type::getIntNTy(IRB.getContext(), BitSize);
669 Type *Ty = Type::getIntNTy(IRB.getContext(), BitSize);
670 Type *PtrTy = Ty->getPointerTo();
683 Type *Ty = Type::getIntNTy(IRB.getContext(), BitSize);
683 Type *Ty = Type::getIntNTy(IRB.getContext(), BitSize);
684 Type *PtrTy = Ty->getPointerTo();
697 Type *OrigOldValTy = CASI->getNewValOperand()->getType();
722 Type *OrigPtrTy = Addr->getType();
723 Type *OrigTy = cast<PointerType>(OrigPtrTy)->getElementType();
lib/Transforms/ObjCARC/ObjCARCContract.cpp 415 Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C));
415 Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C));
416 Type *I8XX = PointerType::getUnqual(I8X);
495 InlineAsm::get(FunctionType::get(Type::getVoidTy(Inst->getContext()),
649 Type *UseTy = U.get()->getType();
lib/Transforms/ObjCARC/ObjCARCOpts.cpp 803 Type *Ty = CI->getArgOperand(0)->getType();
824 Type *Ty = CI->getArgOperand(0)->getType();
1006 Type *ParamTy = CInst->getArgOperand(0)->getType();
1571 Type *ArgTy = Arg->getType();
1572 Type *ParamTy = PointerType::getUnqual(Type::getInt8Ty(ArgTy->getContext()));
1572 Type *ParamTy = PointerType::getUnqual(Type::getInt8Ty(ArgTy->getContext()));
lib/Transforms/Scalar/AlignmentFromAssumptions.cpp 253 Type *Int64Ty = Type::getInt64Ty(I->getParent()->getParent()->getContext());
253 Type *Int64Ty = Type::getInt64Ty(I->getParent()->getParent()->getContext());
lib/Transforms/Scalar/ConstantHoisting.cpp 426 ConstantInt::get(Type::getInt32Ty(*Ctx), Offset.getLimitedValue()),
569 Type *Ty = ConstCand->ConstInt->getType();
623 Type *Ty = ConstInt->getType();
629 Type *ConstTy =
662 Type *MemUseValTy = nullptr;
730 Type *Ty,
736 Offset = ConstantInt::get(Type::getInt32Ty(*Ctx), 0);
743 PointerType *Int8PtrTy = Type::getInt8PtrTy(*Ctx,
842 using RebasedUse = std::tuple<Constant *, Type *, ConstantUser>;
870 Type *Ty = ConstInfo.BaseExpr->getType();
886 Type *Ty = std::get<1>(R);
lib/Transforms/Scalar/CorrelatedValuePropagation.cpp 323 Constant *TorF = ConstantInt::get(Type::getInt1Ty(Cmp->getContext()), Result);
643 auto *TruncTy = Type::getIntNTy(Instr->getContext(), NewWidth);
lib/Transforms/Scalar/DivRemPairs.cpp 94 Type *getType() const { return DivInst->getType(); }
lib/Transforms/Scalar/EarlyCSE.cpp 701 Value *getOrCreateResult(Value *Inst, Type *ExpectedType) const {
lib/Transforms/Scalar/Float2Int.cpp 359 Type *ConvertedToTy = nullptr;
424 Type *Ty = (MinBW > 32) ? Type::getInt64Ty(*Ctx) : Type::getInt32Ty(*Ctx);
424 Type *Ty = (MinBW > 32) ? Type::getInt64Ty(*Ctx) : Type::getInt32Ty(*Ctx);
424 Type *Ty = (MinBW > 32) ? Type::getInt64Ty(*Ctx) : Type::getInt32Ty(*Ctx);
435 Value *Float2IntPass::convert(Instruction *I, Type *ToTy) {
lib/Transforms/Scalar/GVN.cpp 115 Type *type;
774 Type *LoadTy = LI->getType();
1405 Type *Int8Ty = Type::getInt8Ty(V->getContext());
1405 Type *Int8Ty = Type::getInt8Ty(V->getContext());
lib/Transforms/Scalar/IndVarSimplify.cpp 455 IntegerType *Int32Ty = Type::getInt32Ty(PN->getContext());
883 Type *WidestNativeType = nullptr;
900 Type *Ty = Cast->getType();
968 Type *WideType;
1040 Value *createExtendInst(Value *NarrowOper, Type *WideType, bool IsSigned,
1070 Value *WidenIV::createExtendInst(Value *NarrowOper, Type *WideType,
2350 Type *OfsTy = SE->getEffectiveSCEVType(IVInit->getType());
2409 Type *LimitTy = ExitCount->getType()->isPointerTy() ?
2772 Type *WiderType =
2953 Type *WiderTy = SE->getWiderType(ECV->getType(), RHS->getType());
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp 194 Type *getType() const { return Begin->getType(); }
419 ConstantAsMetadata::get(ConstantInt::get(Type::getInt1Ty(Context), 0));
1041 static const SCEV *NoopOrExtend(const SCEV *S, Type *Ty, ScalarEvolution &SE,
1265 auto *RangeTy = Range.getBegin()->getType();
lib/Transforms/Scalar/InferAddressSpaces.cpp 270 Type *DestTy = II->getType();
271 Type *SrcTy = NewV->getType();
419 Type *NewPtrTy =
445 Type *NewPtrType =
506 Type *TargetType =
lib/Transforms/Scalar/JumpThreading.cpp 770 Type *CmpType = Cmp->getType();
812 Res = ConstantInt::get(Type::getInt1Ty(LHS->getContext()), ResT);
lib/Transforms/Scalar/LICM.cpp 989 auto *PtrInt8Ty = PointerType::get(Type::getInt8Ty(LI->getContext()),
2064 auto *SomePtrElemType = SomePtr->getType()->getPointerElementType();
lib/Transforms/Scalar/LoopDataPrefetch.cpp 308 Type *I8Ptr = Type::getInt8PtrTy(BB->getContext(), PtrAddrSpace);
308 Type *I8Ptr = Type::getInt8PtrTy(BB->getContext(), PtrAddrSpace);
314 Type *I32 = Type::getInt32Ty(BB->getContext());
314 Type *I32 = Type::getInt32Ty(BB->getContext());
lib/Transforms/Scalar/LoopIdiomRecognize.cpp 894 Type *IntPtr, unsigned StoreSize,
907 static const SCEV *getNumBytes(const SCEV *BECount, Type *IntPtr,
962 Type *DestInt8PtrTy = Builder.getInt8PtrTy(DestAS);
963 Type *IntPtr = Builder.getIntPtrTy(*DL, DestAS);
1012 Type *Int8PtrTy = DestInt8PtrTy;
1084 Type *IntPtrTy = Builder.getIntPtrTy(*DL, StrAS);
1637 Type *Tys[] = {Val->getType()};
1651 Type *Tys[] = {Val->getType()};
1753 Type *Ty = Count->getType();
1860 Type *Ty = TripCnt->getType();
2086 Type *CmpFuncSizeTy = DL->getIntPtrType(SE->getContext());
2155 Type *BCmpValTy = BCmpInst->getOperand(0)->getType();
2182 Type *CmpFuncSizeTy = DL->getIntPtrType(Context);
2625 Type *CmpFuncSizeTy = DL->getIntPtrType(Builder.getContext());
lib/Transforms/Scalar/LoopInterchange.cpp 303 Type *PhiTy = PhiVar->getType();
lib/Transforms/Scalar/LoopLoadElimination.cpp 101 Type *LoadPtrType = LoadPtr->getType();
102 Type *LoadType = LoadPtrType->getPointerElementType();
lib/Transforms/Scalar/LoopPredication.cpp 393 Type *Ty = LHS->getType();
428 Type *RangeCheckType) {
463 Type *RangeCheckType) {
465 auto *LatchType = LatchCheck.IV->getType();
554 auto *Ty = RangeCheck.IV->getType();
603 auto *Ty = RangeCheck.IV->getType();
697 auto *Ty = RangeCheckIV->getType();
lib/Transforms/Scalar/LoopStrengthReduce.cpp 187 Type *MemTy = nullptr;
191 MemAccessTy(Type *Ty, unsigned AS) : MemTy(Ty), AddrSpace(AS) {}
201 return MemAccessTy(Type::getVoidTy(Ctx), AS);
204 Type *getType() { return MemTy; }
374 Type *getType() const;
554 Type *Formula::getType() const {
631 Type *WideTy =
639 Type *WideTy =
647 Type *WideTy =
1172 Type *WidestFixupType = nullptr;
1936 SmallSetVector<Type *, 4> Types;
2080 Type *DestTy = nullptr;
2121 Type *SrcTy = PH->getType();
2745 Type *LType = LVal->getType();
2746 Type *RType = RVal->getType();
3173 Type *IVTy = IVSrc->getType();
3174 Type *IntTy = SE.getEffectiveSCEVType(IVTy);
3206 Type *OperTy = Inc.IVOperand->getType();
3227 Type *PostIncTy = PostIncV->getType();
3692 Type *CombinedIntegerType = nullptr;
3869 Type *IntTy = Base.getType();
3959 Type *IntTy = Base.getType();
4028 Type *DstTy = Base.getType();
4032 for (Type *SrcTy : Types) {
4190 Type *IntTy = SE.getEffectiveSCEVType(OrigReg->getType());
5144 Type *OpTy = LF.OperandValToReplace->getType();
5146 Type *Ty = F.getType();
5154 Type *IntTy = SE.getEffectiveSCEVType(Ty);
5365 Type *OpTy = LF.OperandValToReplace->getType();
5432 Type *OpTy = LF.OperandValToReplace->getType();
5622 for (Type *Ty : Types) {
lib/Transforms/Scalar/LoopUnswitch.cpp 944 Val->getType() != Type::getInt1Ty(LIC->getContext()))
1467 Replacement = ConstantInt::get(Type::getInt1Ty(Val->getContext()),
lib/Transforms/Scalar/MemCpyOptimizer.cpp 392 Type *EltType =
553 auto *T = LI->getType();
682 auto *T = V->getType();
789 Type *StructTy = cast<PointerType>(A->getType())->getElementType();
1243 Type *ArgTys[3] = { M->getRawDest()->getType(),
1262 Type *ByValTy = cast<PointerType>(ByValArg->getType())->getElementType();
lib/Transforms/Scalar/MergeICmps.cpp 657 MemCmpCall, ConstantInt::get(Type::getInt32Ty(Context), 0));
lib/Transforms/Scalar/NaryReassociate.cpp 332 unsigned I, Type *IndexedType) {
368 Value *RHS, Type *IndexedType) {
402 Type *ElementType = GEP->getResultElementType();
422 Type *IntPtrTy = DL->getIntPtrType(GEP->getType());
lib/Transforms/Scalar/NewGVN.cpp 669 const Expression *createBinaryExpression(unsigned, Type *, Value *, Value *,
686 LoadExpression *createLoadExpression(Type *, Value *, LoadInst *,
745 const Expression *performSymbolicLoadCoercion(Type *, Value *, LoadInst *,
1037 const Expression *NewGVN::createBinaryExpression(unsigned Opcode, Type *T,
1325 LoadExpression *NewGVN::createLoadExpression(Type *LoadType, Value *PointerOp,
1415 NewGVN::performSymbolicLoadCoercion(Type *LoadType, Value *LoadPtr,
3700 Type *Int8Ty = Type::getInt8Ty(BB->getContext());
3700 Type *Int8Ty = Type::getInt8Ty(BB->getContext());
lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp 57 Type *Ty = Call->getType();
lib/Transforms/Scalar/Reassociate.cpp 273 Type *Ty = Neg->getType();
1321 Type *Ty = Ops[0].Op->getType();
1459 Type *Ty = TheOp->getType();
lib/Transforms/Scalar/Reg2Mem.cpp 86 Constant::getNullValue(Type::getInt32Ty(F.getContext())),
87 Type::getInt32Ty(F.getContext()), "reg2mem alloca point", &*I);
lib/Transforms/Scalar/RewriteStatepointsForGC.cpp 312 static bool isGCPointerType(Type *T) {
325 static bool isHandledGCPointerType(Type *T) {
340 static bool containsGCPtrType(Type *Ty) {
355 static bool isUnhandledGCPointerType(Type *Ty) {
1295 Type *NewTy = Type::getInt8PtrTy(M->getContext(), AS);
1295 Type *NewTy = Type::getInt8PtrTy(M->getContext(), AS);
1305 DenseMap<Type *, Function *> TypeToDeclMap;
1313 Type *Ty = LiveVariables[i]->getType();
1468 SmallVector<Type *, 8> DomainTy;
1471 auto *FTy = FunctionType::get(Type::getVoidTy(F->getContext()), DomainTy,
1899 "__tmp_use", FunctionType::get(Type::getVoidTy(M->getContext()), true));
1967 Type *SrcTy = CI->getOperand(0)->getType();
1972 Type *ValTy = GEP->getSourceElementType();
lib/Transforms/Scalar/SCCP.cpp 1511 Type *ITy = I.getType();
lib/Transforms/Scalar/SROA.cpp 769 void handleLoadOrStore(Type *Ty, Instruction &I, const APInt &Offset,
1127 static Type *findCommonType(AllocaSlices::const_iterator B,
1130 Type *Ty = nullptr;
1143 Type *UserTy = nullptr;
1266 Type *LoadTy = SomeLoad->getType();
1421 Value *BasePtr, Type *Ty, Type *TargetTy,
1421 Value *BasePtr, Type *Ty, Type *TargetTy,
1433 Type *ElementTy = Ty;
1465 Value *Ptr, Type *Ty, APInt &Offset,
1466 Type *TargetTy,
1497 Type *ElementTy = ArrTy->getElementType();
1519 Type *ElementTy = STy->getElementType(Index);
1539 Value *Ptr, APInt Offset, Type *TargetTy,
1549 Type *ElementTy = Ty->getElementType();
1579 APInt Offset, Type *PointerTy, Twine NamePrefix) {
1598 Type *TargetTy = TargetPtrTy->getElementType();
1686 Type *Ty;
1709 static bool canConvertValue(const DataLayout &DL, Type *OldTy, Type *NewTy) {
1709 static bool canConvertValue(const DataLayout &DL, Type *OldTy, Type *NewTy) {
1761 Type *NewTy) {
1762 Type *OldTy = V->getType();
1829 Type *SliceTy = (NumElements == 1)
1833 Type *SplitIntTy =
1834 Type::getIntNTy(Ty->getContext(), NumElements * ElementSize * 8);
1852 Type *LTy = LI->getType();
1862 Type *STy = SI->getValueOperand()->getType();
1889 Type *CommonEltTy = nullptr;
2003 Type *AllocaTy,
2043 Type *ValueTy = SI->getValueOperand()->getType();
2088 static bool isIntegerWideningViable(Partition &P, Type *AllocaTy,
2102 Type *IntTy = Type::getIntNTy(AllocaTy->getContext(), SizeInBits);
2102 Type *IntTy = Type::getIntNTy(AllocaTy->getContext(), SizeInBits);
2275 Type *NewAllocaTy;
2293 Type *ElementTy;
2332 ? Type::getIntNTy(
2392 Value *getNewAllocaSlicePtr(IRBuilderTy &IRB, Type *PointerTy) {
2435 unsigned getSliceAlign(Type *Ty = nullptr) {
2478 IntegerType *ExtractTy = Type::getIntNTy(LI.getContext(), SliceSize * 8);
2503 Type *TargetTy = IsSplit ? Type::getIntNTy(LI.getContext(), SliceSize * 8)
2503 Type *TargetTy = IsSplit ? Type::getIntNTy(LI.getContext(), SliceSize * 8)
2553 Type *LTy = TargetTy->getPointerTo(AS);
2606 Type *SliceTy = (NumElements == 1)
2670 IntegerType *NarrowTy = Type::getIntNTy(SI.getContext(), SliceSize * 8);
2737 Type *SplatIntTy = Type::getIntNTy(VTy->getContext(), Size * 8);
2737 Type *SplatIntTy = Type::getIntNTy(VTy->getContext(), Size * 8);
2777 Type *AllocaTy = NewAI.getAllocatedType();
2778 Type *ScalarTy = AllocaTy->getScalarType();
2799 Type *SizeTy = II.getLength()->getType();
2953 Type *OtherPtrTy = OtherPtr->getType();
2971 Type *SizeTy = II.getLength()->getType();
3003 IntTy ? Type::getIntNTy(IntTy->getContext(), Size * 8) : nullptr;
3007 Type *OtherTy;
3094 Type *PointerTy = IRB.getInt8PtrTy(OldPtr->getType()->getPointerAddressSpace());
3277 Type *BaseTy;
3288 OpSplitter(Instruction *InsertionPoint, Value *Ptr, Type *BaseTy,
3307 void emitSplitOps(Type *Ty, Value *&Agg, const Twine &Name) {
3351 LoadOpSplitter(Instruction *InsertionPoint, Value *Ptr, Type *BaseTy,
3358 void emitFunc(Type *Ty, Value *&Agg, unsigned Align, const Twine &Name) {
3390 StoreOpSplitter(Instruction *InsertionPoint, Value *Ptr, Type *BaseTy,
3398 void emitFunc(Type *Ty, Value *&Agg, unsigned Align, const Twine &Name) {
3467 static Type *stripAggregateTypeWrapping(const DataLayout &DL, Type *Ty) {
3467 static Type *stripAggregateTypeWrapping(const DataLayout &DL, Type *Ty) {
3474 Type *InnerTy;
3505 static Type *getTypePartition(const DataLayout &DL, Type *Ty, uint64_t Offset,
3505 static Type *getTypePartition(const DataLayout &DL, Type *Ty, uint64_t Offset,
3514 Type *ElementTy = SeqTy->getElementType();
3554 Type *ElementTy = STy->getElementType(Index);
3858 auto *PartTy = Type::getIntNTy(Ty->getContext(), PartSize * 8);
3992 auto *PartTy = Type::getIntNTy(Ty->getContext(), PartSize * 8);
4118 Type *SliceTy = nullptr;
4120 if (Type *CommonUseTy = findCommonType(P.begin(), P.end(), P.endOffset()))
4124 if (Type *TypePartitionTy = getTypePartition(DL, AI.getAllocatedType(),
4130 SliceTy = Type::getIntNTy(*C, P.size() * 8);
4132 SliceTy = ArrayType::get(Type::getInt8Ty(*C), P.size());
lib/Transforms/Scalar/Scalarizer.cpp 165 Type *ElemTy = nullptr;
204 bool getVectorLayout(Type *Ty, unsigned Alignment, VectorLayout &Layout,
241 Type *Ty = V->getType();
262 Type *ElTy = PtrTy->getElementType()->getVectorElementType();
264 Type *NewPtrTy = PointerType::get(ElTy, PtrTy->getAddressSpace());
418 bool ScalarizerVisitor::getVectorLayout(Type *Ty, unsigned Alignment,
683 Type *MidTy = VectorType::get(DstVT->getElementType(), FanOut);
701 Type *MidTy = VectorType::get(SrcVT->getElementType(), FanIn);
835 Type *Ty = Op->getType();
lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp 765 Type *IntPtrTy = DL->getIntPtrType(GEP->getType());
816 Type *IntPtrTy = DL->getIntPtrType(Variadic->getType());
818 Type *I8PtrTy =
888 Type *IntPtrTy = DL->getIntPtrType(Variadic->getType());
1068 Type *IntPtrTy = DL->getIntPtrType(GEP->getType());
1094 Type *I8PtrTy = Type::getInt8PtrTy(GEP->getContext(),
1094 Type *I8PtrTy = Type::getInt8PtrTy(GEP->getContext(),
1098 Type::getInt8Ty(GEP->getContext()), NewGEP,
lib/Transforms/Scalar/StraightLineStrengthReduce.cpp 667 Type *IntPtrTy = DL->getIntPtrType(C.Ins->getType());
672 Type *CharTy = Type::getInt8PtrTy(Basis.Ins->getContext(), AS);
672 Type *CharTy = Type::getInt8PtrTy(Basis.Ins->getContext(), AS);
lib/Transforms/Scalar/StructurizeCFG.cpp 183 Type *Boolean;
304 Boolean = Type::getInt1Ty(Context);
lib/Transforms/Utils/BuildLibCalls.cpp 788 bool llvm::hasFloatFn(const TargetLibraryInfo *TLI, Type *Ty,
791 case Type::HalfTyID:
793 case Type::FloatTyID:
795 case Type::DoubleTyID:
802 StringRef llvm::getFloatFnName(const TargetLibraryInfo *TLI, Type *Ty,
809 case Type::HalfTyID:
811 case Type::FloatTyID:
813 case Type::DoubleTyID:
827 static Value *emitLibCall(LibFunc TheLibFunc, Type *ReturnType,
828 ArrayRef<Type *> ParamTypes,
862 Type *I8Ptr = B.getInt8PtrTy();
863 Type *I32Ty = B.getInt32Ty();
879 Type *I8Ptr = B.getInt8PtrTy();
886 Type *I8Ptr = B.getInt8PtrTy();
893 Type *I8Ptr = B.getInt8PtrTy();
900 Type *I8Ptr = B.getInt8PtrTy();
lib/Transforms/Utils/BypassSlowDivision.cpp 102 Type *getSlowType() { return SlowDivOrRem->getType(); }
lib/Transforms/Utils/CallPromotionUtils.cpp 161 static void createRetBitCast(CallSite CS, Type *RetTy, CastInst **RetBitCast) {
327 Type *CallRetTy = CS.getInstruction()->getType();
328 Type *FuncRetTy = Callee->getReturnType();
351 Type *FormalTy = Callee->getFunctionType()->getFunctionParamType(I);
352 Type *ActualTy = CS.getArgument(I)->getType();
385 Type *CallSiteRetTy = CS.getInstruction()->getType();
386 Type *CalleeRetTy = Callee->getReturnType();
405 Type *FormalTy = CalleeType->getParamType(ArgNo);
406 Type *ActualTy = Arg->getType();
419 Type *NewTy = Callee->getParamByValType(ArgNo);
lib/Transforms/Utils/CloneFunction.cpp 239 std::vector<Type*> ArgTypes;
lib/Transforms/Utils/CodeExtractor.cpp 779 case 1: RetTy = Type::getVoidTy(header->getContext()); break;
780 case 2: RetTy = Type::getInt1Ty(header->getContext()); break;
781 default: RetTy = Type::getInt16Ty(header->getContext()); break;
784 std::vector<Type *> paramTy;
934 Idx[0] = Constant::getNullValue(Type::getInt32Ty(header->getContext()));
935 Idx[1] = ConstantInt::get(Type::getInt32Ty(header->getContext()), i);
1011 auto Int8PtrTy = Type::getInt8PtrTy(Ctx);
1012 auto NegativeOne = ConstantInt::getSigned(Type::getInt64Ty(Ctx), -1);
1104 std::vector<Type *> ArgTypes;
1118 Idx[0] = Constant::getNullValue(Type::getInt32Ty(Context));
1119 Idx[1] = ConstantInt::get(Type::getInt32Ty(Context), i);
1157 Idx[0] = Constant::getNullValue(Type::getInt32Ty(Context));
1158 Idx[1] = ConstantInt::get(Type::getInt32Ty(Context), FirstOut + i);
1180 SwitchInst::Create(Constant::getNullValue(Type::getInt16Ty(Context)),
1211 brVal = ConstantInt::get(Type::getInt1Ty(Context), !SuccNum);
1214 brVal = ConstantInt::get(Type::getInt16Ty(Context), SuccNum);
1221 TheSwitch->addCase(ConstantInt::get(Type::getInt16Ty(Context),
1260 Idx[0] = Constant::getNullValue(Type::getInt32Ty(Context));
1261 Idx[1] = ConstantInt::get(Type::getInt32Ty(Context), FirstOut + i);
1276 Type *OldFnRetTy = TheSwitch->getParent()->getParent()->getReturnType();
lib/Transforms/Utils/EntryExitInstrumenter.cpp 33 FunctionCallee Fn = M.getOrInsertFunction(Func, Type::getVoidTy(C));
40 Type *ArgTypes[] = {Type::getInt8PtrTy(C), Type::getInt8PtrTy(C)};
40 Type *ArgTypes[] = {Type::getInt8PtrTy(C), Type::getInt8PtrTy(C)};
40 Type *ArgTypes[] = {Type::getInt8PtrTy(C), Type::getInt8PtrTy(C)};
43 Func, FunctionType::get(Type::getVoidTy(C), ArgTypes, false));
47 ArrayRef<Value *>(ConstantInt::get(Type::getInt32Ty(C), 0)), "",
51 Value *Args[] = {ConstantExpr::getBitCast(&CurFn, Type::getInt8PtrTy(C)),
lib/Transforms/Utils/EscapeEnumerator.cpp 26 FunctionType::get(Type::getInt32Ty(C), true));
69 Type *ExnTy = StructType::get(Type::getInt8PtrTy(C), Type::getInt32Ty(C));
69 Type *ExnTy = StructType::get(Type::getInt8PtrTy(C), Type::getInt32Ty(C));
69 Type *ExnTy = StructType::get(Type::getInt8PtrTy(C), Type::getInt32Ty(C));
lib/Transforms/Utils/Evaluator.cpp 190 Type *Ty = cast<PointerType>(Ptr->getType())->getElementType();
376 Type *Ty = cast<PointerType>(P->getType())->getElementType();
471 Type *Ty = AI->getAllocatedType();
530 Type *ElemTy = GV->getValueType();
lib/Transforms/Utils/FunctionComparator.cpp 120 Type *TyL = LA.getValueAsType();
121 Type *TyR = RA.getValueAsType();
202 Type *TyL = L->getType();
203 Type *TyR = R->getType();
406 int FunctionComparator::cmpTypes(Type *TyL, Type *TyR) const {
406 int FunctionComparator::cmpTypes(Type *TyL, Type *TyR) const {
425 case Type::IntegerTyID:
429 case Type::VoidTyID:
430 case Type::FloatTyID:
431 case Type::DoubleTyID:
432 case Type::X86_FP80TyID:
433 case Type::FP128TyID:
434 case Type::PPC_FP128TyID:
435 case Type::LabelTyID:
436 case Type::MetadataTyID:
437 case Type::TokenTyID:
440 case Type::PointerTyID:
444 case Type::StructTyID: {
460 case Type::FunctionTyID: {
479 case Type::ArrayTyID:
480 case Type::VectorTyID: {
lib/Transforms/Utils/InlineFunction.cpp 1249 Type *AggTy = cast<PointerType>(Src->getType())->getElementType();
1267 Type *AggTy = ArgTy->getElementType();
1325 Type *Ty = AI->getType();
1326 Type *Int8PtrTy = Type::getInt8PtrTy(Ty->getContext(),
1326 Type *Int8PtrTy = Type::getInt8PtrTy(Ty->getContext(),
1974 Type *AllocaType = AI->getAllocatedType();
1987 AllocaSize = ConstantInt::get(Type::getInt64Ty(AI->getContext()),
2176 Type *NewRetTy = Caller->getReturnType();
2309 Type *RTy = CalledFunc->getReturnType();
lib/Transforms/Utils/IntegerDivision.cpp 490 Type *RemTy = Rem->getType();
509 Type *Int32Ty = Builder.getInt32Ty();
539 Type *RemTy = Rem->getType();
557 Type *Int64Ty = Builder.getInt64Ty();
588 Type *DivTy = Div->getType();
606 Type *Int32Ty = Builder.getInt32Ty();
636 Type *DivTy = Div->getType();
655 Type *Int64Ty = Builder.getInt64Ty();
lib/Transforms/Utils/LibCallsShrinkWrap.cpp 309 Type *ArgType = CI.getArgOperand(0)->getType();
lib/Transforms/Utils/Local.cpp 708 ConstantInt::get(Type::getInt32Ty(BA->getContext()), 1);
1256 static bool valueCoversEntireFragment(Type *ValTy, DbgVariableIntrinsic *DII) {
1803 static bool isBitCastSemanticsPreserving(const DataLayout &DL, Type *FromTy,
1804 Type *ToTy) {
1829 Type *FromTy = From.getType();
1830 Type *ToTy = To.getType();
2380 Type *NewType = Dest.getType();
2543 auto *NewTy = NewLI.getType();
2568 auto *NewTy = NewLI.getType();
lib/Transforms/Utils/LoopUtils.cpp 204 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), V))};
897 Type *Ty = Src->getType()->getVectorElementType();
lib/Transforms/Utils/LowerMemIntrinsics.cpp 17 static unsigned getLoopOperandSizeInBytes(Type *Type) {
39 Type *TypeOfCopyLen = CopyLen->getType();
40 Type *LoopOpType =
100 SmallVector<Type *, 5> RemainingOps;
148 Type *LoopOpType =
166 Type *CopyLenType = CopyLen->getType();
170 Type *Int8Type = Type::getInt8Ty(Ctx);
170 Type *Int8Type = Type::getInt8Ty(Ctx);
291 Type *TypeOfCopyLen = CopyLen->getType();
295 Type *EltTy = cast<PointerType>(SrcAddr->getType())->getElementType();
371 Type *TypeOfCopyLen = CopyLen->getType();
lib/Transforms/Utils/ModuleUtils.cpp 85 Type *Int8PtrTy = llvm::Type::getInt8PtrTy(M.getContext());
85 Type *Int8PtrTy = llvm::Type::getInt8PtrTy(M.getContext());
111 ArrayRef<Type *> InitArgTypes) {
115 FunctionType::get(Type::getVoidTy(M.getContext()), InitArgTypes, false),
121 ArrayRef<Type *> InitArgTypes, ArrayRef<Value *> InitArgs,
129 FunctionType::get(Type::getVoidTy(M.getContext()), false),
146 ArrayRef<Type *> InitArgTypes, ArrayRef<Value *> InitArgs,
155 Ctor->getReturnType() == Type::getVoidTy(M.getContext()))
170 F->getReturnType() != Type::getVoidTy(M.getContext())) {
180 Type::getVoidTy(M.getContext()))
lib/Transforms/Utils/PredicateInfo.cpp 522 static Function *getCopyDeclaration(Module *M, Type *Ty) {
lib/Transforms/Utils/PromoteMemoryToRegister.cpp 87 if (BCI->getType() != Type::getInt8PtrTy(U->getContext(), AS))
92 if (GEPI->getType() != Type::getInt8PtrTy(U->getContext(), AS))
lib/Transforms/Utils/SSAUpdater.cpp 53 void SSAUpdater::Initialize(Type *Ty, StringRef Name) {
lib/Transforms/Utils/SSAUpdaterBulk.cpp 40 unsigned SSAUpdaterBulk::AddVariable(StringRef Name, Type *Ty) {
lib/Transforms/Utils/SanitizerStats.cpp 25 StatTy = ArrayType::get(Type::getInt8PtrTy(M->getContext()), 2);
37 return StructType::get(M->getContext(), {Type::getInt8PtrTy(M->getContext()),
38 Type::getInt32Ty(M->getContext()),
77 PointerType *Int8PtrTy = Type::getInt8PtrTy(M->getContext());
78 IntegerType *Int32Ty = Type::getInt32Ty(M->getContext());
79 Type *VoidTy = Type::getVoidTy(M->getContext());
79 Type *VoidTy = Type::getVoidTy(M->getContext());
lib/Transforms/Utils/SimplifyCFG.cpp 3236 ConstantInt::get(Type::getInt1Ty(BB->getContext()), CondIsTrue));
3246 Type::getInt1Ty(BB->getContext()), std::distance(PB, PE),
3258 ConstantInt::get(Type::getInt1Ty(BB->getContext()), CondIsTrue),
4933 Type *ElementType);
4985 Type *ValueType = Values.begin()->second->getType();
5149 Type *ElementType) {
5167 const SmallDenseMap<PHINode *, Type *> &ResultTypes) {
5174 Type *Ty = I.second;
5328 SmallDenseMap<PHINode *, Type *> ResultTypes;
5464 Shifted, Type::getInt1Ty(Mod.getContext()), "switch.lobit");
lib/Transforms/Utils/SimplifyIndVar.cpp 342 auto *T = Rem->getType();
389 auto *T = Rem->getType();
518 Type *IVTy = IV->getType();
lib/Transforms/Utils/SimplifyLibCalls.cpp 585 Type *PT = Callee->getFunctionType()->getParamType(0);
638 Type *PT = Callee->getFunctionType()->getParamType(0);
1028 Type *LHSPtrTy =
1033 Type *RHSPtrTy =
1433 Type *Ty = Pow->getType();
1595 Type *Ty = Pow->getType();
1640 Type *Ty = Pow->getType();
1768 Type *Ty = CI->getType();
1817 Type *Ty = Log->getType();
2017 Type *ArgType = I->getType();
2072 Type *ArgTy = Arg->getType();
2073 Type *ResTy;
2203 Type *ArgType = Op->getType();
2217 Type *ArgType = Op->getType();
3294 Type *SizeTTy = DL.getIntPtrType(CI->getContext());
lib/Transforms/Utils/VNCoercion.cpp 15 bool canCoerceMustAliasedValueToLoad(Value *StoredVal, Type *LoadTy,
17 Type *StoredTy = StoredVal->getType();
52 static T *coerceAvailableValueToLoadTypeHelper(T *StoredVal, Type *LoadedTy,
62 Type *StoredValTy = StoredVal->getType();
79 Type *TypeToCastTo = LoadedTy;
125 Type *NewIntTy = IntegerType::get(StoredValTy->getContext(), LoadedValSize);
150 Value *coerceAvailableValueToLoadType(Value *StoredVal, Type *LoadedTy,
163 static int analyzeLoadFromClobberingWrite(Type *LoadTy, Value *LoadPtr,
218 int analyzeLoadFromClobberingStore(Type *LoadTy, Value *LoadPtr,
246 int analyzeLoadFromClobberingLoad(Type *LoadTy, Value *LoadPtr, LoadInst *DepLI,
283 int analyzeLoadFromClobberingMemInst(Type *LoadTy, Value *LoadPtr,
332 ConstantExpr::getBitCast(Src, Type::getInt8PtrTy(Src->getContext(), AS));
334 ConstantInt::get(Type::getInt64Ty(Src->getContext()), (unsigned)Offset);
335 Src = ConstantExpr::getGetElementPtr(Type::getInt8Ty(Src->getContext()), Src,
344 static T *getStoreValueForLoadHelper(T *SrcVal, unsigned Offset, Type *LoadTy,
387 Value *getStoreValueForLoad(Value *SrcVal, unsigned Offset, Type *LoadTy,
396 Type *LoadTy, const DataLayout &DL) {
407 Value *getLoadValueForLoad(LoadInst *SrcVal, unsigned Offset, Type *LoadTy,
427 Type *DestTy = IntegerType::get(LoadTy->getContext(), NewLoadSize * 8);
428 Type *DestPTy =
454 Type *LoadTy, const DataLayout &DL) {
464 Type *LoadTy, HelperClass &Helper,
508 ConstantExpr::getBitCast(Src, Type::getInt8PtrTy(Src->getContext(), AS));
510 ConstantInt::get(Type::getInt64Ty(Src->getContext()), (unsigned)Offset);
511 Src = ConstantExpr::getGetElementPtr(Type::getInt8Ty(Src->getContext()), Src,
520 Type *LoadTy, Instruction *InsertPt,
528 Type *LoadTy, const DataLayout &DL) {
lib/Transforms/Utils/ValueMapper.cpp 440 Type *NewTy = C->getType();
468 Type *NewSrcTy = nullptr;
892 SmallVector<Type *, 3> Tys;
895 for (Type *Ty : FTy->params())
904 Type *Ty = Attrs.getAttribute(i, Attribute::ByVal).getValueAsType();
967 Type *EltTy;
971 VoidPtrTy = Type::getInt8Ty(GV.getContext())->getPointerTo();
973 Type *Tys[3] = {ST.getElementType(0), ST.getElementType(1), VoidPtrTy};
lib/Transforms/Vectorize/LoadStoreVectorizer.cpp 323 Type *PtrATy = PtrA->getType()->getPointerElementType();
324 Type *PtrBTy = PtrB->getType()->getPointerElementType();
757 Type *Ty = LI->getType();
804 Type *Ty = SI->getValueOperand()->getType();
944 Type *StoreTy = nullptr;
951 StoreTy = Type::getIntNTy(F.getParent()->getContext(),
1095 Type *LoadTy = nullptr;
1102 LoadTy = Type::getIntNTy(F.getParent()->getContext(),
lib/Transforms/Vectorize/LoopVectorizationLegality.cpp 369 static Type *convertPointerToIntegerType(const DataLayout &DL, Type *Ty) {
369 static Type *convertPointerToIntegerType(const DataLayout &DL, Type *Ty) {
376 return Type::getInt32Ty(Ty->getContext());
381 static Type *getWiderType(const DataLayout &DL, Type *Ty0, Type *Ty1) {
381 static Type *getWiderType(const DataLayout &DL, Type *Ty0, Type *Ty1) {
381 static Type *getWiderType(const DataLayout &DL, Type *Ty0, Type *Ty1) {
504 Type *PhiTy = Phi->getType();
582 Type *PhiTy = Phi->getType();
730 Type *T = ST->getValueOperand()->getType();
742 Type *VecTy = VectorType::get(T, /*NumElements=*/2);
759 Type *VecTy = VectorType::get(I.getType(), /*NumElements=*/2);
lib/Transforms/Vectorize/LoopVectorize.cpp 300 static Type *ToVectorTy(Type *Scalar, unsigned VF) {
300 static Type *ToVectorTy(Type *Scalar, unsigned VF) {
307 static Type *getMemInstValueType(Value *I) {
318 static bool hasIrregularType(Type *Ty, const DataLayout &DL, unsigned VF) {
354 static Constant *getSignedIntOrFpConstant(Type *Ty, int64_t C) {
1160 Type *SrcTy = ToVectorTy(cast<CastInst>(I)->getSrcTy(), VF);
1161 Type *DestTy = ToVectorTy(cast<CastInst>(I)->getDestTy(), VF);
1194 bool isLegalMaskedStore(Type *DataType, Value *Ptr, MaybeAlign Alignment) {
1201 bool isLegalMaskedLoad(Type *DataType, Value *Ptr, MaybeAlign Alignment) {
1208 bool isLegalMaskedScatter(Type *DataType) {
1214 bool isLegalMaskedGather(Type *DataType) {
1225 auto *Ty = getMemInstValueType(V);
1329 unsigned getInstructionCost(Instruction *I, unsigned VF, Type *&VectorTy);
1897 Type *STy = Val->getType()->getScalarType();
1954 Type *ScalarIVTy = ScalarIV->getType()->getScalarType();
2172 Type *ScalarTy = getMemInstValueType(Instr);
2174 Type *VecTy = VectorType::get(ScalarTy, InterleaveFactor * VF);
2175 Type *PtrTy = VecTy->getPointerTo(getLoadStoreAddressSpace(Instr));
2360 Type *ScalarDataTy = getMemInstValueType(Instr);
2361 Type *DataTy = VectorType::get(ScalarDataTy, VF);
2566 Type *IdxTy = Legal->getWidestInductionType();
2608 Type *Ty = TC->getType();
2653 Type *SrcElemTy = SrcVecTy->getElementType();
2654 Type *DstElemTy = DstVTy->getElementType();
2670 Type *IntTy =
2935 Type *IdxTy = Legal->getWidestInductionType();
3017 Type *StepType = II.getStep()->getType();
3225 Type *ScalarRetTy = CI->getType();
3226 SmallVector<Type *, 4> Tys, ScalarTys;
3239 Type *RetTy = ToVectorTy(ScalarRetTy, VF);
3240 for (Type *ScalarTy : ScalarTys)
3277 static Type *smallestIntegerVectorType(Type *T1, Type *T2) {
3277 static Type *smallestIntegerVectorType(Type *T1, Type *T2) {
3277 static Type *smallestIntegerVectorType(Type *T1, Type *T2) {
3282 static Type *largestIntegerVectorType(Type *T1, Type *T2) {
3282 static Type *largestIntegerVectorType(Type *T1, Type *T2) {
3282 static Type *largestIntegerVectorType(Type *T1, Type *T2) {
3304 Type *OriginalTy = I->getType();
3305 Type *ScalarTruncatedTy =
3307 Type *TruncatedTy = VectorType::get(ScalarTruncatedTy,
3663 Type *VecTy = getOrCreateVectorValue(LoopExitInst, 0)->getType();
3746 Type *RdxVecTy = VectorType::get(RdxDesc.getRecurrenceType(), VF);
3972 Type *VecTy =
3991 Type *VecTy =
4245 Type *DestTy =
4268 Type *RetTy = ToVectorTy(CI->getType(), VF);
4269 SmallVector<Type *, 4> Tys;
4299 Type *TysForDecl[] = {CI->getType()};
4556 auto *Ty = getMemInstValueType(I);
4590 auto *ScalarTy = getMemInstValueType(I);
4610 auto *Ty = getMemInstValueType(I);
4637 auto *ScalarTy = LI ? LI->getType() : SI->getValueOperand()->getType();
5078 Type *T = I.getType();
5731 Type *ValTy = getMemInstValueType(I);
5736 Type *PtrTy = ToVectorTy(Ptr->getType(), VF);
5772 Type *ValTy = getMemInstValueType(I);
5773 Type *VectorTy = ToVectorTy(ValTy, VF);
5796 Type *ValTy = getMemInstValueType(I);
5797 Type *VectorTy = ToVectorTy(ValTy, VF);
5818 Type *ValTy = getMemInstValueType(I);
5819 Type *VectorTy = ToVectorTy(ValTy, VF);
5831 Type *ValTy = getMemInstValueType(I);
5832 Type *VectorTy = ToVectorTy(ValTy, VF);
5839 Type *WideVecTy = VectorType::get(ValTy, VF * InterleaveFactor);
5872 Type *ValTy = getMemInstValueType(I);
5900 Type *VectorTy;
5915 Type *RetTy = ToVectorTy(I->getType(), VF);
6092 Type *&VectorTy) {
6093 Type *RetTy = I->getType();
6122 Type *Vec_i1Ty =
6152 ToVectorTy(Type::getInt1Ty(Phi->getContext()), VF));
6230 Type *CondTy = SI->getCondition()->getType();
6238 Type *ValTy = I->getOperand(0)->getType();
6279 Type *SrcScalarTy = I->getOperand(0)->getType();
6280 Type *SrcVecTy =
6288 Type *MinVecTy = VectorTy;
6566 Type *Ty = Val->getType();
7421 Type *PredInstType = PredInst->getType();
lib/Transforms/Vectorize/SLPVectorizer.cpp 174 static bool isValidElementType(Type *Ty) {
388 Type *Ty0 = cast<Instruction>(VL[BaseIndex])->getOperand(0)->getType();
389 Type *Ty1 = cast<Instruction>(VL[Cnt])->getOperand(0)->getType();
411 Type *Ty = VL[0]->getType();
615 unsigned canMapToVector(Type *T, const DataLayout &DL) const;
1168 int getGatherCost(Type *Ty, const DenseSet<unsigned> &ShuffledIndices) const;
2405 Type *ScalarTy = VL0->getType();
2491 Type *SrcTy = VL0->getOperand(0)->getType();
2493 Type *Ty = cast<Instruction>(V)->getOperand(0)->getType();
2523 Type *ComparedTy = VL0->getOperand(0)->getType();
2626 Type *Ty0 = VL0->getOperand(0)->getType();
2628 Type *CurTy = cast<Instruction>(V)->getOperand(0)->getType();
2808 unsigned BoUpSLP::canMapToVector(Type *T, const DataLayout &DL) const {
2810 Type *EltTy;
2826 for (const auto *Ty : ST->elements())
2910 Type *ScalarTy = VL[0]->getType();
3047 Type *SrcTy = VL0->getOperand(0)->getType();
3199 SmallVector<Type *, 4> ScalarTys;
3257 Type *Src0SclTy = E->getMainOp()->getOperand(0)->getType();
3258 Type *Src1SclTy = E->getAltOp()->getOperand(0)->getType();
3319 Type *SrcTy = LoadPtr->getType()->getPointerElementType();
3410 SmallVector<Type*, 4> V;
3508 int BoUpSLP::getGatherCost(Type *Ty,
3521 Type *ScalarTy = VL[0]->getType();
3676 Type *ScalarTy = S.OpValue->getType();
3731 Type *ScalarTy = VL0->getType();
4018 Type *ScalarLoadTy = LI->getType();
4137 Type *Tys[] = { VectorType::get(CI->getType(), E->Scalars.size()) };
4370 Type *Ty = Scalar->getType();
4948 auto *Ty = I->getType();
5530 Type *Ty = V->getType();
6007 Type *getConditionType() const {
6268 Type *Ty = B->getType();
6512 Type *ScalarTy = FirstReducedVal->getType();
6513 Type *VecTy = VectorType::get(ScalarTy, ReduxWidth);
6530 Type *VecCondTy = CmpInst::makeCmpResultType(VecTy);
lib/Transforms/Vectorize/VPlanSLP.cpp 63 Type *T = cast<VPInstruction>(V)->getUnderlyingInstr()->getType();
tools/bugpoint/CrashDebugger.cpp 228 auto *NewValElemTy = OldUsedVal->getType()->getElementType();
523 if (V && V->getType() == Type::getLabelTy(V->getContext()))
630 if (V && V->getType() == Type::getLabelTy(V->getContext()))
722 if (V && V->getType() == Type::getLabelTy(V->getContext()))
tools/bugpoint/ExtractFunction.cpp 231 Type *Int32Ty = Type::getInt32Ty(TorList[0].first->getContext());
231 Type *Int32Ty = Type::getInt32Ty(TorList[0].first->getContext());
tools/bugpoint/Miscompilation.cpp 830 "getPointerToNamedFunction", Type::getInt8PtrTy(Safe->getContext()),
831 Type::getInt8PtrTy(Safe->getContext()));
854 2, Constant::getNullValue(Type::getInt32Ty(F->getContext())));
tools/clang/include/clang/CodeGen/CGFunctionInfo.h 79 llvm::Type *TypeData; // canHaveCoerceToType()
81 llvm::Type *PaddingType; // canHavePaddingType()
82 llvm::Type *UnpaddedCoerceAndExpandType; // isCoerceAndExpand()
102 void setPaddingType(llvm::Type *T) {
107 void setUnpaddedCoerceToType(llvm::Type *T) {
119 static ABIArgInfo getDirect(llvm::Type *T = nullptr, unsigned Offset = 0,
120 llvm::Type *Padding = nullptr,
129 static ABIArgInfo getDirectInReg(llvm::Type *T = nullptr) {
135 static ABIArgInfo getSignExtend(QualType Ty, llvm::Type *T = nullptr) {
145 static ABIArgInfo getZeroExtend(QualType Ty, llvm::Type *T = nullptr) {
157 static ABIArgInfo getExtend(QualType Ty, llvm::Type *T = nullptr) {
164 static ABIArgInfo getExtendInReg(QualType Ty, llvm::Type *T = nullptr) {
174 llvm::Type *Padding = nullptr) {
200 llvm::Type *Padding) {
211 llvm::Type *unpaddedCoerceToType) {
246 static bool isPaddingForCoerceAndExpand(llvm::Type *eltType) {
287 llvm::Type *getPaddingType() const {
298 llvm::Type *getCoerceToType() const {
303 void setCoerceToType(llvm::Type *T) {
313 llvm::Type *getUnpaddedCoerceAndExpandType() const {
318 ArrayRef<llvm::Type *>getCoerceAndExpandTypeSequence() const {
tools/clang/include/clang/CodeGen/CodeGenABITypes.h 78 llvm::Type *convertTypeForMemory(CodeGenModule &CGM, QualType T);
tools/clang/include/clang/CodeGen/ConstantInitBuilder.h 208 void addBitCast(llvm::Constant *value, llvm::Type *type) {
279 PlaceholderPosition addPlaceholderWithSize(llvm::Type *expectedType);
303 llvm::Constant *getAddrOfCurrentPosition(llvm::Type *type);
312 llvm::Constant *finishArray(llvm::Type *eltTy);
343 ArrayBuilder beginArray(llvm::Type *eltTy = nullptr) {
409 llvm::Type *EltTy;
417 llvm::Type *eltTy)
495 ArrayBuilder beginArray(llvm::Type *eltTy = nullptr) {
536 llvm::Type *eltTy)
tools/clang/include/clang/CodeGen/ConstantInitFuture.h 67 llvm::Type *getType() const;
tools/clang/include/clang/CodeGen/SwiftCallingConv.h 47 llvm::Type *Type;
67 void addTypedData(llvm::Type *type, CharUnits begin);
68 void addTypedData(llvm::Type *type, CharUnits begin, CharUnits end);
92 llvm::function_ref<void(CharUnits offset, CharUnits end, llvm::Type *type)>;
108 std::pair<llvm::StructType*, llvm::Type*> getCoerceAndExpandTypes() const;
113 void addLegalTypedData(llvm::Type *type, CharUnits begin, CharUnits end);
114 void addEntry(llvm::Type *type, CharUnits begin, CharUnits end);
124 ArrayRef<llvm::Type*> types,
131 CharUnits getNaturalAlignment(CodeGenModule &CGM, llvm::Type *type);
142 llvm::Type *eltTy, unsigned numElts);
145 std::pair<llvm::Type*, unsigned>
155 llvm::SmallVectorImpl<llvm::Type*> &types);
tools/clang/lib/CodeGen/ABIInfo.h 110 llvm::Type *Padding = nullptr) const;
129 virtual bool shouldPassIndirectlyForSwift(ArrayRef<llvm::Type*> types,
133 llvm::Type *eltTy,
tools/clang/lib/CodeGen/Address.h 51 llvm::Type *getElementType() const {
87 ConstantAddress getBitCast(llvm::Type *ty) const {
92 ConstantAddress getElementBitCast(llvm::Type *ty) const {
tools/clang/lib/CodeGen/BackendUtil.cpp 1602 Type *UsedElementType = Type::getInt8Ty(M->getContext())->getPointerTo(0);
1602 Type *UsedElementType = Type::getInt8Ty(M->getContext())->getPointerTo(0);
tools/clang/lib/CodeGen/CGAtomic.cpp 248 bool requiresMemSetZero(llvm::Type *type) const;
315 static bool isFullSizeType(CodeGenModule &CGM, llvm::Type *type,
323 bool AtomicInfo::requiresMemSetZero(llvm::Type *type) const {
731 llvm::Type *IPtrTy = llvm::IntegerType::get(CGF.getLLVMContext(),
1339 llvm::Type *Ty = Addr.getElementType();
1395 auto *ValTy = AsValue
tools/clang/lib/CodeGen/CGBlocks.cpp 193 llvm::Type::getInt8PtrTy(
344 llvm::Type *Type;
350 llvm::Type *type, QualType fieldType)
448 SmallVectorImpl<llvm::Type*> &elementTypes) {
526 SmallVector<llvm::Type*, 8> elementTypes;
558 llvm::Type *llvmType = CGM.getTypes().ConvertType(thisType);
656 llvm::Type *llvmType =
1185 llvm::Type *CodeGenModule::getBlockDescriptorType() {
1189 llvm::Type *UnsignedLongTy =
1217 llvm::Type *CodeGenModule::getGenericBlockLiteralType() {
1221 llvm::Type *BlockDescPtrTy = getBlockDescriptorType();
1230 SmallVector<llvm::Type *, 8> StructFields(
1258 llvm::Type *GenBlockTy = CGM.getGenericBlockLiteralType();
1306 llvm::Type *BlockFTy = CGM.getTypes().GetFunctionType(FnInfo);
1308 llvm::Type *BlockFTyPtr = llvm::PointerType::getUnqual(BlockFTy);
1463 llvm::Type *RequiredType =
2040 llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo();
2235 llvm::Type *structPtrTy = blockInfo.StructureType->getPointerTo();
2485 llvm::Type *byrefPtrType = byrefInfo.Type->getPointerTo(0);
2742 SmallVector<llvm::Type *, 8> types;
2782 llvm::Type *varTy = ConvertTypeForMem(Ty);
2790 llvm::Type *paddingTy =
2986 llvm::Type *args[] = { Int8PtrTy, Int32Ty };
2999 llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, Int32Ty };
tools/clang/lib/CodeGen/CGBuilder.h 98 llvm::LoadInst *CreateAlignedLoad(llvm::Type *Ty, llvm::Value *Addr,
141 Address CreateBitCast(Address Addr, llvm::Type *Ty,
148 Address CreateAddrSpaceCast(Address Addr, llvm::Type *Ty,
156 Address CreateElementBitCast(Address Addr, llvm::Type *Ty,
163 Address CreatePointerBitCastOrAddrSpaceCast(Address Addr, llvm::Type *Ty,
218 llvm::Type *ElTy = Addr.getElementType();
tools/clang/lib/CodeGen/CGBuiltin.cpp 58 llvm::Type *Int8 = llvm::IntegerType::getInt8Ty(CGF.CGM.getLLVMContext());
105 QualType T, llvm::Type *ResultType) {
132 llvm::Type *IntPtrType = IntType->getPointerTo(AddrSpace);
137 llvm::Type *ValueType = Args[1]->getType();
193 llvm::Type *IntPtrType = IntType->getPointerTo(AddrSpace);
197 llvm::Type *ValueType = Args[1]->getType();
233 llvm::Type *IntPtrType = IntType->getPointerTo(AddrSpace);
238 llvm::Type *ValueType = Args[1]->getType();
299 auto *IntTy = CGF.ConvertType(E->getType());
312 auto *IntTy = CGF.ConvertType(E->getType());
326 llvm::Type *ITy =
340 llvm::Type *ITy =
398 llvm::Type *ResultType = CGF.ConvertType(E->getType());
419 llvm::Type *Ty = V->getType();
421 llvm::Type *IntTy = llvm::IntegerType::get(C, Width);
531 llvm::Type *DestType = Int8PtrTy;
717 llvm::Type *IntPtrType = IntType->getPointerTo();
834 llvm::Type *Arg1Ty = nullptr;
855 llvm::Type *ArgTypes[2] = {CGF.Int8PtrTy, Arg1Ty};
918 llvm::Type *ArgType = ArgValue->getType();
919 llvm::Type *IndexType =
921 llvm::Type *ResultType = ConvertType(E->getType());
1267 llvm::IntegerType *IntTy = llvm::Type::getIntNTy(getLLVMContext(),
1332 llvm::Type *OpTy = Signed->getType();
1335 llvm::Type *ResTy = ResultPtr.getElementType();
1522 llvm::Type *Ty = Src->getType();
1804 llvm::Type *Type = Int8PtrTy;
1848 llvm::Type *LLVMIntTy = getTypes().ConvertType(getContext().IntTy);
1850 LLVMIntTy, {llvm::Type::getInt8PtrTy(getLLVMContext())}, true);
1901 llvm::Type *ArgType = ArgValue->getType();
1904 llvm::Type *ResultType = ConvertType(E->getType());
1921 llvm::Type *ArgType = ArgValue->getType();
1924 llvm::Type *ResultType = ConvertType(E->getType());
1938 llvm::Type *ArgType = ArgValue->getType();
1941 llvm::Type *ResultType = ConvertType(E->getType());
1955 llvm::Type *ArgType = ArgValue->getType();
1958 llvm::Type *ResultType = ConvertType(E->getType());
1976 llvm::Type *ArgType = ArgValue->getType();
1979 llvm::Type *ResultType = ConvertType(E->getType());
1992 llvm::Type *ArgType = ArgValue->getType();
1995 llvm::Type *ResultType = ConvertType(E->getType());
2010 llvm::Type *ArgType = ArgValue->getType();
2013 llvm::Type *ResultType = ConvertType(E->getType());
2028 llvm::Type *ArgType = ArgValue->getType();
2102 llvm::Type *ResultType = ConvertType(E->getType());
2184 llvm::Type *ArgType = Base->getType();
2259 llvm::Type *IntTy = ConvertType(E->getType());
2289 llvm::Type *ResultType = ConvertType(E->getType());
2299 llvm::Type *Ty = ConvertType(E->getArg(5)->getType());
2499 llvm::Type *WCharTy = ConvertType(getContext().WCharTy);
2843 llvm::Type *ITy = llvm::IntegerType::get(getLLVMContext(),
3238 llvm::Type *EncompassingLLVMTy =
3241 llvm::Type *ResultLLVMTy = CGM.getTypes().ConvertType(ResultQTy);
3396 llvm::Type *RTy;
3400 llvm::Type *IntPtrType = IntType->getPointerTo();
3573 llvm::Type *I8PTy = llvm::PointerType::get(
3574 llvm::Type::getInt8Ty(getLLVMContext()), GenericAS);
3582 llvm::Type *ArgTys[] = {Arg0->getType(), I8PTy, Int32Ty, Int32Ty};
3595 llvm::Type *ArgTys[] = {Arg0->getType(), Arg1->getType(), Int32Ty, I8PTy,
3636 llvm::Type *ReservedIDTy = ConvertType(getContext().OCLReserveIDTy);
3642 llvm::Type *ArgTys[] = {Arg0->getType(), Int32Ty, Int32Ty, Int32Ty};
3682 llvm::Type *ArgTys[] = {Arg0->getType(), Arg1->getType(), Int32Ty, Int32Ty};
3684 llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()),
3708 llvm::Type *ArgTys[] = {Arg0->getType(), Int32Ty, Int32Ty};
3746 llvm::Type *QueueTy = ConvertType(getContext().OCLQueueTy);
3747 llvm::Type *GenericVoidPtrTy = Builder.getInt8PtrTy(
3754 llvm::Type *RangeTy = NDRangeL.getAddress().getType();
3760 llvm::Type *ArgTys[] = {QueueTy, Int32Ty, RangeTy, GenericVoidPtrTy,
3832 std::vector<llvm::Type *> ArgTys = {
3847 llvm::Type *EventTy = ConvertType(getContext().OCLClkEventTy);
3884 std::vector<llvm::Type *> ArgTys = {
3926 llvm::Type *GenericVoidPtrTy = Builder.getInt8PtrTy(
3940 llvm::Type *GenericVoidPtrTy = Builder.getInt8PtrTy(
3955 llvm::Type *GenericVoidPtrTy = Builder.getInt8PtrTy(
4097 llvm::Type *BPP = Int8PtrPtrTy;
4176 llvm::Type *PTy = FTy->getParamType(i);
4199 llvm::Type *RetTy = VoidTy;
4355 Value *CodeGenFunction::EmitNeonShiftVector(Value *V, llvm::Type *Ty,
4363 llvm::Type *Ty, bool usgn,
5135 llvm::Type *ArgType,
5144 SmallVector<llvm::Type *, 3> Tys;
5146 llvm::Type *Ty = ConvertType(E->getCallReturnType(getContext()));
5205 llvm::Type *ArgTy = CGF.ConvertType(Arg->getType());
5212 llvm::Type *ArgTy = ai->getType();
5227 llvm::Type *ResultType = CGF.ConvertType(E->getType());
5253 llvm::Type *Ty = VTy;
5306 llvm::Type *Ty;
5319 llvm::Type *VecFlt = llvm::VectorType::get(Ty, VTy->getNumElements());
5320 llvm::Type *Tys[] = { VTy, VecFlt };
5370 llvm::Type *Tys[2] = { GetFloatNeonType(this, Type), Ty };
5387 llvm::Type *Tys[2] = { Ty, GetFloatNeonType(this, Type) };
5455 llvm::Type *Tys[2] = { Ty, GetFloatNeonType(this, Type) };
5481 llvm::Type *Tys[] = {Ty, Int8PtrTy};
5491 llvm::Type *PTy = llvm::PointerType::getUnqual(VTy->getVectorElementType());
5493 llvm::Type *Tys[2] = { VTy, PTy };
5512 llvm::Type *Tys[] = {Ty, Int8PtrTy};
5536 llvm::Type *Tys[] = {Ty, Int8PtrTy};
5547 llvm::Type *DTy =llvm::VectorType::getTruncatedElementVectorType(VTy);
5554 llvm::Type *QTy = llvm::VectorType::getExtendedElementVectorType(VTy);
5571 llvm::Type *EltTy =
5573 llvm::Type *NarrowTy =
5575 llvm::Type *Tys[2] = { Ty, NarrowTy };
5582 llvm::Type *EltTy = llvm::IntegerType::get(getLLVMContext(), EltBits / 2);
5583 llvm::Type *NarrowTy =
5585 llvm::Type *Tys[2] = { Ty, NarrowTy };
5624 llvm::Type *SrcTy = llvm::VectorType::getTruncatedElementVectorType(VTy);
5634 llvm::Type *SrcTy = llvm::VectorType::getExtendedElementVectorType(VTy);
5660 llvm::Type *Tys[] = {Int8PtrTy, Ty};
5670 llvm::Type *PTy = llvm::PointerType::getUnqual(VTy->getVectorElementType());
5674 llvm::Type *Tys[2] = { VTy, PTy };
5678 llvm::Type *Tys[2] = { PTy, VTy };
5765 llvm::Type *InputTy =
5767 llvm::Type *Tys[2] = { Ty, InputTy };
5773 llvm::Type *InputTy =
5775 llvm::Type *Tys[2] = { Ty, InputTy };
5780 llvm::Type *InputTy =
5782 llvm::Type *Tys[2] = { Ty, InputTy };
5787 llvm::Type *InputTy =
5789 llvm::Type *Tys[2] = { Ty, InputTy };
5794 llvm::Type *InputTy =
5796 llvm::Type *Tys[2] = { Ty, InputTy };
5807 llvm::Type *ResultType = ConvertType(E->getType());
5814 Value *Op, llvm::Type *Ty, const CmpInst::Predicate Fp,
5816 llvm::Type *OTy = Op->getType();
5836 llvm::Type *ResTy, unsigned IntID,
5912 llvm::Type *RegisterType,
5913 llvm::Type *ValueType,
5933 llvm::Type *Types[] = { RegisterType };
6074 llvm::Type *Ty = CGM.getTypes().ConvertType(FD->getType());
6187 llvm::Type *RealResTy = ConvertType(Ty);
6188 llvm::Type *PtrTy = llvm::IntegerType::get(
6201 llvm::Type *IntResTy = llvm::IntegerType::get(
6215 llvm::Type *STy = llvm::StructType::get(Int32Ty, Int32Ty);
6236 llvm::Type *StoreTy = llvm::IntegerType::get(getLLVMContext(),
6243 llvm::Type *IntTy = llvm::IntegerType::get(
6322 llvm::Type *ValueType;
6323 llvm::Type *RegisterType;
6445 llvm::Type *Tys[] = {Arg->getType()};
6632 llvm::Type *Ty;
6654 llvm::Type *Ty = VTy;
6682 llvm::Type *Tys[] = {Ty, Int8PtrTy};
6750 llvm::Type *Tys[] = {Int8PtrTy, Ops[1]->getType()};
6814 llvm::SmallVector<llvm::Type *, 4> Tys;
6851 llvm::SmallVector<llvm::Type *, 4> Tys;
7039 llvm::Type *VTy = llvm::VectorType::get(Int16Ty, 4);
7146 llvm::Type *Ty = CGM.getTypes().ConvertType(FD->getType());
7165 llvm::Type *Int128Ty = llvm::IntegerType::get(getLLVMContext(), 128);
7178 llvm::Type *RealResTy = ConvertType(Ty);
7179 llvm::Type *PtrTy = llvm::IntegerType::get(
7192 llvm::Type *IntResTy = llvm::IntegerType::get(
7204 llvm::Type *STy = llvm::StructType::get(Int64Ty, Int64Ty);
7225 llvm::Type *StoreTy = llvm::IntegerType::get(getLLVMContext(),
7232 llvm::Type *IntTy = llvm::IntegerType::get(
7299 llvm::Type *DataTy = F->getFunctionType()->getParamType(1);
7323 llvm::Type *T = ConvertType(E->getType());
7400 llvm::Type *ValueType;
7401 llvm::Type *RegisterType = Int64Ty;
7432 llvm::Type *RegisterType = Int64Ty;
7433 llvm::Type *Types[] = { RegisterType };
7508 llvm::Type *Int128Ty = llvm::Type::getIntNTy(getLLVMContext(), 128);
7508 llvm::Type *Int128Ty = llvm::Type::getIntNTy(getLLVMContext(), 128);
7509 llvm::Type *Int128PTy = llvm::PointerType::get(Int128Ty, 0);
7515 llvm::Type *Int128PTy = llvm::Type::getIntNPtrTy(getLLVMContext(), 128);
7515 llvm::Type *Int128PTy = llvm::Type::getIntNPtrTy(getLLVMContext(), 128);
7527 llvm::Type *InTy = Is64 ? Int64Ty : Int32Ty;
7528 llvm::Type *FTy = Is64 ? DoubleTy : FloatTy;
7542 llvm::Type *InTy = Is64 ? Int64Ty : Int32Ty;
7543 llvm::Type *FTy = Is64 ? DoubleTy : FloatTy;
7558 llvm::Type *FTy = HalfTy;
7559 llvm::Type *InTy;
7610 llvm::Type* InTy = Int32Ty;
7611 llvm::Type* FTy = HalfTy;
7612 llvm::Type *Tys[2] = {InTy, FTy};
7641 llvm::Type* InTy = Int32Ty;
7642 llvm::Type* FTy = HalfTy;
7643 llvm::Type *Tys[2] = {InTy, FTy};
7662 llvm::Type* InTy = Int32Ty;
7663 llvm::Type* FTy = HalfTy;
7664 llvm::Type *Tys[2] = {InTy, FTy};
7679 llvm::Type* FTy = HalfTy;
7680 llvm::Type* InTy = Int32Ty;
7681 llvm::Type *Tys[2] = {FTy, InTy};
7697 llvm::Type *Ty = llvm::VectorType::get(Int64Ty, 2);
7709 llvm::Type *Ty =
7722 llvm::Type *Ty =
8015 llvm::Type *VTy = llvm::VectorType::get(Int32Ty, 4);
8112 llvm::Type *VTy = llvm::VectorType::get(Int32Ty, 4);
8315 llvm::Type *Ty = VTy;
8338 llvm::Type *BitTy = llvm::VectorType::getInteger(VTy);
8360 llvm::Type *SourceTy = BuiltinID == NEON::BI__builtin_neon_vfmaq_lane_v ?
8378 llvm::Type *VTy = GetNeonType(this,
8390 llvm::Type *STy = llvm::VectorType::get(VTy->getElementType(),
8415 llvm::Type *Ty = ConvertType(E->getCallReturnType(getContext()));
8458 llvm::Type *ArgTy = llvm::VectorType::get(
8460 llvm::Type* Tys[2] = { VTy, ArgTy };
8647 llvm::Type *Tys[2] = { Ty, GetFloatNeonType(this, Type) };
8663 llvm::Type *Tys[2] = { Ty, GetFloatNeonType(this, Type) };
8679 llvm::Type *Tys[2] = { Ty, GetFloatNeonType(this, Type) };
8695 llvm::Type *Tys[2] = { Ty, GetFloatNeonType(this, Type) };
8720 llvm::Type *VTy = GetNeonType(this,
8765 llvm::Type *Tys[2] = { Ty, VTy };
8777 llvm::Type *Tys[2] = { Ty, VTy };
8789 llvm::Type *Tys[2] = { Ty, VTy };
8801 llvm::Type *Tys[2] = { Ty, VTy };
8810 llvm::Type *Tys[2] = { Ty, VTy };
8819 llvm::Type *Tys[2] = { Ty, VTy };
8828 llvm::Type *Tys[2] = { Ty, VTy };
8837 llvm::Type *Tys[2] = { Ty, VTy };
8846 llvm::Type *Tys[2] = { Ty, VTy };
8855 llvm::Type *Tys[2] = { Ty, VTy };
8864 llvm::Type *Tys[2] = { Ty, VTy };
8873 llvm::Type *Tys[2] = { Ty, VTy };
8882 llvm::Type *Tys[2] = { Ty, VTy };
8891 llvm::Type *Tys[2] = { Ty, VTy };
8900 llvm::Type *Tys[2] = { Ty, VTy };
8909 llvm::Type *Tys[2] = { Ty, VTy };
8918 llvm::Type *Tys[2] = { Ty, VTy };
8927 llvm::Type *Tys[2] = { Ty, VTy };
8936 llvm::Type *Tys[2] = { Ty, VTy };
8945 llvm::Type *Tys[2] = { Ty, VTy };
8954 llvm::Type *Tys[2] = { Ty, VTy };
8963 llvm::Type *Tys[2] = { Ty, VTy };
8972 llvm::Type *Tys[2] = { Ty, VTy };
8981 llvm::Type *Tys[2] = { Ty, VTy };
8990 llvm::Type *Tys[2] = { Ty, VTy };
8999 llvm::Type *Tys[2] = { Ty, VTy };
9008 llvm::Type *Tys[2] = { Ty, VTy };
9017 llvm::Type *Tys[2] = { Ty, VTy };
9031 llvm::Type *Tys[2] = { Ty, VTy };
9040 llvm::Type *Tys[2] = { Ty, VTy };
9048 llvm::Type *Tys[2] = { Ty, VTy };
9057 llvm::Type *Tys[2] = { Ty, VTy };
9065 llvm::Type *Tys[2] = { Ty, VTy };
9074 llvm::Type *Tys[2] = { Ty, VTy };
9082 llvm::Type *Tys[2] = { Ty, VTy };
9091 llvm::Type *Tys[2] = { Ty, VTy };
9168 llvm::Type *PTy = llvm::PointerType::getUnqual(VTy);
9170 llvm::Type *Tys[2] = { VTy, PTy };
9179 llvm::Type *PTy = llvm::PointerType::getUnqual(VTy);
9181 llvm::Type *Tys[2] = { VTy, PTy };
9190 llvm::Type *PTy = llvm::PointerType::getUnqual(VTy);
9192 llvm::Type *Tys[2] = { VTy, PTy };
9201 llvm::Type *PTy =
9204 llvm::Type *Tys[2] = { VTy, PTy };
9213 llvm::Type *PTy =
9216 llvm::Type *Tys[2] = { VTy, PTy };
9225 llvm::Type *PTy =
9228 llvm::Type *Tys[2] = { VTy, PTy };
9237 llvm::Type *Tys[2] = { VTy, Ops[1]->getType() };
9251 llvm::Type *Tys[2] = { VTy, Ops[1]->getType() };
9266 llvm::Type *Tys[2] = { VTy, Ops[1]->getType() };
9284 llvm::Type *Tys[2] = { VTy, Ops[2]->getType() };
9293 llvm::Type *Tys[2] = { VTy, Ops[3]->getType() };
9301 llvm::Type *Tys[2] = { VTy, Ops[3]->getType() };
9310 llvm::Type *Tys[2] = { VTy, Ops[4]->getType() };
9318 llvm::Type *Tys[2] = { VTy, Ops[4]->getType() };
9327 llvm::Type *Tys[2] = { VTy, Ops[5]->getType() };
9537 llvm::Type *ResultTy = Ops[1]->getType();
9538 llvm::Type *PtrTy = ResultTy->getVectorElementType();
9555 llvm::Type *ResultTy = Ops[1]->getType();
9568 llvm::Type *ResultTy = Ops[1]->getType();
9569 llvm::Type *PtrTy = ResultTy->getVectorElementType();
9599 llvm::Type *Ty = Op0->getType();
9619 llvm::Type *Ty = Op0->getType();
9748 llvm::Type *Ty = Ops[1]->getType();
9766 llvm::Type *Ty = Ops[0]->getType();
9838 llvm::Type *Ty = A->getType();
9931 llvm::Type *Ty = Ops[0]->getType();
9960 llvm::Type *Ty = Ops[0]->getType();
9987 llvm::Type *DstTy) {
10014 llvm::Type *Int32Ty = CGF.Builder.getInt32Ty();
10017 llvm::Type *ResultType = CGF.ConvertType(E->getType());
10024 llvm::Type *Int32Ty = Builder.getInt32Ty();
10032 llvm::Type *STy = llvm::StructType::get(Int32Ty, Int32Ty, Int32Ty,
10105 llvm::Type *STy = llvm::StructType::get(Int32Ty, Int32Ty, Int32Ty,
10274 llvm::Type::getX86_MMXTy(getLLVMContext()));
10406 llvm::Type *ResultType = ConvertType(E->getType());
10862 llvm::Type *DstTy = ConvertType(E->getType());
10983 llvm::Type *Ty = Ops[0]->getType();
11007 llvm::Type *Ty = Ops[0]->getType();
11037 llvm::Type *Ty = Ops[0]->getType();
11064 llvm::Type *Ty = Ops[0]->getType();
11092 llvm::Type *Ty = Ops[0]->getType();
11170 llvm::Type *Ty = Ops[0]->getType();
11234 llvm::Type *ResultType = Ops[0]->getType();
11252 llvm::Type *VecTy = llvm::VectorType::get(Int8Ty, NumElts);
11264 llvm::Type *ResultType = Ops[0]->getType();
11282 llvm::Type *VecTy = llvm::VectorType::get(Int8Ty, NumElts);
11817 llvm::Type *MMXTy = llvm::Type::getX86_MMXTy(getLLVMContext());
11817 llvm::Type *MMXTy = llvm::Type::getX86_MMXTy(getLLVMContext());
12172 llvm::Type *Int64Ty = llvm::IntegerType::get(getLLVMContext(), 64);
12182 llvm::Type *ResType = ConvertType(E->getType());
12183 llvm::Type *Int128Ty = llvm::IntegerType::get(getLLVMContext(), 128);
12219 llvm::Type *Int128Ty = Builder.getInt128Ty();
12269 llvm::Type *Int128Ty = Builder.getInt128Ty();
12270 llvm::Type *Int128PtrTy = Int128Ty->getPointerTo();
12328 llvm::Type *IntTy = ConvertType(E->getType());
12340 llvm::Type *IntTy = ConvertType(E->getType());
12530 llvm::Type *ResultType = ConvertType(E->getType());
12541 llvm::Type *ResultType = ConvertType(E->getType());
12551 llvm::Type *ResultType = ConvertType(E->getType());
12561 llvm::Type *ResultType = ConvertType(E->getType());
12569 llvm::Type *ResultType = ConvertType(E->getType());
12587 llvm::Type *ResultType = ConvertType(E->getType());
12611 llvm::Type *ResultType = ConvertType(E->getType());
12626 llvm::Type *ResultType = ConvertType(E->getType());
12845 llvm::Type *RealFlagType
13075 llvm::Type *ResultType = ConvertType(E->getType());
13085 llvm::Type *ResultType = ConvertType(E->getType());
13096 llvm::Type *ResultType = ConvertType(E->getType());
13105 llvm::Type *ResultType = ConvertType(E->getType());
13112 llvm::Type *ResultType = ConvertType(E->getType());
13121 llvm::Type *ResultType = ConvertType(E->getType());
13131 llvm::Type *ResultType = ConvertType(E->getType());
13141 llvm::Type *ResultType = ConvertType(E->getType());
13152 llvm::Type *ResultType = ConvertType(E->getType());
13159 llvm::Type *ResultType = ConvertType(E->getType());
13167 llvm::Type *ResultType = ConvertType(E->getType());
13213 llvm::Type *ResultType = ConvertType(E->getType());
13243 llvm::Type *ResultType = ConvertType(E->getType());
13275 llvm::Type *ResultType = ConvertType(E->getType());
13964 llvm::Type *ParamType = Intrinsic->getFunctionType()->getParamType(1);
14023 llvm::Type *AType = Intrinsic->getFunctionType()->getParamType(0);
14033 llvm::Type *BType = Intrinsic->getFunctionType()->getParamType(MI.NumEltsA);
14042 llvm::Type *CType =
14052 llvm::Type *DType = Dst.getElementType();
14069 llvm::Type *ResultType = ConvertType(E->getType());
14075 llvm::Type *ResultType = ConvertType(E->getType());
14108 llvm::Type *ResultType = ConvertType(E->getType());
14113 llvm::Type *ResultType = ConvertType(E->getType());
14156 llvm::Type *ResT = ConvertType(E->getType());
14166 llvm::Type *ResT = ConvertType(E->getType());
14178 llvm::Type *ResT = ConvertType(E->getType());
14190 llvm::Type *ResT = ConvertType(E->getType());
14266 llvm::Type *ElemType = ConvertType(E->getType())->getVectorElementType();
tools/clang/lib/CodeGen/CGCUDANV.cpp 37 llvm::Type *VoidTy;
173 llvm::Type *Params[] = {VoidPtrTy, SizeTy, SizeTy};
202 llvm::Type *Params[] = {RegisterGlobalsFnTy->getPointerTo(), VoidPtrTy,
331 llvm::Type *Ty = CGM.getTypes().ConvertType(CQT);
409 llvm::Type *RegisterFuncParams[] = {
439 llvm::Type *RegisterVarParams[] = {VoidPtrPtrTy, CharPtrTy, CharPtrTy,
tools/clang/lib/CodeGen/CGCXX.cpp 134 llvm::Type *AliasValueType = getTypes().GetFunctionType(AliasDecl);
248 llvm::Type *Ty,
277 llvm::Type *Ty) {
304 llvm::Type *Ty = CGM.getTypes().GetFunctionType(FInfo);
tools/clang/lib/CodeGen/CGCXXABI.cpp 35 llvm::Type *
62 llvm::Type *Ty = CGF.ConvertType(MPT->getPointeeType())
tools/clang/lib/CodeGen/CGCXXABI.h 148 virtual llvm::Type *
256 llvm::Type *StdTypeInfoPtrTy) = 0;
421 llvm::Type *Ty,
tools/clang/lib/CodeGen/CGCall.cpp 980 SmallVectorImpl<llvm::Type *>::iterator &TI) {
992 llvm::Type *EltTy = ConvertType(CExp->EltTy);
1113 static Address CreateTempAllocaForCoercion(CodeGenFunction &CGF, llvm::Type *Ty,
1133 llvm::Type *FirstElt = SrcSTy->getElementType(0);
1149 llvm::Type *SrcTy = SrcPtr.getElementType();
1164 llvm::Type *Ty,
1178 llvm::Type *DestIntTy = Ty;
1217 static llvm::Value *CreateCoercedLoad(Address Src, llvm::Type *Ty,
1219 llvm::Type *SrcTy = Src.getElementType();
1294 llvm::Type *SrcTy = Src->getType();
1295 llvm::Type *DstTy = Dst.getType()->getElementType();
1547 llvm::Type *resultType = nullptr;
1562 llvm::Type *ty = ConvertType(ret);
1566 resultType = llvm::Type::getVoidTy(getLLVMContext());
1572 resultType = llvm::Type::getVoidTy(getLLVMContext());
1581 SmallVector<llvm::Type*, 8> ArgTypes(IRFunctionArgs.totalIRArgs());
1586 llvm::Type *Ty = ConvertType(Ret);
1623 llvm::Type *LTy = ConvertTypeForMem(it->type);
1633 llvm::Type *argType = ArgInfo.getCoerceToType();
1669 llvm::Type *CodeGenTypes::GetFunctionTypeForVTable(GlobalDecl GD) {
2167 llvm::Type *varType = CGF.ConvertType(var->getType());
2236 llvm::Type* LLVMTy = CGM.getTypes().ConvertType(RetTy);
2448 llvm::Type *LTy = ConvertType(Arg->getType());
2468 llvm::Type *DstTy = Ptr.getElementType();
2522 llvm::Type *eltType = coercionType->getElementType(i);
2593 llvm::Type *resultType = result->getType();
2701 llvm::Type *resultType = result->getType();
2943 llvm::Type *returnType = RetAI.getUnpaddedCoerceAndExpandType();
3037 llvm::Type *IRTy = CGF.ConvertTypeForMem(Ty);
3038 llvm::Type *IRPtrTy = IRTy->getPointerTo();
3817 llvm::Type *TypeFromVal;
3925 llvm::Type *MemType = ConvertTypeForMem(I->Ty)->getPointerTo(AS);
4097 llvm::Type *SrcTy = Src.getType()->getElementType();
4147 llvm::Type *scalarType = RV.getScalarVal()->getType();
4167 llvm::Type *eltType = coercionType->getElementType(i);
4205 llvm::Type *LastParamTy =
4480 llvm::Type *eltType = coercionType->getElementType(i);
4509 llvm::Type *RetIRTy = ConvertType(RetTy);
tools/clang/lib/CodeGen/CGClass.cpp 187 llvm::Type *PtrDiffTy =
305 llvm::Type *BasePtrTy =
387 llvm::Type *DerivedPtrTy = ConvertType(DerivedTy)->getPointerTo(AddrSpace);
794 llvm::Type *Args[2] = {IntPtrTy, IntPtrTy};
981 llvm::Type *DBP =
982 llvm::Type::getInt8PtrTy(CGF.getLLVMContext(), DPT->getAddressSpace());
986 llvm::Type *SBP =
987 llvm::Type::getInt8PtrTy(CGF.getLLVMContext(), SPT->getAddressSpace());
1643 llvm::Type *ArgTypes[] = {CGF.VoidPtrTy, CGF.SizeTy};
2043 llvm::Type *NewType =
2313 llvm::Type *t = CGM.getTypes().ConvertType(QT);
2490 llvm::Type *VTablePtrTy =
2589 llvm::Type *VTableTy,
tools/clang/lib/CodeGen/CGCleanup.cpp 52 llvm::Type *ComplexTy =
tools/clang/lib/CodeGen/CGDecl.cpp 237 llvm::Type *LTy = getTypes().ConvertTypeForMem(Ty);
396 llvm::Type *expectedType = addr->getType();
989 llvm::Type *Ty) {
1006 llvm::Type *Int8Ty = llvm::IntegerType::getInt8Ty(CGM.getLLVMContext());
1042 llvm::Type *OrigTy = constant->getType();
1050 llvm::Type *ElemTy = STy->getElementType();
1064 auto *NewElemTy = Values[0]->getType();
1102 auto *Ty = Constant->getType();
1133 llvm::Type *BP = llvm::PointerType::getInt8PtrTy(CGM.getLLVMContext(),
1144 auto *Ty = constant->getType();
1225 llvm::Type *ElTy = Loc.getElementType();
1234 llvm::Type *ElTy = Loc.getElementType();
1242 auto *Ty = constant->getType();
1254 auto *Ty = constant->getType();
1473 llvm::Type *allocaTy;
1541 llvm::Type *llvmTy = ConvertTypeForMem(VlaSize.Type);
1704 llvm::Type *ElTy = Loc.getElementType();
1849 llvm::Type *BP = CGM.Int8Ty->getPointerTo(Loc.getAddressSpace());
2376 llvm::Type *IRTy = ConvertTypeForMem(Ty)->getPointerTo(AS);
tools/clang/lib/CodeGen/CGDeclCXX.cpp 162 llvm::Type *ObjectPtr[1] = {Int8PtrTy};
197 llvm::Type *LTy = CGM.getTypes().ConvertTypeForMem(T);
tools/clang/lib/CodeGen/CGException.cpp 249 llvm::Type::getInt8Ty(CGM.getLLVMContext()),
385 llvm::Type *ty = ConvertTypeForMem(e->getType())->getPointerTo();
1586 llvm::Type *LPadType = llvm::StructType::get(Exn->getType(), Sel->getType());
1954 llvm::Type *RecordTy = CGM.Int32Ty->getPointerTo();
1955 llvm::Type *PtrsTy = llvm::StructType::get(RecordTy, CGM.VoidPtrTy);
tools/clang/lib/CodeGen/CGExpr.cpp 56 destType = llvm::Type::getInt8PtrTy(getLLVMContext(), addressSpace);
64 Address CodeGenFunction::CreateTempAllocaWithoutCast(llvm::Type *Ty,
75 Address CodeGenFunction::CreateTempAlloca(llvm::Type *Ty, CharUnits Align,
106 llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(llvm::Type *Ty,
119 Address CodeGenFunction::CreateDefaultAlignTempAlloca(llvm::Type *Ty,
726 llvm::Type *Tys[2] = { IntPtrTy, Int8PtrTy };
811 llvm::Type *VPtrTy = llvm::PointerType::get(IntPtrTy, 0);
821 llvm::Type *HashTable = llvm::ArrayType::get(IntPtrTy, CacheSize);
1150 llvm::Type *EltTy =
1179 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
1558 llvm::Type *LTy = CGF.ConvertTypeForMem(ED->getIntegerType());
1643 const llvm::Type *EltTy = Addr.getElementType();
1724 llvm::Type *SrcTy = Value->getType();
1825 llvm::Type *ResLTy = ConvertType(LV.getType());
1885 llvm::Type *VectorElementTy = CGM.getTypes().ConvertType(EQT);
1909 llvm::Type *OrigTy = CGM.getTypes().ConvertType(LV.getType());
1910 llvm::Type *Ty = OrigTy;
1913 llvm::Type *Types[] = { Ty };
2001 llvm::Type *ResultType = IntPtrTy;
2027 llvm::Type *ResLTy = ConvertTypeForMem(Dst.getType());
2170 llvm::Type *OrigTy = CGM.getTypes().ConvertType(Dst.getType());
2171 llvm::Type *Ty = OrigTy;
2174 llvm::Type *Types[] = { Ty };
2286 llvm::Value *V, llvm::Type *IRType,
2294 llvm::Type *RealVarTy, SourceLocation Loc) {
2377 llvm::Type *RealVarTy = CGF.getTypes().ConvertTypeForMem(VD->getType());
2544 llvm::Type *VarTy = getTypes().ConvertTypeForMem(VD->getType());
2835 llvm::Type *TargetTy = IntPtrTy;
2845 V = Builder.CreateBitCast(V, llvm::Type::getIntNTy(getLLVMContext(),
3066 SmallVector<llvm::Type *, 4> ArgTypes;
3326 llvm::Type *NewTy = ConvertType(E->getType());
3550 llvm::Type *OrigBaseTy = Addr.getType();
3621 llvm::Type *NewTy = CGF.ConvertType(BaseTy);
4009 llvm::Type *FieldIntTy =
4010 llvm::Type::getIntNTy(getLLVMContext(), Info.StorageSize);
4149 llvm::Type *llvmType = ConvertTypeForMem(FieldType);
4800 llvm::Type *PrefixStructTyElems[] = {PrefixSig->getType(), Int32Ty};
4934 llvm::Type *CalleeTy = getTypes().GetFunctionType(FnInfo);
tools/clang/lib/CodeGen/CGExprCXX.cpp 106 llvm::Type *NewType = CGM.getTypes().ConvertType(DstTy);
964 const CXXNewExpr *E, QualType ElementType, llvm::Type *ElementTy,
1271 QualType ElementType, llvm::Type *ElementTy,
1691 llvm::Type *elementTy = ConvertTypeForMem(allocType);
1721 llvm::Type *resultType = ConvertTypeForMem(E->getType());
2104 llvm::Type *StdTypeInfoPtrTy) {
2144 llvm::Type *StdTypeInfoPtrTy =
2169 llvm::Type *DestLTy = CGF.ConvertType(DestTy);
tools/clang/lib/CodeGen/CGExprComplex.cpp 393 llvm::Type *EltTy =
655 static StringRef getComplexMultiplyLibCallName(llvm::Type *Ty) {
659 case llvm::Type::HalfTyID:
661 case llvm::Type::FloatTyID:
663 case llvm::Type::DoubleTyID:
665 case llvm::Type::PPC_FP128TyID:
667 case llvm::Type::X86_FP80TyID:
669 case llvm::Type::FP128TyID:
800 case llvm::Type::HalfTyID:
802 case llvm::Type::FloatTyID:
804 case llvm::Type::DoubleTyID:
806 case llvm::Type::PPC_FP128TyID:
808 case llvm::Type::X86_FP80TyID:
810 case llvm::Type::FP128TyID:
1079 llvm::Type* LTy = CGF.ConvertType(Ty);
1090 llvm::Type *EltTy =
tools/clang/lib/CodeGen/CGExprConstant.cpp 51 CharUnits getSize(llvm::Type *Ty) const {
60 llvm::Type *Ty = CGM.Int8Ty;
67 llvm::Type *Ty = llvm::ArrayType::get(CGM.Int8Ty, ZeroSize.getQuantity());
102 bool NaturalLayout, llvm::Type *DesiredTy,
121 void condense(CharUnits Offset, llvm::Type *DesiredTy);
128 llvm::Constant *build(llvm::Type *DesiredTy, bool AllowOversized) const {
384 llvm::Type *CommonElementType, unsigned ArrayBound,
391 bool NaturalLayout, llvm::Type *DesiredTy, bool AllowOversized) {
405 llvm::Type *CommonType = Elems[0]->getType();
496 llvm::Type *DesiredTy) {
622 llvm::Type *ElemTy = Emitter.CGM.getTypes().ConvertTypeForMem(ElemType);
843 llvm::Type *ValTy = CGM.getTypes().ConvertType(Type);
917 llvm::Type *CommonElementType, unsigned ArrayBound,
950 auto *FillerType =
968 llvm::SmallVector<llvm::Type *, 16> Types;
1050 SmallVector<llvm::Type*, 2> Types;
1058 llvm::Type *Ty = CGM.Int8Ty;
1075 llvm::Type *destTy = ConvertType(E->getType());
1206 llvm::Type *CommonElementType = nullptr;
1260 llvm::Type *ValTy = CGM.getTypes().ConvertType(destType);
1323 llvm::Type *ConvertType(QualType T) {
1445 llvm::Type *BaseValueTy = nullptr;
1691 llvm::Type *boolTy = CGM.getTypes().ConvertTypeForMem(destType);
1756 llvm::Constant *tryEmitAbsolute(llvm::Type *destTy);
1790 llvm::Type *origPtrTy = C->getType();
1792 llvm::Type *charPtrTy = CGM.Int8Ty->getPointerTo(AS);
1844 ConstantLValueEmitter::tryEmitAbsolute(llvm::Type *destTy) {
1891 llvm::Type *StdTypeInfoPtrTy =
2084 llvm::Type *ResultType = CGM.getTypes().ConvertType(DestType);
2119 llvm::Type *CommonElementType = nullptr;
2188 llvm::Type *baseType,
2222 llvm::Type *baseType = structure->getElementType(fieldIndex);
2261 llvm::Type *baseType = structure->getElementType(fieldIndex);
2277 llvm::Type *baseType,
tools/clang/lib/CodeGen/CGExprScalar.cpp 252 llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); }
319 llvm::Type *DstTy, SourceLocation Loc);
873 QualType DstType, llvm::Type *DstTy, SourceLocation Loc) {
945 llvm::Type *SrcTy = Src->getType();
946 llvm::Type *DstTy = Dst->getType();
1033 llvm::Type *SrcTy = Src->getType();
1034 llvm::Type *DstTy = Dst->getType();
1056 llvm::Type *VTy = V->getType();
1093 llvm::Type *SrcTy = Src->getType();
1094 llvm::Type *DstTy = Dst->getType();
1214 llvm::Type *SrcTy = Src->getType();
1220 llvm::Type *DstTy = ConvertType(DstType);
1267 llvm::Type *MiddleTy = CGF.CGM.getDataLayout().getIntPtrType(DstPT);
1308 llvm::Type *SrcElementTy = SrcTy->getVectorElementType();
1309 llvm::Type *DstElementTy = DstTy->getVectorElementType();
1333 llvm::Type *ResTy = DstTy;
1433 llvm::Type *DstIntTy = Builder.getIntNTy(DstWidth);
1469 llvm::Type *UpscaledTy = Builder.getIntNTy(ResultWidth);
1660 llvm::Type *SrcTy = Src->getType();
1661 llvm::Type *DstTy = ConvertType(DstType);
1675 llvm::Type *SrcEltTy = SrcTy->getVectorElementType(),
1758 unsigned Off, llvm::Type *I32Ty) {
1765 static llvm::Constant *getAsInt32(llvm::ConstantInt *C, llvm::Type *I32Ty) {
1922 llvm::Type *EltTy = VType->getElementType();
1995 llvm::Type *SrcTy = Src->getType();
1996 llvm::Type *DstTy = ConvertType(DestTy);
2165 llvm::Type *MiddleTy = CGF.CGM.getDataLayout().getIntPtrType(DestLLVMTy);
2200 llvm::Type *DstTy = ConvertType(DestTy);
2645 llvm::Type* ResultType = ConvertType(E->getType());
3021 llvm::Type *ValTy = Val->getType();
3084 llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty);
3121 llvm::Type *Int8Ty = CGF.Int8Ty;
3122 llvm::Type *argTypes[] = { CGF.Int64Ty, CGF.Int64Ty, Int8Ty, Int8Ty };
3981 llvm::Type *ResTy = ConvertType(E->getType());
4012 llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2,
4065 llvm::Type *ResTy = ConvertType(E->getType());
4097 llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2,
4196 llvm::Type *condType = ConvertType(condExpr->getType());
4200 llvm::Type *elemType = vecTy->getElementType();
4301 llvm::Type *ArgTy = ConvertType(VE->getType());
4359 Value *Src, llvm::Type *DstTy,
4389 llvm::Type *DstTy = ConvertType(E->getType());
4391 llvm::Type *SrcTy = Src->getType();
4582 auto *IntPtrTy = DL.getIntPtrType(GEP->getPointerOperandType());
4661 llvm::Type *PtrTy = Ptr->getType();
4677 llvm::Type *IntPtrTy = DL.getIntPtrType(PtrTy);
tools/clang/lib/CodeGen/CGGPUBuiltin.cpp 24 llvm::Type *ArgTypes[] = {llvm::Type::getInt8PtrTy(M.getContext()),
24 llvm::Type *ArgTypes[] = {llvm::Type::getInt8PtrTy(M.getContext()),
25 llvm::Type::getInt8PtrTy(M.getContext())};
27 llvm::Type::getInt32Ty(M.getContext()), ArgTypes, false);
96 BufferPtr = llvm::ConstantPointerNull::get(llvm::Type::getInt8PtrTy(Ctx));
98 llvm::SmallVector<llvm::Type *, 8> ArgTypes;
107 llvm::Type *AllocaTy = llvm::StructType::create(ArgTypes, "printf_args");
115 BufferPtr = Builder.CreatePointerCast(Alloca, llvm::Type::getInt8PtrTy(Ctx));
tools/clang/lib/CodeGen/CGLoopInfo.cpp 52 llvm::Type::getInt1Ty(Ctx), 1))}));
67 llvm::Type::getInt32Ty(Ctx), Attrs.PipelineInitiationInterval))};
122 llvm::Type::getInt32Ty(Ctx), Attrs.UnrollCount))};
185 ConstantAsMetadata::get(ConstantInt::get(llvm::Type::getInt32Ty(Ctx),
232 llvm::Type::getInt1Ty(Ctx), 0))}));
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),
295 llvm::Type::getInt1Ty(Ctx),
332 llvm::Type::getInt1Ty(Ctx), 0))}));
350 llvm::Type::getInt1Ty(Ctx),
tools/clang/lib/CodeGen/CGNonTrivialStruct.cpp 229 llvm::Type *Ty = Addr.getElementType();
529 llvm::Type *Ty = llvm::Type::getIntNTy(
529 llvm::Type *Ty = llvm::Type::getIntNTy(
tools/clang/lib/CodeGen/CGObjC.cpp 40 llvm::Type *type = addr.getElementType();
272 llvm::Type *ExpLLVMTy = CGF.ConvertType(ExpT);
635 llvm::Type *selfTy = selfAddr.getElementType();
1061 llvm::Type *bitcastType = llvm::Type::getIntNTy(getLLVMContext(), ivarSize);
1061 llvm::Type *bitcastType = llvm::Type::getIntNTy(getLLVMContext(), ivarSize);
1073 llvm::Type *retTy = ConvertType(getterMethod->getReturnType());
1077 llvm::Type *newTy = llvm::Type::getIntNTy(getLLVMContext(), retTySize);
1077 llvm::Type *newTy = llvm::Type::getIntNTy(getLLVMContext(), retTySize);
1346 llvm::Type *bitcastType =
1347 llvm::Type::getIntNTy(getLLVMContext(),
1699 llvm::Type *NSUIntegerTy = ConvertType(getContext().getNSUIntegerType());
1809 llvm::Type *convertedElementType = ConvertType(elementType);
1984 CodeGenFunction &CGF, llvm::Value *value, llvm::Type *returnType,
1996 llvm::Type *origType = returnType ? returnType : value->getType();
2018 llvm::Type *origType = addr.getElementType();
2045 llvm::Type *origType = value->getType();
2082 llvm::Type *returnType,
2100 llvm::Type *origType = returnType ? returnType : value->getType();
2373 llvm::Type *origType = value->getType();
2554 llvm::Type *resultType) {
2563 llvm::Type *resultType) {
2570 llvm::Type *resultType) {
2613 llvm::Type *returnType) {
2623 llvm::Type *returnType) {
2993 llvm::Type *resultType = CGF.ConvertType(e->getType());
3319 llvm::Value *emitBitCast(llvm::Value *value, llvm::Type *resultType) {
tools/clang/lib/CodeGen/CGObjCGNU.cpp 73 void init(CodeGenModule *Mod, const char *name, llvm::Type *RetTy,
74 Tys *... Types) {
79 SmallVector<llvm::Type *, 8> ArgTys({Types...});
166 llvm::Type *BoolTy;
324 llvm::Value* EnforceType(CGBuilderTy &B, llvm::Value *V, llvm::Type *Ty) {
328 Address EnforceType(CGBuilderTy &B, Address V, llvm::Type *Ty) {
742 llvm::Type *SlotTy;
821 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
821 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
825 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
825 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
834 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
834 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
842 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
842 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
958 SmallVector<llvm::Type *,8> Types;
1419 llvm::Constant *EnforceType(llvm::Constant *Val, llvm::Type *Ty) {
1522 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
2139 Int8Ty = llvm::Type::getInt8Ty(VMContext);
2159 Int32Ty = llvm::Type::getInt32Ty(VMContext);
2160 Int64Ty = llvm::Type::getInt64Ty(VMContext);
2204 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
2204 llvm::Type *VoidTy = llvm::Type::getVoidTy(VMContext);
2231 llvm::Type *IMPArgs[] = { IdTy, SelectorTy };
2571 llvm::Type *CastTy = llvm::StructType::get(IdTy, IdTy);
2600 llvm::Type::getInt1Ty(VMContext), IsClassMessage))};
2676 llvm::Type::getInt1Ty(VMContext), Class != nullptr))};
2741 llvm::Type *RetTy = v.getElementType();
3036 llvm::Type *T =
3539 llvm::Type *IndexTy = Int32Ty;
3616 llvm::Type *selStructPtrTy = SelectorTy;
3751 llvm::Type *moduleEltTys[] = {
3796 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
3811 llvm::Type *ArgTypes[2] = {PtrTy, PtrToInt8Ty};
4032 llvm::Type::getInt32PtrTy(VMContext), false,
tools/clang/lib/CodeGen/CGObjCMac.cpp 65 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
79 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
91 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
103 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
104 llvm::Type *longDoubleType = llvm::Type::getX86_FP80Ty(VMContext);
104 llvm::Type *longDoubleType = llvm::Type::getX86_FP80Ty(VMContext);
105 llvm::Type *resultType =
119 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
130 llvm::Type *params[] = { SuperPtrTy, SelectorPtrTy };
141 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
152 llvm::Type *params[] = { Int8PtrTy, SuperPtrTy, SelectorPtrTy };
174 llvm::Type *IvarOffsetVarTy;
188 llvm::Type *ExternalProtocolPtrTy;
191 llvm::Type *getExternalProtocolPtrTy() {
197 llvm::Type *T = Types.ConvertType(Ctx.getObjCProtoType());
228 llvm::Type *CacheTy;
364 llvm::Type *args[] = { ObjectPtrTy->getPointerTo() };
373 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
382 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
391 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
400 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo(),
410 llvm::Type *args[] = { Int8PtrTy, Int8PtrTy, LongTy };
418 llvm::Type *args[] = { ObjectPtrTy, ObjectPtrTy->getPointerTo() };
427 llvm::Type *args[] = { ObjectPtrTy };
443 llvm::Type *args[] = { ObjectPtrTy };
452 llvm::Type *args[] = { ObjectPtrTy };
553 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
561 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
569 llvm::Type *params[] = { ExceptionDataTy->getPointerTo() };
577 llvm::Type *params[] = { ClassPtrTy, ObjectPtrTy };
586 llvm::Type *params[] = { CGM.Int32Ty->getPointerTo() };
656 llvm::Type *MessageRefPtrTy;
672 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
680 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
688 llvm::Type *params[] = { ObjectPtrTy, MessageRefPtrTy };
697 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
706 llvm::Type *params[] = { SuperPtrTy, SuperMessageRefPtrTy };
718 llvm::Type *params[] = { Int8PtrTy };
735 llvm::Type *params[] = { Int8PtrPtrTy };
752 llvm::Type *EHTypePtrTy;
1808 llvm::Type *scalarTy = callResult.first->getType();
1831 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx0),
1832 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), idx1)
1957 llvm::Type *PTy = llvm::ArrayType::get(CGM.IntTy, 0);
2102 llvm::Type *ClassTy =
2605 llvm::Type *Ty = CGM.getTypes().ConvertType(QualType(RT, 0));
4010 llvm::Type *Ty = Init->getType();
4323 SmallVector<llvm::Type *, 16> tys(Locals.size());
4789 llvm::Type* DestTy = AddrWeakObj.getElementType();
4804 llvm::Type * SrcTy = src->getType();
4825 llvm::Type * SrcTy = src->getType();
4851 llvm::Type * SrcTy = src->getType();
4870 llvm::Type * SrcTy = src->getType();
5004 llvm::Type::getInt32Ty(VMContext), eImageInfo_GarbageCollected))};
5424 llvm::Type *PtrTy = CGM.Int8PtrTy;
5852 llvm::Type *StackPtrTy = llvm::ArrayType::get(CGM.Int8PtrTy, 4);
5955 llvm::Type *params[] = { ObjectPtrTy, SelectorPtrTy };
6829 llvm::Type *FieldTy =
7460 llvm::Type *ClassTy =
7516 llvm::Type * SrcTy = src->getType();
7536 llvm::Type * SrcTy = src->getType();
7568 llvm::Type *DestTy = AddrWeakObj.getElementType();
7582 llvm::Type * SrcTy = src->getType();
7603 llvm::Type * SrcTy = src->getType();
tools/clang/lib/CodeGen/CGObjCRuntime.cpp 64 llvm::Type *LTy = CGF.CGM.getTypes().ConvertTypeForMem(IvarTy);
110 llvm::Type::getIntNTy(CGF.getLLVMContext(),
257 llvm::Type *CatchType = CGF.ConvertType(CatchParam->getType());
tools/clang/lib/CodeGen/CGOpenCLRuntime.cpp 33 llvm::Type *CGOpenCLRuntime::convertOpenCLSpecificType(const Type *T) {
72 llvm::Type *CGOpenCLRuntime::getPipeType(const PipeType *T) {
79 llvm::Type *CGOpenCLRuntime::getPipeType(const PipeType *T, StringRef Name,
80 llvm::Type *&PipeTy) {
101 llvm::Type *Int32Ty = llvm::IntegerType::getInt32Ty(CGM.getLLVMContext());
111 llvm::Type *Int32Ty = llvm::IntegerType::getInt32Ty(CGM.getLLVMContext());
tools/clang/lib/CodeGen/CGOpenCLRuntime.h 38 llvm::Type *PipeROTy;
39 llvm::Type *PipeWOTy;
51 virtual llvm::Type *getPipeType(const PipeType *T, StringRef Name,
52 llvm::Type *&PipeTy);
65 virtual llvm::Type *convertOpenCLSpecificType(const Type *T);
67 virtual llvm::Type *getPipeType(const PipeType *T);
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp 1009 auto *ElemType =
1125 llvm::Type *BaseLVType, CharUnits BaseLVAlignment,
1141 llvm::Type *Ty = BaseLVType;
1280 llvm::Type *DeclTy = CGM.getTypes().GetFunctionType(FI);
1761 llvm::Type *CGOpenMPRuntime::getIdentTyPointerTy() {
1765 llvm::Type *CGOpenMPRuntime::getKmpc_MicroPointerTy() {
1768 llvm::Type *MicroParams[] = {llvm::PointerType::getUnqual(CGM.Int32Ty),
1781 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty,
1806 llvm::Type *TypeParams[] = {getIdentTyPointerTy()};
1815 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty,
1826 llvm::Type *TypeParams[] = {
1837 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty,
1853 llvm::Type *KmpcCopyCtorTyArgs[] = {CGM.VoidPtrTy, CGM.VoidPtrTy};
1862 llvm::Type *FnTyArgs[] = {getIdentTyPointerTy(), CGM.VoidPtrTy, KmpcCtorTy,
1872 llvm::Type *TypeParams[] = {
1883 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
1891 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
1899 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
1908 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty,
1918 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
1927 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
1935 llvm::Type *TypeParams[] = {getIdentTyPointerTy()};
1943 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
1951 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
1960 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty, CGM.IntTy};
1968 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
1976 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
1988 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty, CGM.Int32Ty,
2002 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty, CGM.Int32Ty,
2014 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty,
2025 llvm::Type *CpyTypeParams[] = {CGM.VoidPtrTy, CGM.VoidPtrTy};
2028 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty, CGM.SizeTy,
2040 llvm::Type *ReduceTypeParams[] = {CGM.VoidPtrTy, CGM.VoidPtrTy};
2043 llvm::Type *TypeParams[] = {
2057 llvm::Type *ReduceTypeParams[] = {CGM.VoidPtrTy, CGM.VoidPtrTy};
2060 llvm::Type *TypeParams[] = {
2072 llvm::Type *TypeParams[] = {
2083 llvm::Type *TypeParams[] = {
2095 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty,
2106 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty,
2116 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
2124 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
2132 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
2140 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
2148 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
2157 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty, CGM.IntTy};
2167 llvm::Type *TypeParams[] = {
2180 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty,
2191 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty, CGM.IntTy};
2200 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty, CGM.IntTy};
2209 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty, CGM.Int32Ty,
2219 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty,
2246 llvm::Type *TypeParams[] = {getIdentTyPointerTy(),
2265 llvm::Type *TypeParams[] = {getIdentTyPointerTy(),
2276 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
2285 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty,
2295 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty,
2305 llvm::Type *TypeParams[] = {CGM.IntTy, CGM.IntTy, CGM.VoidPtrTy};
2315 llvm::Type *TypeParams[] = {CGM.IntTy, CGM.VoidPtrTy, CGM.VoidPtrTy};
2325 llvm::Type *TypeParams[] = {CGM.IntTy, CGM.SizeTy, CGM.VoidPtrTy};
2334 llvm::Type *TypeParams[] = {CGM.IntTy, CGM.VoidPtrTy, CGM.VoidPtrTy};
2343 llvm::Type *TypeParams[] = {CGM.Int64Ty, CGM.Int64Ty};
2353 llvm::Type *TypeParams[] = {CGM.Int64Ty,
2369 llvm::Type *TypeParams[] = {CGM.Int64Ty,
2385 llvm::Type *TypeParams[] = {CGM.Int64Ty,
2403 llvm::Type *TypeParams[] = {CGM.Int64Ty,
2419 llvm::Type *TypeParams[] = {CGM.Int64Ty};
2429 llvm::Type *TypeParams[] = {CGM.getTypes().ConvertTypeForMem(ParamTy)};
2439 llvm::Type *TypeParams[] = {CGM.getTypes().ConvertTypeForMem(ParamTy)};
2448 llvm::Type *TypeParams[] = {CGM.Int64Ty,
2463 llvm::Type *TypeParams[] = {CGM.Int64Ty,
2477 llvm::Type *TypeParams[] = {CGM.Int64Ty,
2492 llvm::Type *TypeParams[] = {CGM.Int64Ty,
2506 llvm::Type *TypeParams[] = {CGM.Int64Ty,
2521 llvm::Type *TypeParams[] = {CGM.Int64Ty,
2534 llvm::Type *TypeParams[] = {CGM.VoidPtrTy};
2543 llvm::Type *TypeParams[] = {CGM.VoidPtrTy, CGM.VoidPtrTy, CGM.VoidPtrTy,
2563 llvm::Type *ITy = IVSize == 32 ? CGM.Int32Ty : CGM.Int64Ty;
2565 llvm::Type *TypeParams[] = {
2589 llvm::Type *ITy = IVSize == 32 ? CGM.Int32Ty : CGM.Int64Ty;
2590 llvm::Type *TypeParams[] = { getIdentTyPointerTy(), // loc
2611 llvm::Type *TypeParams[] = {
2628 llvm::Type *ITy = IVSize == 32 ? CGM.Int32Ty : CGM.Int64Ty;
2630 llvm::Type *TypeParams[] = {
2726 llvm::Type *VarTy = VDAddr.getElementType();
2834 llvm::Type *CopyCtorTyArgs[] = {CGM.VoidPtrTy, CGM.VoidPtrTy};
2992 llvm::Type *VarLVType = CGF.ConvertTypeForMem(VarType);
3134 llvm::Type *Ty, const llvm::Twine &Name, unsigned AddressSpace) {
3288 CodeGenModule &CGM, llvm::Type *ArgsType,
5030 llvm::Type *KmpTaskTWithPrivatesTy = CGF.ConvertType(KmpTaskTWithPrivatesQTy);
5031 llvm::Type *KmpTaskTWithPrivatesPtrTy =
5039 llvm::Type *TaskPrivatesMapTy =
5208 llvm::Type *LLVMFlagsTy = CGF.ConvertTypeForMem(FlagsTy);
5559 SourceLocation Loc, llvm::Type *ArgsType, ArrayRef<const Expr *> Privates,
tools/clang/lib/CodeGen/CGOpenMPRuntime.h 262 llvm::Type *getIdentTyPointerTy();
378 llvm::Type *KmpRoutineEntryPtrTy = nullptr;
698 llvm::Type *getKmpc_MicroPointerTy();
738 llvm::Constant *getOrCreateInternalVariable(llvm::Type *Ty,
1289 llvm::Type *ArgsType,
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp 1532 llvm::Type *TypeParams[] = {CGM.Int32Ty, CGM.Int16Ty};
1540 llvm::Type *TypeParams[] = {CGM.Int16Ty};
1549 llvm::Type *TypeParams[] = {CGM.Int32Ty, CGM.Int16Ty, CGM.Int16Ty};
1557 llvm::Type *TypeParams[] = {CGM.Int16Ty};
1566 llvm::Type *TypeParams[] = {CGM.Int8PtrTy, CGM.Int16Ty};
1575 llvm::Type *TypeParams[] = {CGM.Int8PtrPtrTy, CGM.Int16Ty};
1576 llvm::Type *RetTy = CGM.getTypes().ConvertType(CGM.getContext().BoolTy);
1592 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
1601 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
1610 llvm::Type *TypeParams[] = {CGM.Int32Ty, CGM.Int16Ty, CGM.Int16Ty};
1619 llvm::Type *TypeParams[] = {CGM.Int64Ty, CGM.Int16Ty, CGM.Int16Ty};
1631 llvm::Type *ShuffleReduceTypeParams[] = {CGM.VoidPtrTy, CGM.Int16Ty,
1636 llvm::Type *InterWarpCopyTypeParams[] = {CGM.VoidPtrTy, CGM.Int32Ty};
1640 llvm::Type *TypeParams[] = {getIdentTyPointerTy(),
1655 llvm::Type *TypeParams[] = {CGM.Int32Ty};
1674 llvm::Type *ShuffleReduceTypeParams[] = {CGM.VoidPtrTy, CGM.Int16Ty,
1679 llvm::Type *InterWarpCopyTypeParams[] = {CGM.VoidPtrTy, CGM.Int32Ty};
1683 llvm::Type *GlobalListTypeParams[] = {CGM.VoidPtrTy, CGM.IntTy,
1688 llvm::Type *TypeParams[] = {getIdentTyPointerTy(),
1723 llvm::Type *TypeParams[] = {CGM.SizeTy, CGM.Int16Ty};
1732 llvm::Type *TypeParams[] = {CGM.VoidPtrTy};
1742 llvm::Type *TypeParams[] = {CGM.Int8PtrPtrTy->getPointerTo(), CGM.SizeTy};
1757 llvm::Type *TypeParams[] = {CGM.Int8PtrPtrTy->getPointerTo()};
1765 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
1780 llvm::Type *TypeParams[] = {CGM.Int16Ty, CGM.VoidPtrTy, CGM.SizeTy,
1790 llvm::Type *TypeParams[] = {CGM.Int16Ty, CGM.Int16Ty};
1799 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
1809 llvm::Type *TypeParams[] = {getIdentTyPointerTy(), CGM.Int32Ty};
1851 llvm::ConstantInt::get(llvm::Type::getInt32Ty(Ctx), 1))};
2817 llvm::Type *LLVMCastTy = CGF.ConvertTypeForMem(CastTy);
2892 llvm::Type *IntTy = CGF.ConvertTypeForMem(IntType);
3253 llvm::Type *CopyType = CGF.ConvertTypeForMem(CType);
3664 llvm::Type *LLVMReductionsBufferTy =
3763 llvm::Type *LLVMReductionsBufferTy =
3864 llvm::Type *LLVMReductionsBufferTy =
3963 llvm::Type *LLVMReductionsBufferTy =
4519 llvm::Type *TargetType = FnType->getParamType(I);
4751 llvm::Type *VarTy = CGF.ConvertTypeForMem(VD->getType());
4763 llvm::Type *VarTy = CGF.ConvertTypeForMem(VD->getType());
4776 llvm::Type *VarTy = CGF.ConvertTypeForMem(VD->getType());
5124 llvm::Type *LLVMStaticTy = CGM.getTypes().ConvertTypeForMem(StaticTy);
5151 llvm::Type *LLVMArr2Ty = CGM.getTypes().ConvertTypeForMem(Arr2Ty);
5185 llvm::Type *LLVMReductionsBufferTy =
tools/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp 80 llvm::Type *Data;
85 MemberInfo(CharUnits Offset, InfoKind Kind, llvm::Type *Data,
88 MemberInfo(CharUnits Offset, InfoKind Kind, llvm::Type *Data,
98 MemberInfo StorageInfo(CharUnits Offset, llvm::Type *Data) {
121 llvm::Type *getIntNType(uint64_t NumBits) {
122 return llvm::Type::getIntNTy(Types.getLLVMContext(),
126 llvm::Type *getByteArrayType(CharUnits NumBytes) {
128 llvm::Type *Type = llvm::Type::getInt8Ty(Types.getLLVMContext());
128 llvm::Type *Type = llvm::Type::getInt8Ty(Types.getLLVMContext());
134 llvm::Type *getStorageType(const FieldDecl *FD) {
135 llvm::Type *Type = Types.ConvertTypeForMem(FD->getType());
142 llvm::Type *getStorageType(const CXXRecordDecl *RD) {
148 CharUnits getSize(llvm::Type *Type) {
151 CharUnits getAlignment(llvm::Type *Type) {
169 llvm::Type *StorageType);
202 SmallVector<llvm::Type *, 16> FieldTypes;
225 const FieldDecl *FD, CharUnits StartOffset, llvm::Type *StorageType) {
288 llvm::Type *StorageType = nullptr;
299 llvm::Type *FieldType = getStorageType(Field);
305 llvm::Type *FieldType = getStorageType(Field);
388 llvm::Type *Type = Types.ConvertTypeForMem(Field->getType());
468 llvm::Type *Type = getIntNType(Tail - StartBitOffset);
510 llvm::Type::getInt32PtrTy(Types.getLLVMContext())));
701 llvm::Type *Ty = Types.ConvertTypeForMem(FD->getType());
828 llvm::Type *ElementTy = ST->getTypeAtIndex(RL->getLLVMFieldNo(FD));
tools/clang/lib/CodeGen/CGStmt.cpp 1827 llvm::Type *Ty = ConvertType(InputType);
1914 const std::vector<llvm::Type *> &ResultRegTypes,
1994 std::vector<llvm::Type *> ResultRegTypes;
1995 std::vector<llvm::Type *> ResultTruncRegTypes;
1996 std::vector<llvm::Type *> ArgTypes;
2003 std::vector<llvm::Type*> InOutArgTypes;
2048 llvm::Type *ConvTy = llvm::IntegerType::get(getLLVMContext(), Size);
2075 if (llvm::Type* AdjTy =
2105 if (llvm::Type* AdjTy =
2176 llvm::Type *OutputTy = ConvertType(OutputType);
2189 if (llvm::Type* AdjTy =
2262 llvm::Type *ResultType;
2305 llvm::Type *TruncTy = ResultTruncRegTypes[i];
tools/clang/lib/CodeGen/CGStmtOpenMP.cpp 4673 llvm::Type *AddrTy = ConvertTypeForMem(AddrQTy);
tools/clang/lib/CodeGen/CGVTT.cpp 46 llvm::Type *Int8PtrTy = CGM.Int8PtrTy, *Int32Ty = CGM.Int32Ty;
tools/clang/lib/CodeGen/CGVTables.cpp 33 llvm::Constant *CodeGenModule::GetAddrOfThunk(StringRef Name, llvm::Type *FnTy,
165 llvm::Type *Ty = CGM.getTypes().GetFunctionType(FnInfo);
405 llvm::Type *ThisType = Args[ThisArgNo]->getType();
412 llvm::Type *ThisType = ThisAddr.getElementType();
452 llvm::Type *Ty;
502 llvm::Type *ThunkVTableTy = CGM.getTypes().GetFunctionTypeForVTable(GD);
714 llvm::Type *fnTy = CGM.getTypes().GetFunctionTypeForVTable(GD);
730 llvm::Type *CodeGenVTables::getVTableType(const VTableLayout &layout) {
731 SmallVector<llvm::Type *, 4> tys;
778 llvm::Type *VTType = getVTableType(*VTLayout);
tools/clang/lib/CodeGen/CGVTables.h 126 llvm::Type *getVTableType(const VTableLayout &layout);
tools/clang/lib/CodeGen/CodeGenABITypes.cpp 69 llvm::Type *T = CGM.getTypes().ConvertType(FD->getType());
77 llvm::Type *
tools/clang/lib/CodeGen/CodeGenFunction.cpp 180 llvm::Type *CodeGenFunction::ConvertTypeForMem(QualType T) {
184 llvm::Type *CodeGenFunction::ConvertType(QualType T) {
1789 llvm::Type *baseType = ConvertType(eltType);
2100 llvm::Type *VTy = V->getType();
tools/clang/lib/CodeGen/CodeGenFunction.h 1927 llvm::Value *GetVTablePtr(Address This, llvm::Type *VTableTy,
2036 llvm::Type *ConvertTypeForMem(QualType T);
2037 llvm::Type *ConvertType(QualType T);
2038 llvm::Type *ConvertType(const TypeDecl *T) {
2199 llvm::AllocaInst *CreateTempAlloca(llvm::Type *Ty, const Twine &Name = "tmp",
2201 Address CreateTempAlloca(llvm::Type *Ty, CharUnits align,
2205 Address CreateTempAllocaWithoutCast(llvm::Type *Ty, CharUnits align,
2219 Address CreateDefaultAlignTempAlloca(llvm::Type *Ty,
2562 llvm::Type *ElementTy, Address NewPtr,
3645 llvm::Type *Ty);
3732 llvm::Value *EmitAArch64CompareBuiltinExpr(llvm::Value *Op, llvm::Type *Ty,
3754 unsigned Modifier, llvm::Type *ArgTy,
3761 llvm::Value *EmitNeonShiftVector(llvm::Value *V, llvm::Type *Ty,
3764 llvm::Type *Ty, bool usgn, const char *name);
3833 llvm::Value *EmitObjCAutorelease(llvm::Value *value, llvm::Type *returnType);
3835 llvm::Type *returnType);
3846 llvm::Type *returnType);
3848 llvm::Type *returnType);
3849 llvm::Value *EmitObjCAllocInit(llvm::Value *value, llvm::Type *resultType);
tools/clang/lib/CodeGen/CodeGenModule.cpp 104 VoidTy = llvm::Type::getVoidTy(LLVMContext);
105 Int8Ty = llvm::Type::getInt8Ty(LLVMContext);
106 Int16Ty = llvm::Type::getInt16Ty(LLVMContext);
107 Int32Ty = llvm::Type::getInt32Ty(LLVMContext);
108 Int64Ty = llvm::Type::getInt64Ty(LLVMContext);
109 HalfTy = llvm::Type::getHalfTy(LLVMContext);
110 FloatTy = llvm::Type::getFloatTy(LLVMContext);
111 DoubleTy = llvm::Type::getDoubleTy(LLVMContext);
501 llvm::Type::getInt32Ty(VMContext), 1))};
669 CodeGenModule::getTBAAVTablePtrAccessInfo(llvm::Type *VTablePtrType) {
1155 llvm::Type *CtorPFTy = llvm::PointerType::get(CtorFTy,
2388 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(VD->getType());
2486 llvm::Type *Ty = getTypes().GetFunctionType(FI);
2915 llvm::Type *DeclTy = getTypes().ConvertType(FD->getType());
2924 llvm::Type *ResolverType;
3026 GlobalDecl GD, llvm::Type *DeclTy, const FunctionDecl *FD) {
3049 llvm::Type *ResolverType = llvm::FunctionType::get(
3080 StringRef MangledName, llvm::Type *Ty, GlobalDecl GD, bool ForVTable,
3262 llvm::Type *PTy = llvm::PointerType::getUnqual(Ty);
3270 llvm::Type *Ty,
3548 auto *InitType = Init->getType();
3615 StringRef Name, llvm::Type *Ty, llvm::GlobalValue::LinkageTypes Linkage,
3664 llvm::Type *Ty,
3681 CodeGenModule::CreateRuntimeVariable(llvm::Type *Ty,
3716 CharUnits CodeGenModule::GetTargetTypeStoreSize(llvm::Type *Ty) const {
3937 llvm::Type* InitType = Init->getType();
4260 llvm::Type *newRetTy = newFn->getReturnType();
4454 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
4543 llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType());
4576 ArrayRef<llvm::Type*> Tys) {
4642 llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy);
4860 llvm::Type *ElemTy = AType->getElementType();
5049 llvm::Type *Type;
5556 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
5556 llvm::Type *i64 = llvm::Type::getInt64Ty(Context);
tools/clang/lib/CodeGen/CodeGenModule.h 519 llvm::Type *BlockDescriptorType = nullptr;
520 llvm::Type *GenericBlockLiteralType = nullptr;
716 TBAAAccessInfo getTBAAVTablePtrAccessInfo(llvm::Type *VTablePtrType);
802 CreateOrReplaceCXXRuntimeVariable(StringRef Name, llvm::Type *Ty,
829 llvm::Type *Ty = nullptr,
842 llvm::Constant *GetAddrOfFunction(GlobalDecl GD, llvm::Type *Ty = nullptr,
855 llvm::Constant *GetAddrOfThunk(StringRef Name, llvm::Type *FnTy,
894 llvm::Type *getBlockDescriptorType();
897 llvm::Type *getGenericBlockLiteralType();
991 llvm::Function *getIntrinsic(unsigned IID, ArrayRef<llvm::Type*> Tys = None);
1048 llvm::Constant *CreateRuntimeVariable(llvm::Type *Ty,
1191 CharUnits GetTargetTypeStoreSize(llvm::Type *Ty) const;
1371 StringRef MangledName, llvm::Type *Ty, GlobalDecl D, bool ForVTable,
1377 llvm::Type *DeclTy,
tools/clang/lib/CodeGen/CodeGenPGO.cpp 900 auto *I8PtrTy = llvm::Type::getInt8PtrTy(CGM.getLLVMContext());
tools/clang/lib/CodeGen/CodeGenTBAA.cpp 230 TBAAAccessInfo CodeGenTBAA::getVTablePtrAccessInfo(llvm::Type *VTablePtrType) {
tools/clang/lib/CodeGen/CodeGenTBAA.h 185 TBAAAccessInfo getVTablePtrAccessInfo(llvm::Type *VTablePtrType);
tools/clang/lib/CodeGen/CodeGenTypeCache.h 34 llvm::Type *VoidTy;
39 llvm::Type *HalfTy, *FloatTy, *DoubleTy;
tools/clang/lib/CodeGen/CodeGenTypes.cpp 86 llvm::Type *CodeGenTypes::ConvertTypeForMem(QualType T) {
87 llvm::Type *R = ConvertType(T);
289 static llvm::Type *getTypeForFormat(llvm::LLVMContext &VMContext,
294 return llvm::Type::getHalfTy(VMContext);
296 return llvm::Type::getInt16Ty(VMContext);
299 return llvm::Type::getFloatTy(VMContext);
301 return llvm::Type::getDoubleTy(VMContext);
303 return llvm::Type::getFP128Ty(VMContext);
305 return llvm::Type::getPPC_FP128Ty(VMContext);
307 return llvm::Type::getX86_FP80Ty(VMContext);
311 llvm::Type *CodeGenTypes::ConvertFunctionTypeInternal(QualType QFT) {
356 llvm::Type *ResultType = nullptr;
381 llvm::Type *CodeGenTypes::ConvertType(QualType T) {
391 llvm::DenseMap<const Type *, llvm::Type *>::iterator TCI = TypeCache.find(Ty);
397 llvm::Type *ResultType = nullptr;
416 ResultType = llvm::Type::getInt8Ty(getLLVMContext());
421 ResultType = llvm::Type::getInt1Ty(getLLVMContext());
493 ResultType = llvm::Type::getInt8PtrTy(getLLVMContext());
544 llvm::Type *EltTy = ConvertType(cast<ComplexType>(Ty)->getElementType());
552 llvm::Type *PointeeType = ConvertTypeForMem(ETy);
560 llvm::Type *PointeeType = ConvertTypeForMem(ETy);
562 PointeeType = llvm::Type::getInt8Ty(getLLVMContext());
586 ResultType = llvm::Type::getInt8Ty(getLLVMContext());
593 llvm::Type *EltTy = ConvertTypeForMem(A->getElementType());
599 EltTy = llvm::Type::getInt8Ty(getLLVMContext());
624 llvm::Type *&T = InterfaceTypes[cast<ObjCInterfaceType>(Ty)];
635 llvm::Type *T =
648 ResultType = llvm::Type::getInt32Ty(getLLVMContext());
654 llvm::Type *PointeeType = CGM.getLangOpts().OpenCL
682 llvm::Type *elts[] = {
tools/clang/lib/CodeGen/CodeGenTypes.h 75 llvm::DenseMap<const ObjCInterfaceType*, llvm::Type *> InterfaceTypes;
102 llvm::DenseMap<const Type *, llvm::Type *> TypeCache;
107 llvm::Type *ConvertFunctionTypeInternal(QualType FT);
131 llvm::Type *ConvertType(QualType T);
137 llvm::Type *ConvertTypeForMem(QualType T);
158 llvm::Type *GetFunctionTypeForVTable(GlobalDecl GD);
291 SmallVectorImpl<llvm::Type *>::iterator &TI);
tools/clang/lib/CodeGen/ConstantInitBuilder.cpp 21 llvm::Type *ConstantInitFuture::getType() const {
148 ConstantAggregateBuilderBase::getAddrOfCurrentPosition(llvm::Type *type) {
182 ConstantAggregateBuilderBase::addPlaceholderWithSize(llvm::Type *type) {
230 llvm::Type *elementType = element->getType();
244 llvm::Constant *ConstantAggregateBuilderBase::finishArray(llvm::Type *eltTy) {
tools/clang/lib/CodeGen/CoverageMappingGen.cpp 1326 llvm::Type *FunctionRecordTypes[] = {
1342 llvm::ConstantExpr::getBitCast(NamePtr, llvm::Type::getInt8PtrTy(Ctx)));
1375 auto *Int32Ty = llvm::Type::getInt32Ty(Ctx);
1419 llvm::Type *CovDataHeaderTypes[] = {
1433 llvm::Type *CovDataTypes[] = {CovDataHeaderTy, RecordsTy,
1451 auto NamesArrTy = llvm::ArrayType::get(llvm::Type::getInt8PtrTy(Ctx),
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp 117 llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT) override;
182 llvm::Type *StdTypeInfoPtrTy) override;
264 Address This, llvm::Type *Ty,
548 llvm::Type *
630 llvm::Type *VTableTy = Builder.getInt8PtrTy();
802 llvm::Type *PType = CGF.ConvertTypeForMem(MPT->getPointeeType())
997 llvm::Type *Ty;
1238 llvm::Type *Args[3] = { CGM.Int8PtrTy, CGM.Int8PtrTy, CGM.Int8PtrTy };
1248 llvm::Type *SizeTy = CGF.ConvertType(getContext().getSizeType());
1285 llvm::Type *Int8PtrTy = CGF.Int8PtrTy;
1286 llvm::Type *PtrDiffTy =
1289 llvm::Type *Args[4] = { Int8PtrTy, Int8PtrTy, Int8PtrTy, PtrDiffTy };
1382 llvm::Type *StdTypeInfoPtrTy) {
1401 llvm::Type *PtrDiffLTy =
1403 llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1445 llvm::Type *PtrDiffLTy =
1447 llvm::Type *DestLTy = CGF.ConvertType(DestTy);
1757 llvm::Type *VTableType = CGM.getVTables().getVTableType(VTLayout);
1777 llvm::Type *Ty,
1925 llvm::Type *PtrDiffTy =
1979 llvm::Type *T = CGF.ReturnValue.getElementType();
2370 llvm::Type *dtorTy =
2385 llvm::Type *paramTys[] = {dtorTy, AddrInt8PtrTy, handle->getType()};
3262 llvm::Type *PtrDiffTy =
3649 llvm::Type *UnsignedIntLTy =
3694 llvm::Type *OffsetFlagsLTy =
3769 llvm::Type *UnsignedIntLTy =
3796 llvm::Type *UnsignedIntLTy =
4097 llvm::Type *LLVMCatchTy = CGF.ConvertTypeForMem(CatchType);
4140 llvm::Type *PtrTy =
4191 llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
4216 llvm::Type *PtrTy = LLVMCatchTy->getPointerTo(0); // addrspace 0 ok
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp 139 llvm::Type *StdTypeInfoPtrTy) override;
295 Address This, llvm::Type *Ty,
452 llvm::Type *FieldTypes[] = {
461 llvm::Type *getImageRelativeType(llvm::Type *PtrType) {
461 llvm::Type *getImageRelativeType(llvm::Type *PtrType) {
470 llvm::Type *FieldTypes[] = {
490 llvm::Type *FieldTypes[] = {
506 llvm::Type *FieldTypes[] = {
514 llvm::ArrayRef<llvm::Type *> FieldTypesRef(FieldTypes);
623 llvm::Type *ConvertMemberPointerType(const MemberPointerType *MPT) override;
683 llvm::Type *FieldTypes[] = {
705 llvm::Type *CTType =
707 llvm::Type *FieldTypes[] = {
719 llvm::Type *FieldTypes[] = {
733 llvm::Type *Args[] = {CGM.Int8PtrTy, getThrowInfoType()->getPointerTo()};
934 llvm::Type *ArgTypes[] = {CGF.Int8PtrTy};
952 llvm::Type *StdTypeInfoPtrTy) {
969 llvm::Type *DestLTy = CGF.ConvertType(DestTy);
988 llvm::Type *ArgTypes[] = {CGF.Int8PtrTy, CGF.Int32Ty, CGF.Int8PtrTy,
1009 llvm::Type *ArgTypes[] = {CGF.Int8PtrTy};
1500 llvm::Type *charPtrTy = CGF.Int8Ty->getPointerTo(AS),
1801 llvm::Type *VTableType = CGM.getVTables().getVTableType(VTLayout);
1859 llvm::Type *Ty,
2364 llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()),
2376 llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()),
2388 llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()),
2609 llvm::Type *
2613 llvm::SmallVector<llvm::Type *, 4> fields;
2781 llvm::Type *Ty;
3038 llvm::Type *PType =
3629 llvm::Type *PtrType = ABI.getImageRelativeType(
4178 llvm::Type *CTType =
tools/clang/lib/CodeGen/ObjectFilePCHContainerOperations.cpp 273 auto Int8Ty = llvm::Type::getInt8Ty(*VMContext);
tools/clang/lib/CodeGen/PatternInit.cpp 15 llvm::Type *Ty) {
51 llvm::Type *IntTy = llvm::IntegerType::get(CGM.getLLVMContext(), PtrWidth);
tools/clang/lib/CodeGen/PatternInit.h 22 llvm::Constant *initializationPatternFor(CodeGenModule &, llvm::Type *);
tools/clang/lib/CodeGen/SanitizerMetadata.cpp 52 llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), IsDynInit)),
54 llvm::Type::getInt1Ty(VMContext), IsBlacklisted))};
98 llvm::Type::getInt32Ty(VMContext), PLoc.getLine())),
100 llvm::Type::getInt32Ty(VMContext), PLoc.getColumn())),
tools/clang/lib/CodeGen/SwiftCallingConv.cpp 31 static llvm::Type *getCommonType(llvm::Type *first, llvm::Type *second) {
31 static llvm::Type *getCommonType(llvm::Type *first, llvm::Type *second) {
31 static llvm::Type *getCommonType(llvm::Type *first, llvm::Type *second) {
55 static CharUnits getTypeStoreSize(CodeGenModule &CGM, llvm::Type *type) {
59 static CharUnits getTypeAllocSize(CodeGenModule &CGM, llvm::Type *type) {
193 void SwiftAggLowering::addTypedData(llvm::Type *type, CharUnits begin) {
198 void SwiftAggLowering::addTypedData(llvm::Type *type,
205 SmallVector<llvm::Type*, 4> componentTys;
211 llvm::Type *componentTy = componentTys[i];
231 void SwiftAggLowering::addLegalTypedData(llvm::Type *type,
258 void SwiftAggLowering::addEntry(llvm::Type *type,
417 static bool isMergeableEntryType(llvm::Type *type) {
550 std::pair<llvm::StructType*, llvm::Type*>
561 SmallVector<llvm::Type*, 8> elts;
570 auto padding = llvm::ArrayType::get(llvm::Type::getInt8Ty(ctx),
591 llvm::Type *unpaddedType = coercionType;
622 SmallVector<llvm::Type*, 8> componentTys;
632 ArrayRef<llvm::Type*> componentTys,
644 CharUnits swiftcall::getNaturalAlignment(CodeGenModule &CGM, llvm::Type *type) {
682 llvm::Type *eltTy, unsigned numElts) {
688 std::pair<llvm::Type*, unsigned>
705 llvm::SmallVectorImpl<llvm::Type*> &components) {
tools/clang/lib/CodeGen/TargetInfo.cpp 56 llvm::Type *IntType = llvm::Type::getIntNTy(LLVMContext, Alignment);
56 llvm::Type *IntType = llvm::Type::getIntNTy(LLVMContext, Alignment);
81 llvm::Type *Padding) const {
113 ArrayRef<llvm::Type*> scalarTypes,
116 for (llvm::Type *type : scalarTypes) {
132 llvm::Type *eltTy,
226 if (llvm::Type *Ty = getCoerceToType())
289 llvm::Type *DirectTy,
356 llvm::Type *DirectTy = CGF.ConvertTypeForMem(ValueTy);
447 LangAS DestAddr, llvm::Type *DestTy, bool isNonNull) const {
460 llvm::Type *DestTy) const {
630 llvm::Type *BaseTy =
750 bool shouldPassIndirectlyForSwift(ArrayRef<llvm::Type*> scalars,
924 bool IsX86_MMXType(llvm::Type *IRType) {
931 static llvm::Type* X86AdjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
933 llvm::Type* Ty) {
943 return llvm::Type::getX86_MMXTy(CGF.getLLVMContext());
979 static ABIArgInfo getDirectX86Hva(llvm::Type* T = nullptr) {
1064 void addFieldToArgStruct(SmallVector<llvm::Type *, 6> &FrameFields,
1086 bool shouldPassIndirectlyForSwift(ArrayRef<llvm::Type*> scalars,
1125 llvm::Type* adjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
1127 llvm::Type* Ty) const override {
1133 std::vector<llvm::Type *> &ResultRegTypes,
1134 std::vector<llvm::Type *> &ResultTruncRegTypes,
1204 std::vector<llvm::Type *> &ResultRegTypes,
1205 std::vector<llvm::Type *> &ResultTruncRegTypes,
1224 llvm::Type *CoerceTy = llvm::IntegerType::get(CGF.getLLVMContext(), RetWidth);
1403 llvm::Type::getInt64Ty(getVMContext()), 2));
1677 llvm::IntegerType *Int32 = llvm::Type::getInt32Ty(LLVMContext);
1682 SmallVector<llvm::Type*, 3> Elements(SizeInRegs, Int32);
1683 llvm::Type *Result = llvm::StructType::get(LLVMContext, Elements);
1845 X86_32ABIInfo::addFieldToArgStruct(SmallVector<llvm::Type *, 6> &FrameFields,
1861 llvm::Type *Ty = llvm::Type::getInt8Ty(getVMContext());
1861 llvm::Type *Ty = llvm::Type::getInt8Ty(getVMContext());
1895 SmallVector<llvm::Type *, 6> FrameFields;
2125 llvm::Type *GetByteVectorType(QualType Ty) const;
2126 llvm::Type *GetSSETypeAtOffset(llvm::Type *IRType,
2126 llvm::Type *GetSSETypeAtOffset(llvm::Type *IRType,
2129 llvm::Type *GetINTEGERTypeAtOffset(llvm::Type *IRType,
2129 llvm::Type *GetINTEGERTypeAtOffset(llvm::Type *IRType,
2211 llvm::Type *ty = info.getCoerceToType();
2229 bool shouldPassIndirectlyForSwift(ArrayRef<llvm::Type*> scalars,
2261 bool shouldPassIndirectlyForSwift(ArrayRef<llvm::Type *> scalars,
2312 llvm::Type* adjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
2314 llvm::Type* Ty) const override {
2996 llvm::Type *X86_64ABIInfo::GetByteVectorType(QualType Ty) const {
3002 llvm::Type *IRType = CGT.ConvertType(Ty);
3010 return llvm::VectorType::get(llvm::Type::getInt64Ty(getVMContext()),
3017 if (IRType->getTypeID() == llvm::Type::FP128TyID)
3026 return llvm::VectorType::get(llvm::Type::getDoubleTy(getVMContext()),
3118 static bool ContainsFloatAtOffset(llvm::Type *IRType, unsigned IROffset,
3134 llvm::Type *EltTy = ATy->getElementType();
3146 llvm::Type *X86_64ABIInfo::
3147 GetSSETypeAtOffset(llvm::Type *IRType, unsigned IROffset,
3154 return llvm::Type::getFloatTy(getVMContext());
3161 return llvm::VectorType::get(llvm::Type::getFloatTy(getVMContext()), 2);
3163 return llvm::Type::getDoubleTy(getVMContext());
3181 llvm::Type *X86_64ABIInfo::
3182 GetINTEGERTypeAtOffset(llvm::Type *IRType, unsigned IROffset,
3223 llvm::Type *EltTy = ATy->getElementType();
3249 static llvm::Type *
3250 GetX86_64ByValArgumentPair(llvm::Type *Lo, llvm::Type *Hi,
3250 GetX86_64ByValArgumentPair(llvm::Type *Lo, llvm::Type *Hi,
3272 Lo = llvm::Type::getDoubleTy(Lo->getContext());
3276 Lo = llvm::Type::getInt64Ty(Lo->getContext());
3299 llvm::Type *ResType = nullptr;
3346 ResType = llvm::Type::getX86_FP80Ty(getVMContext());
3354 ResType = llvm::StructType::get(llvm::Type::getX86_FP80Ty(getVMContext()),
3355 llvm::Type::getX86_FP80Ty(getVMContext()));
3359 llvm::Type *HighPart = nullptr;
3433 llvm::Type *ResType = nullptr;
3487 llvm::Type *IRType = CGT.ConvertType(Ty);
3494 llvm::Type *HighPart = nullptr;
3698 llvm::Type *LTy = CGF.ConvertTypeForMem(Ty);
3788 llvm::Type *LTy = CGF.ConvertTypeForMem(Ty);
3800 llvm::Type *TyLo = ST->getElementType(0);
3801 llvm::Type *TyHi = ST->getElementType(1);
3804 llvm::Type *PTyLo = llvm::PointerType::getUnqual(TyLo);
3805 llvm::Type *PTyHi = llvm::PointerType::getUnqual(TyHi);
3861 llvm::Type *ST = AI.canHaveCoerceToType()
3985 llvm::Type *LLTy = CGT.ConvertType(Ty);
4028 llvm::VectorType::get(llvm::Type::getInt64Ty(getVMContext()), 2));
4244 llvm::Type *DirectTy = CGF.ConvertType(Ty);
4467 bool shouldPassIndirectlyForSwift(ArrayRef<llvm::Type*> scalars,
4745 llvm::Type *CoerceTy = llvm::IntegerType::get(getVMContext(), Size);
4762 llvm::Type *BaseTy = CGT.ConvertType(QualType(Base, 0));
4763 llvm::Type *CoerceTy = llvm::ArrayType::get(BaseTy, Members);
4773 llvm::Type *CoerceTy;
4785 llvm::Type *RegTy = llvm::IntegerType::get(getVMContext(), RegBits);
4817 llvm::Type *CoerceTy = llvm::IntegerType::get(getVMContext(), Size);
4828 llvm::Type *BaseTy = CGT.ConvertType(QualType(Base, 0));
4829 llvm::Type *CoerceTy = llvm::ArrayType::get(BaseTy, Members);
4839 llvm::Type *CoerceTy;
4889 llvm::Type *EltTy = CGF.ConvertTypeForMem(CTy->getElementType());
5026 bool shouldPassIndirectlyForSwift(ArrayRef<llvm::Type*> scalars,
5034 bool isLegalVectorTypeForSwift(CharUnits totalSize, llvm::Type *eltTy,
5115 llvm::Type *ResType = llvm::Type::getInt16Ty(getVMContext());
5115 llvm::Type *ResType = llvm::Type::getInt16Ty(getVMContext());
5119 llvm::Type *ResType = llvm::Type::getInt32Ty(getVMContext());
5119 llvm::Type *ResType = llvm::Type::getInt32Ty(getVMContext());
5123 llvm::Type *ResType =
5124 llvm::VectorType::get(llvm::Type::getInt32Ty(getVMContext()), 2);
5128 llvm::Type *ResType =
5129 llvm::VectorType::get(llvm::Type::getInt32Ty(getVMContext()), 4);
5164 return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
5194 llvm::Type *BaseTy = llvm::Type::getInt64Ty(getVMContext());
5194 llvm::Type *BaseTy = llvm::Type::getInt64Ty(getVMContext());
5244 llvm::Type *BaseTy = llvm::Type::getInt64Ty(getVMContext());
5244 llvm::Type *BaseTy = llvm::Type::getInt64Ty(getVMContext());
5268 llvm::Type *eltTy,
5305 llvm::Type *BaseTy = CGF.ConvertType(Ty);
5419 llvm::Type *MemTy = CGF.ConvertTypeForMem(Ty);
5437 llvm::Type *BaseTy = CGF.ConvertType(QualType(Base, 0));
5438 llvm::Type *HFATy = llvm::ArrayType::get(BaseTy, NumMembers);
5665 bool shouldPassIndirectlyForSwift(ArrayRef<llvm::Type*> scalars,
5672 bool isLegalVectorTypeForSwift(CharUnits totalSize, llvm::Type *eltTy,
5829 llvm::Type *ResType =
5830 llvm::Type::getInt32Ty(getVMContext());
5834 llvm::Type *ResType = llvm::VectorType::get(
5835 llvm::Type::getInt32Ty(getVMContext()), Size / 32);
5850 llvm::Type *NewVecTy = llvm::VectorType::get(
5851 llvm::Type::getInt32Ty(getVMContext()), Size / 32);
5852 llvm::Type *Ty = llvm::ArrayType::get(NewVecTy, Members);
5883 llvm::Type *ResType = IsAAPCS_VFP ?
5884 llvm::Type::getFloatTy(getVMContext()) :
5885 llvm::Type::getInt32Ty(getVMContext());
5922 llvm::Type *Ty =
5964 llvm::Type* ElemTy;
5969 ElemTy = llvm::Type::getInt32Ty(getVMContext());
5972 ElemTy = llvm::Type::getInt64Ty(getVMContext());
6090 llvm::Type *ResType = IsAAPCS_VFP ?
6091 llvm::Type::getFloatTy(getVMContext()) :
6092 llvm::Type::getInt32Ty(getVMContext());
6123 return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
6125 return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
6126 return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
6157 return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
6161 return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
6163 return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
6164 return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
6166 llvm::Type *Int32Ty = llvm::Type::getInt32Ty(getVMContext());
6166 llvm::Type *Int32Ty = llvm::Type::getInt32Ty(getVMContext());
6167 llvm::Type *CoerceTy =
6241 llvm::Type *eltTy,
6405 llvm::Type *IntType = llvm::Type::getIntNTy(LLVMContext, Div);
6405 llvm::Type *IntType = llvm::Type::getIntNTy(LLVMContext, Div);
6525 llvm::ConstantInt::get(llvm::Type::getInt32Ty(Ctx), Operand))};
6567 bool shouldPassIndirectlyForSwift(ArrayRef<llvm::Type*> scalars,
6689 llvm::Type *ArgTy = CGF.ConvertTypeForMem(Ty);
6690 llvm::Type *DirectTy = ArgTy;
6715 llvm::Type *IndexTy = CGF.Int64Ty;
6871 llvm::Type *PassTy;
6875 PassTy = llvm::Type::getFloatTy(getVMContext());
6877 PassTy = llvm::Type::getDoubleTy(getVMContext());
6937 SmallVectorImpl<llvm::Type *> &ArgList) const;
6938 llvm::Type* HandleAggregates(QualType Ty, uint64_t TySize) const;
6939 llvm::Type* returnAggregateInRegs(QualType RetTy, uint64_t Size) const;
6940 llvm::Type* getPaddingType(uint64_t Align, uint64_t Offset) const;
7023 uint64_t TySize, SmallVectorImpl<llvm::Type *> &ArgList) const {
7040 llvm::Type* MipsABIInfo::HandleAggregates(QualType Ty, uint64_t TySize) const {
7041 SmallVector<llvm::Type*, 8> ArgList, IntArgList;
7086 ArgList.push_back(llvm::Type::getDoubleTy(getVMContext()));
7096 llvm::Type *MipsABIInfo::getPaddingType(uint64_t OrigOffset,
7149 llvm::Type*
7152 SmallVector<llvm::Type*, 8> RTList;
7285 llvm::Type *IntTy = (OrigTy->isIntegerType() ? Temp.getElementType()
7491 return ABIArgInfo::getDirect(llvm::Type::getInt64Ty(getVMContext()));
7493 return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
7495 return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
7497 return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
7526 return ABIArgInfo::getDirect(llvm::Type::getInt8Ty(getVMContext()));
7528 return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
7530 return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
7531 return ABIArgInfo::getDirect(llvm::Type::getInt64Ty(getVMContext()));
7638 llvm::IntegerType *Int32 = llvm::Type::getInt32Ty(LLVMContext);
7639 SmallVector<llvm::Type *, 3> Elements(SizeInRegs, Int32);
7640 llvm::Type *Result = llvm::StructType::get(LLVMContext, Elements);
7789 return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
7792 return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
7795 llvm::Type *I32Ty = llvm::Type::getInt32Ty(getVMContext());
7795 llvm::Type *I32Ty = llvm::Type::getInt32Ty(getVMContext());
7860 return ABIArgInfo::getDirect(llvm::Type::getInt16Ty(getVMContext()));
7863 return ABIArgInfo::getDirect(llvm::Type::getInt32Ty(getVMContext()));
7866 llvm::Type *I32Ty = llvm::Type::getInt32Ty(getVMContext());
7866 llvm::Type *I32Ty = llvm::Type::getInt32Ty(getVMContext());
8209 SmallVector<llvm::Type*, 8> Elems;
8231 Elems.push_back(llvm::Type::getInt64Ty(Context));
8243 void addFloat(uint64_t Offset, llvm::Type *Ty, unsigned Bits) {
8259 llvm::Type *ElemTy = StrTy->getElementType(i);
8262 case llvm::Type::StructTyID:
8265 case llvm::Type::FloatTyID:
8268 case llvm::Type::DoubleTyID:
8271 case llvm::Type::FP128TyID:
8274 case llvm::Type::PointerTyID:
8293 llvm::Type *getType() const {
8343 llvm::Type *CoerceTy = CB.isUsableType(StrTy) ? StrTy : CB.getType();
8354 llvm::Type *ArgTy = CGT.ConvertType(Ty);
8362 llvm::Type *ArgPtrTy = llvm::PointerType::getUnqual(ArgTy);
8563 llvm::IntegerType *Int32 = llvm::Type::getInt32Ty(LLVMContext);
8564 SmallVector<llvm::Type *, 3> Elements(SizeInRegs, Int32);
8565 llvm::Type *Result = llvm::StructType::get(LLVMContext, Elements);
8722 llvm::Type *ArgTy = CGT.ConvertType(Ty);
8725 llvm::Type *ArgPtrTy = llvm::PointerType::getUnqual(ArgTy);
9255 llvm::Type *&Field1Ty,
9257 llvm::Type *&Field2Ty,
9277 bool detectFPCCEligibleStruct(QualType Ty, llvm::Type *&Field1Ty,
9278 CharUnits &Field1Off, llvm::Type *&Field2Ty,
9281 ABIArgInfo coerceAndExpandFPCCEligibleStruct(llvm::Type *Field1Ty,
9283 llvm::Type *Field2Ty,
9323 llvm::Type *&Field1Ty,
9325 llvm::Type *&Field2Ty,
9434 bool RISCVABIInfo::detectFPCCEligibleStruct(QualType Ty, llvm::Type *&Field1Ty,
9436 llvm::Type *&Field2Ty,
9466 llvm::Type *Field1Ty, CharUnits Field1Off, llvm::Type *Field2Ty,
9466 llvm::Type *Field1Ty, CharUnits Field1Off, llvm::Type *Field2Ty,
9468 SmallVector<llvm::Type *, 3> CoerceElts;
9469 SmallVector<llvm::Type *, 2> UnpaddedCoerceElts;
9472 llvm::Type::getInt8Ty(getVMContext()), Field1Off.getQuantity()));
9499 llvm::Type::getInt8Ty(getVMContext()), Padding.getQuantity()));
9550 llvm::Type *Field1Ty = nullptr;
9551 llvm::Type *Field2Ty = nullptr;
9892 llvm::SmallVector<llvm::Type *, 2> ArgTys;
9897 auto *FT = llvm::FunctionType::get(llvm::Type::getVoidTy(C), ArgTys, false);
9927 auto *BlockTy = BlockLiteral->getType()->getPointerElementType();
9929 llvm::SmallVector<llvm::Type *, 2> ArgTys;
9955 auto *FT = llvm::FunctionType::get(llvm::Type::getVoidTy(C), ArgTys, false);
tools/clang/lib/CodeGen/TargetInfo.h 127 virtual llvm::Type *adjustInlineAsmType(CodeGen::CodeGenFunction &CGF,
129 llvm::Type *Ty) const {
136 std::string &Constraints, std::vector<llvm::Type *> &ResultRegTypes,
137 std::vector<llvm::Type *> &ResultTruncRegTypes,
257 LangAS DestAddr, llvm::Type *DestTy,
268 llvm::Type *DestTy) const;
288 virtual llvm::SmallVector<llvm::Type *, 1> getCustomFieldTypes() = 0;
tools/clang/tools/clang-offload-wrapper/ClangOffloadWrapper.cpp 74 switch (M.getDataLayout().getPointerTypeSize(Type::getInt8PtrTy(C))) {
76 return Type::getInt32Ty(C);
78 return Type::getInt64Ty(C);
92 EntryTy = StructType::create("__tgt_offload_entry", Type::getInt8PtrTy(C),
93 Type::getInt8PtrTy(C), getSizeTTy(),
94 Type::getInt32Ty(C), Type::getInt32Ty(C));
94 Type::getInt32Ty(C), Type::getInt32Ty(C));
108 ImageTy = StructType::create("__tgt_device_image", Type::getInt8PtrTy(C),
109 Type::getInt8PtrTy(C), getEntryPtrTy(),
126 DescTy = StructType::create("__tgt_bin_desc", Type::getInt32Ty(C),
239 ConstantInt::get(Type::getInt32Ty(C), ImagesInits.size()), ImagesB,
248 auto *FuncTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg*/ false);
254 auto *RegFuncTy = FunctionType::get(Type::getVoidTy(C), getBinDescPtrTy(),
269 auto *FuncTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg*/ false);
275 auto *UnRegFuncTy = FunctionType::get(Type::getVoidTy(C), getBinDescPtrTy(),
tools/clang/unittests/CodeGen/CodeGenExternalTest.cpp 195 llvm::Type *llvmTy = CodeGen::convertTypeForMemory(CGM, qType);
227 llvm::Type* xTy = structTy->getTypeAtIndex(x);
228 llvm::Type* yTy = structTy->getTypeAtIndex(y);
229 llvm::Type* zTy = structTy->getTypeAtIndex(z);
tools/clang/unittests/CodeGen/IRMatchers.h 61 PointerUnion3<const Value *, const Metadata *, const Type *> Entity;
67 Query(const Type *T, unsigned N) : Entity(T), OperandNo(N) {}
70 const T *get() const {
71 return Entity.dyn_cast<const T *>();
78 void push(const T *V, unsigned N = ~0) {
85 const T *top() const { return MatchStack.back().get<T>(); }
85 const T *top() const { return MatchStack.back().get<T>(); }
124 if (auto V = MC.top<T>())
128 virtual bool matchEntity(const T &M, MatcherContext &C) = 0;
145 class CondMatcher : public EntityMatcher<T> {
146 std::function<bool(const T &)> Condition;
148 CondMatcher(std::function<bool(const T &)> C) : Condition(C) {}
149 bool matchEntity(const T &V, MatcherContext &C) override {
295 std::shared_ptr<EntityMatcher<Type>> TyM;
297 ValueTypeMatcher(std::shared_ptr<EntityMatcher<Type>> T) : TyM(T) {}
298 ValueTypeMatcher(const Type *T)
299 : TyM(new CondMatcher<Type>([T](const Type &Ty) -> bool {
303 Type *Ty = V.getType();
375 MValType(std::shared_ptr<EntityMatcher<Type>> T) {
379 inline std::shared_ptr<EntityMatcher<Value>> MValType(const Type *T) {
383 inline std::shared_ptr<EntityMatcher<Type>>
384 MType(std::function<bool(const Type &)> C) {
385 return std::shared_ptr<EntityMatcher<Type>>(new CondMatcher<Type>(C));
tools/clang/unittests/CodeGen/TBAAMetadataTest.cpp 184 MValType(Type::getInt8PtrTy(Compiler.Context)),
196 MValType(Type::getInt32PtrTy(Compiler.Context)),
tools/lldb/include/lldb/Target/ABI.h 62 llvm::Type &prototype,
71 lldb::ValueObjectSP GetReturnValueObject(Thread &thread, llvm::Type &type,
87 GetReturnValueObjectImpl(Thread &thread, llvm::Type &ir_type) const;
tools/lldb/include/lldb/Target/ThreadPlanCallFunctionUsingABI.h 33 llvm::Type &function_prototype,
34 llvm::Type &return_type,
46 llvm::Type &m_return_type;
tools/lldb/source/Expression/IRInterpreter.cpp 62 static std::string PrintType(const Type *type, bool truncate = false) {
151 Type *type) {
285 Type *src_elem_ty =
378 lldb::addr_t Malloc(llvm::Type *type) {
385 std::string PrintData(lldb::addr_t addr, llvm::Type *type) {
599 Type *operand_type = operand->getType();
604 case Type::VectorTyID: {
832 Type *T = alloca_inst->getAllocatedType();
833 Type *Tptr = alloca_inst->getType();
1020 Type *src_elem_ty = gep_inst->getSourceElementType();
1286 Type *pointer_ty = pointer_operand->getType();
1294 Type *target_ty = pointer_ptr_ty->getElementType();
1378 Type *pointer_ty = pointer_operand->getType();
1382 Type *target_ty = pointer_ptr_ty->getElementType();
1458 llvm::Type *returnType = call_inst->getType();
1502 llvm::Type *prototype = val->getType();
1533 llvm::Type *arg_ty = arg_op->getType();
tools/lldb/source/Plugins/ABI/SysV-arc/ABISysV_arc.cpp 196 addr_t ra, llvm::Type &prototype,
510 llvm::Type &retType) const {
tools/lldb/source/Plugins/ABI/SysV-arc/ABISysV_arc.h 34 llvm::Type &prototype,
50 llvm::Type &type) const override;
tools/lldb/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp 1064 llvm::Type &prototype, llvm::ArrayRef<ABI::CallArgument> args) const {
1308 llvm::Type &retType) const {
tools/lldb/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.h 31 llvm::Type &prototype,
47 llvm::Type &type) const override;
tools/lldb/source/Plugins/ExpressionParser/Clang/IRDynamicChecks.cpp 241 llvm::Type *param_array[1];
245 ArrayRef<llvm::Type *> params(param_array, 1);
248 llvm::Type::getVoidTy(m_module.getContext()), params, true);
264 llvm::Type *param_array[2];
269 ArrayRef<llvm::Type *> params(param_array, 2);
272 llvm::Type::getVoidTy(m_module.getContext()), params, true);
281 m_i8ptr_ty = llvm::Type::getInt8PtrTy(m_module.getContext());
290 m_intptr_ty = llvm::Type::getIntNTy(m_module.getContext(),
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp 98 static std::string PrintType(const llvm::Type *type, bool truncate = false) {
357 ConstantInt::get(llvm::Type::getInt64Ty(m_module->getContext()),
419 Type *ns_str_ty = ns_str->getType();
421 Type *i8_ptr_ty = Type::getInt8PtrTy(m_module->getContext());
421 Type *i8_ptr_ty = Type::getInt8PtrTy(m_module->getContext());
422 Type *i32_ty = Type::getInt32Ty(m_module->getContext());
422 Type *i32_ty = Type::getInt32Ty(m_module->getContext());
423 Type *i8_ty = Type::getInt8Ty(m_module->getContext());
423 Type *i8_ty = Type::getInt8Ty(m_module->getContext());
466 Type *arg_type_array[5];
474 ArrayRef<Type *> CFSCWB_arg_types(arg_type_array, 5);
852 Type *sel_ptr_type = Type::getInt8PtrTy(m_module->getContext());
852 Type *sel_ptr_type = Type::getInt8PtrTy(m_module->getContext());
854 Type *type_array[1];
856 type_array[0] = llvm::Type::getInt8PtrTy(m_module->getContext());
858 ArrayRef<Type *> srN_arg_types(type_array, 1);
874 _objc_meth_var_name_, Type::getInt8PtrTy(m_module->getContext()));
1005 Type *class_type = load->getType();
1006 Type *type_array[1];
1007 type_array[0] = llvm::Type::getInt8PtrTy(m_module->getContext());
1009 ArrayRef<Type *> ogC_arg_types(type_array, 1);
1025 _objc_class_name_, Type::getInt8PtrTy(m_module->getContext()));
1231 const Type *value_type = nullptr;
1296 Type *symbol_type = symbol->getType();
1751 IntegerType *offset_type(Type::getInt32Ty(context));
1849 m_intptr_ty = llvm::Type::getIntNTy(m_module->getContext(),
1885 llvm::Type *int8_ty = Type::getInt8Ty(m_module->getContext());
1885 llvm::Type *int8_ty = Type::getInt8Ty(m_module->getContext());
tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp 62 bool isRSAllocationPtrTy(const llvm::Type *type) {
100 std::vector<llvm::Type *> new_params{num_params + 1, nullptr};
101 std::vector<llvm::Type *> params{orig_type->param_begin(),
tools/lldb/source/Target/ThreadPlanCallFunctionUsingABI.cpp 24 Thread &thread, const Address &function, llvm::Type &prototype,
25 llvm::Type &return_type, llvm::ArrayRef<ABI::CallArgument> args,
tools/lli/lli.cpp 315 Type *ReturnTy;
317 ReturnTy = Type::getInt64Ty(Context);
319 ReturnTy = Type::getInt32Ty(Context);
597 "exit", Type::getVoidTy(Context), Type::getInt32Ty(Context));
597 "exit", Type::getVoidTy(Context), Type::getInt32Ty(Context));
tools/llvm-exegesis/lib/Assembler.cpp 76 Type *const ReturnType = Type::getInt32Ty(Module->getContext());
76 Type *const ReturnType = Type::getInt32Ty(Module->getContext());
77 Type *const MemParamType = PointerType::get(
78 Type::getInt8Ty(Module->getContext()), 0 /*default address space*/);
tools/llvm-isel-fuzzer/llvm-isel-fuzzer.cpp 54 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
54 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
54 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
54 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
55 Type::getInt64Ty, Type::getFloatTy, Type::getDoubleTy};
55 Type::getInt64Ty, Type::getFloatTy, Type::getDoubleTy};
55 Type::getInt64Ty, Type::getFloatTy, Type::getDoubleTy};
tools/llvm-opt-fuzzer/llvm-opt-fuzzer.cpp 39 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
39 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
39 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
39 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
40 Type::getInt64Ty, Type::getFloatTy, Type::getDoubleTy};
40 Type::getInt64Ty, Type::getFloatTy, Type::getDoubleTy};
40 Type::getInt64Ty, Type::getFloatTy, Type::getDoubleTy};
tools/llvm-stress/llvm-stress.cpp 71 template <> class parser<Type*> final : public basic_parser<Type*> {
76 bool parse(Option &O, StringRef, StringRef Arg, Type *&Value) {
77 if (Arg == "half") Value = Type::getHalfTy(Context);
78 else if (Arg == "fp128") Value = Type::getFP128Ty(Context);
79 else if (Arg == "x86_fp80") Value = Type::getX86_FP80Ty(Context);
80 else if (Arg == "ppc_fp128") Value = Type::getPPC_FP128Ty(Context);
81 else if (Arg == "x86_mmx") Value = Type::getX86_MMXTy(Context);
86 Value = Type::getIntNTy(Context, N);
99 static cl::list<Type*> AdditionalScalarTypes("types", cl::CommaSeparated,
157 Type* ArgsTy[] = {
158 Type::getInt8PtrTy(Context),
159 Type::getInt32PtrTy(Context),
160 Type::getInt64PtrTy(Context),
161 Type::getInt32Ty(Context),
162 Type::getInt64Ty(Context),
163 Type::getInt8Ty(Context)
166 auto *FuncTy = FunctionType::get(Type::getVoidTy(Context), ArgsTy, false);
209 Constant *getRandomConstant(Type *Tp) {
223 Value *getRandomValue(Type *Tp) {
278 Type *pickType() {
283 Type *pickPointerType() {
284 Type *Ty = pickType();
289 Type *pickVectorType(unsigned len = (unsigned)-1) {
294 Type *Ty;
307 Type *pickScalarType() {
308 static std::vector<Type*> ScalarTypes;
311 Type::getInt1Ty(Context),
312 Type::getInt8Ty(Context),
313 Type::getInt16Ty(Context),
314 Type::getInt32Ty(Context),
315 Type::getInt64Ty(Context),
316 Type::getFloatTy(Context),
317 Type::getDoubleTy(Context)
360 Type *ValTy = Val->getType();
420 Type *Ty = pickType();
471 Type *Tp = pickType();
485 ConstantInt::get(Type::getInt32Ty(BB->getContext()),
503 Type *I32 = Type::getInt32Ty(BB->getContext());
503 Type *I32 = Type::getInt32Ty(BB->getContext());
529 ConstantInt::get(Type::getInt32Ty(BB->getContext()),
542 Type *VTy = V->getType();
543 Type *DestTy = pickScalarType();
625 Type *CondTy = Type::getInt1Ty(Context);
625 Type *CondTy = Type::getInt1Ty(Context);
tools/opt/Debugify.cpp 42 uint64_t getAllocSizeInBits(Module &M, Type *Ty) {
151 auto *IntTy = Type::getInt32Ty(Ctx);
185 Type *Ty = V->getType();
tools/polly/include/polly/CodeGen/BlockGenerators.h 509 __isl_take isl_id *Id, Type *ExpectedType);
665 Type *getVectorPtrTy(const Value *V, int Width);
tools/polly/include/polly/CodeGen/IslExprBuilder.h 140 llvm::Type *getWidestType(llvm::Type *T1, llvm::Type *T2);
140 llvm::Type *getWidestType(llvm::Type *T1, llvm::Type *T2);
140 llvm::Type *getWidestType(llvm::Type *T1, llvm::Type *T2);
tools/polly/include/polly/CodeGen/IslNodeBuilder.h 291 SmallSet<std::pair<const SCEV *, Type *>, 16> PreloadedPtrs;
tools/polly/include/polly/CodeGen/LoopGenerators.h 118 Type::getIntNTy(Builder.getContext(), DL.getPointerSizeInBits())),
155 Type *LongType;
174 void extractValuesFromStruct(SetVector<Value *> Values, Type *Ty,
tools/polly/include/polly/CodeGen/RuntimeDebugBuilder.h 52 static bool isPrintable(llvm::Type *Ty);
tools/polly/include/polly/ScopBuilder.h 545 Value *BaseAddress, Type *ElemType, bool Affine,
566 Type *ElemType, bool IsAffine,
tools/polly/include/polly/ScopInfo.h 224 ScopArrayInfo(Value *BasePtr, Type *ElementType, isl::ctx IslCtx,
239 void updateElementType(Type *NewElementType);
313 Type *getElementType() const { return ElementType; }
407 Type *ElementType;
548 Type *ElementType;
721 Value *BaseAddress, Type *ElemType, bool Affine,
874 Type *getElementType() const { return ElementType; }
1140 Type *AccessType;
2486 ScopArrayInfo *getOrCreateScopArrayInfo(Value *BasePtr, Type *ElementType,
2496 ScopArrayInfo *createScopArrayInfo(Type *ElementType,
tools/polly/include/polly/Support/SCEVAffinator.h 82 isl::pw_aff addModuloSemantic(isl::pw_aff PWA, llvm::Type *ExprType) const;
tools/polly/include/polly/Support/ScopHelper.h 349 const llvm::SCEV *E, llvm::Type *Ty,
tools/polly/lib/Analysis/ScopBuilder.cpp 806 DenseMap<std::pair<const SCEV *, Type *>, LoadInst *> EquivClasses;
812 Type *Ty = LInst->getType();
1334 Type *Ty = PTy->getElementType();
1347 const ArrayRef<Type *> ArrMemberTys = StructArrTy->elements();
1350 if (ArrMemberTys[0] != Type::getInt8PtrTy(V->getContext()))
1355 Type *IntTy = ArrMemberTys[1];
1602 Type *ElementType = Val->getType();
1613 auto *SrcTy = Src->getType();
1614 auto *DstTy = BitCast->getType();
1679 Type *ElementType = Val->getType();
1845 Type *ElementType = Val->getType();
2264 Value *BaseAddress, Type *ElementType, bool Affine, Value *AccessValue,
2302 Value *BaseAddress, Type *ElementType,
3020 Type *Ty = LInst->getType();
3205 Type *ElementType = Access->getElementType();
tools/polly/lib/Analysis/ScopDetection.cpp 1080 auto *SizeTy =
tools/polly/lib/Analysis/ScopInfo.cpp 223 ScopArrayInfo::ScopArrayInfo(Value *BasePtr, Type *ElementType, isl::ctx Ctx,
277 void ScopArrayInfo::updateElementType(Type *NewElementType) {
887 Type *ElementType, bool Affine,
1802 Type *Ty = LInst->getType();
1817 ScopArrayInfo *Scop::getOrCreateScopArrayInfo(Value *BasePtr, Type *ElementType,
1841 ScopArrayInfo *Scop::createScopArrayInfo(Type *ElementType,
1844 auto *DimSizeType = Type::getInt64Ty(getSE()->getContext());
tools/polly/lib/CodeGen/BlockGenerators.cpp 269 Type *ExpectedType) {
504 Type *Ty = Array->getElementType();
1039 Type *VectorBlockGenerator::getVectorPtrTy(const Value *Val, int Width) {
1043 Type *ScalarType = PointerTy->getElementType();
1054 Type *VectorPtrType = getVectorPtrTy(Pointer, VectorWidth);
1083 Type *VectorPtrType = getVectorPtrTy(Pointer, 1);
1203 Type *VectorPtrType = getVectorPtrTy(Pointer, getVectorWidth());
1341 Type *VectorPtrType = getVectorPtrTy(Address, 1);
tools/polly/lib/CodeGen/IRBuilder.cpp 131 auto *FalseValue = ConstantInt::get(Type::getInt1Ty(Ctx), 0);
tools/polly/lib/CodeGen/IslExprBuilder.cpp 164 Type *IslExprBuilder::getWidestType(Type *T1, Type *T2) {
164 Type *IslExprBuilder::getWidestType(Type *T1, Type *T2) {
164 Type *IslExprBuilder::getWidestType(Type *T1, Type *T2) {
178 Type *MaxType = getType(Expr);
214 Type *Ty = getWidestType(V->getType(), OpV->getType());
299 Type *Ty = getWidestType(NextIndex->getType(), IndexOp->getType());
323 Type *Ty = getWidestType(DimSize->getType(), IndexOp->getType());
350 Type *MaxType;
363 Type *LHSType = LHS->getType();
364 Type *RHSType = RHS->getType();
459 Type *MaxType = getType(Expr);
499 auto *LHSTy = LHS->getType();
500 auto *RHSTy = RHS->getType();
511 Type *MaxType = LHS->getType();
tools/polly/lib/CodeGen/IslNodeBuilder.cpp 444 Type *MaxType = ExprBuilder.getType(Iterator);
516 Type *MaxType;
622 Type *MaxType;
1152 Type *endType = dyn_cast<IntegerType>(end->getType());
1208 Type *Ty = AccInst->getType();
1245 Type *AccInstTy = AccInst->getType();
1378 Type *AccInstTy = AccInst->getType();
1453 Type *NewArrayType = nullptr;
1483 ConstantInt::get(Type::getInt64Ty(Ctx), Size),
1484 ConstantInt::get(Type::getInt64Ty(Ctx), ArraySizeInt), nullptr,
tools/polly/lib/CodeGen/LoopGenerators.cpp 219 SmallVector<Type *, 8> Members;
245 SetVector<Value *> OldValues, Type *Ty, Value *Struct, ValueMapT &Map) {
tools/polly/lib/CodeGen/LoopGeneratorsGOMP.cpp 32 Type *Params[] = {PointerType::getUnqual(FunctionType::get(
181 Type *Params[] = {LongType->getPointerTo(), LongType->getPointerTo()};
tools/polly/lib/CodeGen/LoopGeneratorsKMP.cpp 26 Type *KMPCMicroTy = M->getTypeByName("kmpc_micro");
30 Type *MicroParams[] = {Builder.getInt32Ty()->getPointerTo(),
41 Type *Params[] = {IdentTy->getPointerTo(), Builder.getInt32Ty(),
77 std::vector<Type *> Arguments = {Builder.getInt32Ty()->getPointerTo(),
281 Type *Params[] = {IdentTy->getPointerTo()};
300 Type *Params[] = {IdentTy->getPointerTo(), Builder.getInt32Ty(),
326 Type *Params[] = {IdentTy->getPointerTo(),
364 Type *Params[] = {IdentTy->getPointerTo(), Builder.getInt32Ty()};
387 Type *Params[] = {IdentTy->getPointerTo(),
427 Type *Params[] = {IdentTy->getPointerTo(),
457 Type *LocMembers[] = {Builder.getInt32Ty(), Builder.getInt32Ty(),
tools/polly/lib/CodeGen/RuntimeDebugBuilder.cpp 104 bool RuntimeDebugBuilder::isPrintable(Type *Ty) {
123 Type *Ty = Val->getType();
196 Type *Ty = Val->getType();
tools/polly/lib/Exchange/JSONExporter.cpp 598 static Type *parseTextType(const std::string &TypeTextRepresentation,
600 std::map<std::string, Type *> MapStrToType = {
601 {"void", Type::getVoidTy(LLVMContext)},
602 {"half", Type::getHalfTy(LLVMContext)},
603 {"float", Type::getFloatTy(LLVMContext)},
604 {"double", Type::getDoubleTy(LLVMContext)},
605 {"x86_fp80", Type::getX86_FP80Ty(LLVMContext)},
606 {"fp128", Type::getFP128Ty(LLVMContext)},
607 {"ppc_fp128", Type::getPPC_FP128Ty(LLVMContext)},
608 {"i1", Type::getInt1Ty(LLVMContext)},
609 {"i8", Type::getInt8Ty(LLVMContext)},
610 {"i16", Type::getInt16Ty(LLVMContext)},
611 {"i32", Type::getInt32Ty(LLVMContext)},
612 {"i64", Type::getInt64Ty(LLVMContext)},
613 {"i128", Type::getInt128Ty(LLVMContext)}};
654 auto *ElementType = parseTextType(
tools/polly/lib/Support/SCEVAffinator.cpp 154 Type *ExprType) const {
555 return visit(SE.getZero(Type::getInt32Ty(S->getFunction().getContext())));
tools/polly/lib/Support/ScopHelper.cpp 239 Value *expandCodeFor(const SCEV *E, Type *Ty, Instruction *I) {
395 const char *Name, const SCEV *E, Type *Ty,
453 return ConstantInt::getTrue(Type::getInt1Ty(TI->getContext()));
666 Type *Ty = GEP->getPointerOperandType();
tools/polly/lib/Transform/ZoneAlgo.cpp 436 Type *Ty = MA->getLatestScopArrayInfo()->getElementType();
unittests/Analysis/AliasAnalysisTest.cpp 169 FunctionType::get(Type::getVoidTy(C), std::vector<Type *>(), false);
172 auto IntType = Type::getInt32Ty(C);
173 auto PtrType = Type::getInt32PtrTy(C);
unittests/Analysis/CGSCCPassManagerTest.cpp 1173 Type::getInt8PtrTy(H2F.getContext()),
unittests/Analysis/DivergenceAnalysisTest.cpp 80 FunctionType::get(Type::getVoidTy(Context), {IntTy}, false);
unittests/Analysis/MemoryBuiltinsTest.cpp 26 IntegerType *ArgTy = Type::getInt32Ty(Context);
29 FunctionType::get(Type::getInt8PtrTy(Context), {ArgTy}, false),
unittests/Analysis/MemorySSATest.cpp 600 Type *Int8 = Type::getInt8Ty(C);
600 Type *Int8 = Type::getInt8Ty(C);
631 Type *Int8 = Type::getInt8Ty(C);
631 Type *Int8 = Type::getInt8Ty(C);
661 Type *Int8 = Type::getInt8Ty(C);
661 Type *Int8 = Type::getInt8Ty(C);
705 Type *Int8 = Type::getInt8Ty(C);
705 Type *Int8 = Type::getInt8Ty(C);
713 B.CreateCondBr(UndefValue::get(Type::getInt1Ty(C)), IfThen, IfEnd);
769 Type *Int8 = Type::getInt8Ty(C);
769 Type *Int8 = Type::getInt8Ty(C);
798 Type *Int8 = Type::getInt8Ty(C);
798 Type *Int8 = Type::getInt8Ty(C);
830 Type *Int8 = Type::getInt8Ty(C);
830 Type *Int8 = Type::getInt8Ty(C);
1007 Type *Int8 = Type::getInt8Ty(C);
1007 Type *Int8 = Type::getInt8Ty(C);
1050 Type *Int8 = Type::getInt8Ty(C);
1050 Type *Int8 = Type::getInt8Ty(C);
1101 Type *Int8 = Type::getInt8Ty(C);
1101 Type *Int8 = Type::getInt8Ty(C);
1143 Type *Int8 = Type::getInt8Ty(C);
1143 Type *Int8 = Type::getInt8Ty(C);
1288 Type *Int8 = Type::getInt8Ty(C);
1288 Type *Int8 = Type::getInt8Ty(C);
1338 Type *Int8 = Type::getInt8Ty(C);
1338 Type *Int8 = Type::getInt8Ty(C);
1471 Type *Int8 = Type::getInt8Ty(C);
1471 Type *Int8 = Type::getInt8Ty(C);
unittests/Analysis/OrderedInstructionsTest.cpp 27 FunctionType::get(Type::getVoidTy(Ctx), {B.getInt8PtrTy()}, false);
unittests/Analysis/PhiValuesTest.cpp 23 Type *VoidTy = Type::getVoidTy(C);
23 Type *VoidTy = Type::getVoidTy(C);
24 Type *I1Ty = Type::getInt1Ty(C);
24 Type *I1Ty = Type::getInt1Ty(C);
25 Type *I32Ty = Type::getInt32Ty(C);
25 Type *I32Ty = Type::getInt32Ty(C);
26 Type *I32PtrTy = Type::getInt32PtrTy(C);
26 Type *I32PtrTy = Type::getInt32PtrTy(C);
90 Type *VoidTy = Type::getVoidTy(C);
90 Type *VoidTy = Type::getVoidTy(C);
91 Type *I1Ty = Type::getInt1Ty(C);
91 Type *I1Ty = Type::getInt1Ty(C);
92 Type *I32Ty = Type::getInt32Ty(C);
92 Type *I32Ty = Type::getInt32Ty(C);
93 Type *I32PtrTy = Type::getInt32PtrTy(C);
93 Type *I32PtrTy = Type::getInt32PtrTy(C);
unittests/Analysis/ScalarEvolutionTest.cpp 69 FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context),
75 Type *Ty = Type::getInt1Ty(Context);
75 Type *Ty = Type::getInt1Ty(Context);
118 FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context),
125 BranchInst::Create(LoopBB, ExitBB, UndefValue::get(Type::getInt1Ty(Context)),
128 auto *Ty = Type::getInt32Ty(Context);
148 auto *I8Ty = Type::getInt8Ty(Context);
149 auto *I8PtrTy = Type::getInt8PtrTy(Context);
150 auto *I32Ty = Type::getInt32Ty(Context);
151 auto *I32PtrTy = Type::getInt32PtrTy(Context);
153 FunctionType::get(Type::getVoidTy(Context), std::vector<Type *>(), false);
174 LoopBB, ExitBB, UndefValue::get(Type::getInt1Ty(Context)), LoopBB);
336 FunctionType::get(Type::getVoidTy(Context), std::vector<Type *>(), false);
342 auto *Ty = Type::getInt32Ty(Context);
383 BranchInst::Create(LoopBB, ExitBB, UndefValue::get(Type::getInt1Ty(Context)),
406 FunctionType::get(Type::getVoidTy(Context), {IntPtrTy, IntPtrTy}, false);
440 Type *Ty32 = Type::getInt32Ty(Context);
440 Type *Ty32 = Type::getInt32Ty(Context);
441 Type *ArgTys[] = {Type::getInt64Ty(Context), Ty32};
441 Type *ArgTys[] = {Type::getInt64Ty(Context), Ty32};
444 FunctionType::get(Type::getVoidTy(Context), ArgTys, false);
678 FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), {}, false);
687 Type *I64Ty = Type::getInt64Ty(Context);
687 Type *I64Ty = Type::getInt64Ty(Context);
688 Type *I8Ty = Type::getInt8Ty(Context);
688 Type *I8Ty = Type::getInt8Ty(Context);
689 Type *I8PtrTy = Type::getInt8PtrTy(Context);
689 Type *I8PtrTy = Type::getInt8PtrTy(Context);
718 Type *I128Ty = Type::getInt128Ty(Context);
718 Type *I128Ty = Type::getInt128Ty(Context);
752 Type *T_int1 = Type::getInt1Ty(Context);
752 Type *T_int1 = Type::getInt1Ty(Context);
753 Type *T_int64 = Type::getInt64Ty(Context);
753 Type *T_int64 = Type::getInt64Ty(Context);
754 Type *T_pint64 = T_int64->getPointerTo(10);
757 FunctionType::get(Type::getVoidTy(Context), {T_pint64}, false);
827 Type *T_int64 = Type::getInt64Ty(Context);
827 Type *T_int64 = Type::getInt64Ty(Context);
828 Type *T_pint64 = T_int64->getPointerTo(10);
831 FunctionType::get(Type::getVoidTy(Context), {T_pint64}, false);
925 Type *T_int64 = Type::getInt64Ty(Context);
925 Type *T_int64 = Type::getInt64Ty(Context);
926 Type *T_pint64 = T_int64->getPointerTo(10);
929 FunctionType::get(Type::getVoidTy(Context), {T_pint64}, false);
989 FunctionType::get(Type::getVoidTy(Context), std::vector<Type *>(), false);
1017 LoopBB, ExitBB, UndefValue::get(Type::getInt1Ty(Context)), LoopBB);
1018 auto *Phi = PHINode::Create(Type::getInt64Ty(Context), 2, "", Br);
1043 Type *Int32Ty = Type::getInt32Ty(Context);
1043 Type *Int32Ty = Type::getInt32Ty(Context);
1044 SmallVector<Type *, 1> Types;
1046 FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), Types, false);
1074 LoopBB, ExitBB, UndefValue::get(Type::getInt1Ty(Context)), LoopBB);
1097 Type *ArgTy = Type::getInt64Ty(Context);
1097 Type *ArgTy = Type::getInt64Ty(Context);
1098 Type *Int32Ty = Type::getInt32Ty(Context);
1098 Type *Int32Ty = Type::getInt32Ty(Context);
1099 SmallVector<Type *, 1> Types;
1101 FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), Types, false);
1153 Type *T_int64 = Type::getInt64Ty(Context);
1153 Type *T_int64 = Type::getInt64Ty(Context);
1154 Type *T_pint64 = T_int64->getPointerTo(10);
1157 FunctionType::get(Type::getVoidTy(Context), {T_pint64}, false);
1215 Type *T_int64 = Type::getInt64Ty(Context);
1215 Type *T_int64 = Type::getInt64Ty(Context);
1218 FunctionType::get(Type::getVoidTy(Context), { T_int64 }, false);
1267 Type *T_int64 = Type::getInt64Ty(Context);
1267 Type *T_int64 = Type::getInt64Ty(Context);
1270 FunctionType::get(Type::getVoidTy(Context), { T_int64 }, false);
1317 Type *T_int64 = Type::getInt64Ty(Context);
1317 Type *T_int64 = Type::getInt64Ty(Context);
1320 FunctionType::get(Type::getVoidTy(Context), { T_int64 }, false);
1368 Type *T_int64 = Type::getInt64Ty(Context);
1368 Type *T_int64 = Type::getInt64Ty(Context);
1371 FunctionType::get(Type::getVoidTy(Context), { T_int64 }, false);
1418 Type *T_int64 = Type::getInt64Ty(Context);
1418 Type *T_int64 = Type::getInt64Ty(Context);
1421 FunctionType::get(Type::getVoidTy(Context), { T_int64, T_int64 }, false);
1633 Type *ARType = IntegerType::get(C, ARBitWidth);
1895 Type *ARType = IntegerType::get(C, ARBitWidth);
unittests/Analysis/SparsePropagation.cpp 377 {Type::getInt1PtrTy(Context)}, false),
384 LoadInst *Cond = Builder.CreateLoad(Type::getInt1Ty(Context), F->arg_begin());
417 {Type::getInt1PtrTy(Context)}, false),
424 LoadInst *Cond = Builder.CreateLoad(Type::getInt1Ty(Context), F->arg_begin());
unittests/Analysis/TBAATest.cpp 35 FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), {});
38 auto *IntType = Type::getInt32Ty(C);
39 auto *PtrType = Type::getInt32PtrTy(C);
unittests/Analysis/ValueLatticeTest.cpp 40 auto FloatTy = Type::getFloatTy(Context);
136 auto *FloatTy = IntegerType::getFloatTy(Context);
175 auto *FloatTy = IntegerType::getFloatTy(Context);
unittests/Analysis/VectorUtilsTest.cpp 71 FunctionType::get(Type::getVoidTy(Ctx), /* IsVarArg */ false),
unittests/AsmParser/AsmParserTest.cpp 177 Type *Ty;
302 Type *Ty;
unittests/CodeGen/LowLevelTypeTest.cpp 43 Type *IRTy = IntegerType::get(C, S);
87 Type *IRSTy = IntegerType::get(C, S);
88 Type *IRTy = VectorType::get(IRSTy, Elts);
200 Type *IRTy = PointerType::get(IntegerType::get(C, 8), AS);
202 Type *IRVTy =
unittests/CodeGen/MachineInstrTest.cpp 156 auto Type = FunctionType::get(Type::getVoidTy(Ctx), false);
unittests/CodeGen/MachineOperandTest.cpp 243 M.getOrInsertGlobal("foo", Type::getInt32Ty(Ctx));
unittests/CodeGen/ScalableVectorMVTsTest.cpp 92 Type *Int64Ty = Type::getInt64Ty(Ctx);
92 Type *Int64Ty = Type::getInt64Ty(Ctx);
115 Type *Ty = Enxv4f64.getTypeForEVT(Ctx);
unittests/ExecutionEngine/ExecutionEngineTest.cpp 40 GlobalVariable *NewExtGlobal(Type *T, const Twine &Name) {
52 GlobalVariable *G1 = NewExtGlobal(Type::getInt32Ty(Context), "Global1");
65 GlobalVariable *G2 = NewExtGlobal(Type::getInt32Ty(Context), "Global1");
77 GlobalVariable *G1 = NewExtGlobal(Type::getInt32Ty(Context), "Global1");
87 GlobalVariable *G2 = NewExtGlobal(Type::getInt32Ty(Context), "Global2");
103 GlobalVariable *G1 = NewExtGlobal(Type::getInt32Ty(Context), "Global1");
113 GlobalVariable *G2 = NewExtGlobal(Type::getInt32Ty(Context), "Global2");
121 GlobalVariable *G1 = NewExtGlobal(Type::getInt32Ty(Context), "Global1");
unittests/ExecutionEngine/MCJIT/MCJITTestBase.h 81 M, FunctionType::get(Type::getInt32Ty(Context), {}, false), "main");
96 Type::getInt32Ty(Context),
97 {Type::getInt32Ty(Context), Type::getInt32Ty(Context)}, false),
97 {Type::getInt32Ty(Context), Type::getInt32Ty(Context)}, false),
131 Type *GlobalTy = Type::getInt32Ty(Context);
131 Type *GlobalTy = Type::getInt32Ty(Context);
157 FunctionType::get(Type::getInt32Ty(Context),
158 {Type::getInt32Ty(Context)}, false),
unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp 22 Type::getVoidTy(Context),
unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp 80 Type *Int32Ty = IntegerType::get(Context, 32);
126 Type *Int32Ty = IntegerType::get(Context, 32);
216 Type *Int32Ty = IntegerType::get(Context, 32);
unittests/ExecutionEngine/Orc/OrcCAPITest.cpp 29 Type *IntTy = Type::getScalarTy<int>(Context);
29 Type *IntTy = Type::getScalarTy<int>(Context);
35 {IntTy, Type::getInt8PtrTy(Context)->getPointerTo()},
unittests/ExecutionEngine/Orc/OrcTestCommon.h 188 return StructType::get(ArrayType::get(Type::getInt32Ty(Context), 256));
unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp 76 Type *Int32Ty = IntegerType::get(Context, 32);
133 FunctionType::get(Type::getVoidTy(*TSCtx.getContext()), {}, false),
141 FunctionType::get(Type::getVoidTy(*TSCtx.getContext()), {}, false),
187 FunctionType::get(Type::getVoidTy(M.getContext()), {}, false),
206 FunctionType::get(Type::getVoidTy(*TSCtx.getContext()), {}, false),
unittests/ExecutionEngine/Orc/RemoteObjectLayerTest.cpp 98 FunctionType::get(Type::getInt32Ty(Ctx),
99 {Type::getInt32Ty(Ctx),
100 Type::getInt8PtrTy(Ctx)->getPointerTo()},
105 B.CreateRet(ConstantInt::getSigned(Type::getInt32Ty(Ctx), 42));
unittests/FuzzMutate/OperationsTest.cpp 23 void PrintTo(Type *T, ::std::ostream *OS) {
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),
88 Constant *f16 = ConstantFP::getInfinity(Type::getHalfTy(Ctx));
89 Constant *f32 = ConstantFP::get(Type::getFloatTy(Ctx), 0.0);
90 Constant *f64 = ConstantFP::get(Type::getDoubleTy(Ctx), 123.45);
178 Function *F = Function::Create(FunctionType::get(Type::getVoidTy(Ctx), {},
186 SBOp.BuilderFunc({UndefValue::get(Type::getInt1Ty(Ctx))}, RI);
196 auto *AI = new AllocaInst(Type::getInt8Ty(Ctx), 0, "a", RI);
245 Type *Int8Ty = Type::getInt8Ty(Ctx);
245 Type *Int8Ty = Type::getInt8Ty(Ctx);
248 Function *F = Function::Create(FunctionType::get(Type::getVoidTy(Ctx), {},
282 Type *Int8PtrTy = Type::getInt8PtrTy(Ctx);
282 Type *Int8PtrTy = Type::getInt8PtrTy(Ctx);
283 Type *Int32Ty = Type::getInt32Ty(Ctx);
283 Type *Int32Ty = Type::getInt32Ty(Ctx);
286 Function *F = Function::Create(FunctionType::get(Type::getVoidTy(Ctx), {},
332 Type *Int8PtrTy = Type::getInt8PtrTy(Ctx);
332 Type *Int8PtrTy = Type::getInt8PtrTy(Ctx);
333 Type *Int32Ty = Type::getInt32Ty(Ctx);
333 Type *Int32Ty = Type::getInt32Ty(Ctx);
334 Type *Int64Ty = Type::getInt64Ty(Ctx);
334 Type *Int64Ty = Type::getInt64Ty(Ctx);
336 Type *StructTy = StructType::create(Ctx, {Int8PtrTy, Int32Ty});
337 Type *OpaqueTy = StructType::create(Ctx, "OpaqueStruct");
338 Type *ZeroSizedArrayTy = ArrayType::get(Int64Ty, 0);
339 Type *ArrayTy = ArrayType::get(Int64Ty, 4);
340 Type *VectorTy = VectorType::get(Int32Ty, 2);
unittests/FuzzMutate/RandomIRBuilderTest.cpp 101 std::vector<Type *> Types =
102 {Type::getInt8Ty(Ctx), Type::getInt32Ty(Ctx), Type::getInt64Ty(Ctx)};
102 {Type::getInt8Ty(Ctx), Type::getInt32Ty(Ctx), Type::getInt64Ty(Ctx)};
102 {Type::getInt8Ty(Ctx), Type::getInt32Ty(Ctx), Type::getInt64Ty(Ctx)};
118 for (auto *T: Types) {
180 std::vector<Type *> Types =
181 {Type::getInt8Ty(Ctx), Type::getInt32Ty(Ctx), Type::getInt64Ty(Ctx)};
181 {Type::getInt8Ty(Ctx), Type::getInt32Ty(Ctx), Type::getInt64Ty(Ctx)};
181 {Type::getInt8Ty(Ctx), Type::getInt32Ty(Ctx), Type::getInt64Ty(Ctx)};
222 std::vector<Type *> Types = {Type::getInt8Ty(Ctx)};
222 std::vector<Type *> Types = {Type::getInt8Ty(Ctx)};
252 std::vector<Type *> Types = {Type::getInt8Ty(Ctx)};
252 std::vector<Type *> Types = {Type::getInt8Ty(Ctx)};
282 std::vector<Type *> Types = {Type::getInt8Ty(Ctx)};
282 std::vector<Type *> Types = {Type::getInt8Ty(Ctx)};
unittests/FuzzMutate/StrategiesTest.cpp 30 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
30 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
30 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
30 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
31 Type::getInt64Ty, Type::getFloatTy, Type::getDoubleTy};
31 Type::getInt64Ty, Type::getFloatTy, Type::getDoubleTy};
31 Type::getInt64Ty, Type::getFloatTy, Type::getDoubleTy};
43 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
43 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
43 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
43 Type::getInt1Ty, Type::getInt8Ty, Type::getInt16Ty, Type::getInt32Ty,
44 Type::getInt64Ty, Type::getFloatTy, Type::getDoubleTy};
44 Type::getInt64Ty, Type::getFloatTy, Type::getDoubleTy};
44 Type::getInt64Ty, Type::getFloatTy, Type::getDoubleTy};
unittests/IR/AsmWriterTest.cpp 26 auto Ty = Type::getInt32Ty(Ctx);
40 auto Ty = Type::getInt32Ty(Ctx);
unittests/IR/AttributesTest.cpp 44 Attribute ByVal = Attribute::get(C, Attribute::ByVal, Type::getInt32Ty(C));
176 StructType *Ty = StructType::create(Type::getInt32Ty(C), "mystruct");
185 A = Attribute::getWithByValType(C, Type::getInt32Ty(C));
unittests/IR/BasicBlockTest.cpp 45 auto *Int32Ty = Type::getInt32Ty(Context);
98 Type *ArgTy1[] = {Type::getInt32PtrTy(Ctx)};
98 Type *ArgTy1[] = {Type::getInt32PtrTy(Ctx)};
99 FunctionType *FT = FunctionType::get(Type::getVoidTy(Ctx), ArgTy1, false);
100 Argument *V = new Argument(Type::getInt32Ty(Ctx));
unittests/IR/CFGBuilder.cpp 25 FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Context), {}, false);
unittests/IR/ConstantsTest.cpp 107 IntegerType *Int8Ty = Type::getInt8Ty(Context);
121 Type *FP128Ty = Type::getFP128Ty(Context);
121 Type *FP128Ty = Type::getFP128Ty(Context);
123 IntegerType *Int128Ty = Type::getIntNTy(Context, 128);
131 Type *Int8PtrTy = Type::getInt8PtrTy(C);
131 Type *Int8PtrTy = Type::getInt8PtrTy(C);
132 Type *Int32PtrTy = Type::getInt32PtrTy(C);
132 Type *Int32PtrTy = Type::getInt32PtrTy(C);
133 Type *Int64Ty = Type::getInt64Ty(C);
133 Type *Int64Ty = Type::getInt64Ty(C);
158 Type *Int32Ptr1Ty = Type::getInt32PtrTy(C, 1);
158 Type *Int32Ptr1Ty = Type::getInt32PtrTy(C, 1);
159 ConstantInt *K = ConstantInt::get(Type::getInt64Ty(C), 1234);
195 Type *Int64Ty = Type::getInt64Ty(Context);
195 Type *Int64Ty = Type::getInt64Ty(Context);
196 Type *Int32Ty = Type::getInt32Ty(Context);
196 Type *Int32Ty = Type::getInt32Ty(Context);
197 Type *Int16Ty = Type::getInt16Ty(Context);
197 Type *Int16Ty = Type::getInt16Ty(Context);
198 Type *Int1Ty = Type::getInt1Ty(Context);
198 Type *Int1Ty = Type::getInt1Ty(Context);
199 Type *FloatTy = Type::getFloatTy(Context);
199 Type *FloatTy = Type::getFloatTy(Context);
200 Type *DoubleTy = Type::getDoubleTy(Context);
200 Type *DoubleTy = Type::getDoubleTy(Context);
308 Type *Int32Ty = Type::getInt32Ty(Context);
308 Type *Int32Ty = Type::getInt32Ty(Context);
328 Type *IntTy = Type::getInt8Ty(Context);
328 Type *IntTy = Type::getInt8Ty(Context);
353 Type *IntTy = Type::getInt8Ty(Context);
353 Type *IntTy = Type::getInt8Ty(Context);
376 Type *IntTy = Type::getInt32Ty(Context);
376 Type *IntTy = Type::getInt32Ty(Context);
377 Type *PtrTy = PointerType::get(IntTy, 0);
403 Type *I16Ty = Type::getInt16Ty(Context);
403 Type *I16Ty = Type::getInt16Ty(Context);
404 Type *I16PTy = PointerType::get(I16Ty, 0);
411 static std::string getNameOfType(Type *T) {
422 for (Type *T : {Type::getInt8Ty(Context), Type::getInt16Ty(Context),
422 for (Type *T : {Type::getInt8Ty(Context), Type::getInt16Ty(Context),
422 for (Type *T : {Type::getInt8Ty(Context), Type::getInt16Ty(Context),
423 Type::getInt32Ty(Context), Type::getInt64Ty(Context)}) {
423 Type::getInt32Ty(Context), Type::getInt64Ty(Context)}) {
431 for (Type *T : {Type::getHalfTy(Context), Type::getFloatTy(Context),
431 for (Type *T : {Type::getHalfTy(Context), Type::getFloatTy(Context),
431 for (Type *T : {Type::getHalfTy(Context), Type::getFloatTy(Context),
432 Type::getDoubleTy(Context)}) {
445 for (Type *T : {Type::getInt8Ty(Context), Type::getInt16Ty(Context),
445 for (Type *T : {Type::getInt8Ty(Context), Type::getInt16Ty(Context),
445 for (Type *T : {Type::getInt8Ty(Context), Type::getInt16Ty(Context),
446 Type::getInt32Ty(Context), Type::getInt64Ty(Context)}) {
446 Type::getInt32Ty(Context), Type::getInt64Ty(Context)}) {
453 for (Type *T : {Type::getHalfTy(Context), Type::getFloatTy(Context),
453 for (Type *T : {Type::getHalfTy(Context), Type::getFloatTy(Context),
453 for (Type *T : {Type::getHalfTy(Context), Type::getFloatTy(Context),
454 Type::getDoubleTy(Context)}) {
466 auto *i32 = Type::getInt32Ty(Context);
468 Type *EltTys[] = {i32, U};
481 Type *VoidType(Type::getVoidTy(Context));
481 Type *VoidType(Type::getVoidTy(Context));
489 IntegerType *ConstantIntType(Type::getInt32Ty(Context));
572 IntegerType *IntType(Type::getInt32Ty(Context));
unittests/IR/DataLayoutTest.cpp 52 Type *const FourByteAlignType = Type::getInt32Ty(Context);
52 Type *const FourByteAlignType = Type::getInt32Ty(Context);
unittests/IR/FunctionTest.cpp 19 Type *ArgTypes[] = {Type::getInt8Ty(C), Type::getInt32Ty(C)};
19 Type *ArgTypes[] = {Type::getInt8Ty(C), Type::getInt32Ty(C)};
19 Type *ArgTypes[] = {Type::getInt8Ty(C), Type::getInt32Ty(C)};
20 FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), ArgTypes, false);
49 Type *ArgTypes[] = {Type::getInt8Ty(C), Type::getInt32Ty(C)};
49 Type *ArgTypes[] = {Type::getInt8Ty(C), Type::getInt32Ty(C)};
49 Type *ArgTypes[] = {Type::getInt8Ty(C), Type::getInt32Ty(C)};
50 FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), ArgTypes, false);
126 Function::Create(llvm::FunctionType::get(llvm::Type::getVoidTy(C), false),
142 Type *VoidType(Type::getVoidTy(Context));
142 Type *VoidType(Type::getVoidTy(Context));
unittests/IR/IRBuilderTest.cpp 30 FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
34 GV = new GlobalVariable(*M, Type::getFloatTy(Ctx), true,
132 Type *SrcVecTy = VectorType::get(Builder.getHalfTy(), 8, true);
133 Type *DstVecTy = VectorType::get(Builder.getInt32Ty(), 4, true);
134 Type *PredTy = VectorType::get(Builder.getInt1Ty(), 16, true);
151 Type *VecTy = VectorType::get(Builder.getInt32Ty(), 4, true);
152 Type *PtrToVecTy = VecTy->getPointerTo();
177 GlobalVariable *GVDouble = new GlobalVariable(*M, Type::getDoubleTy(Ctx),
222 V = Builder.CreateFPTrunc(VDouble, Type::getFloatTy(Ctx));
227 VDouble = Builder.CreateFPExt(V, Type::getDoubleTy(Ctx));
541 auto CalleeTy = FunctionType::get(Type::getFloatTy(Ctx),
798 auto CalleeTy = FunctionType::get(Type::getVoidTy(Ctx),
unittests/IR/InstructionsTest.cpp 69 FArgTypes.push_back(Type::getInt8Ty(Ctx));
70 FArgTypes.push_back(Type::getInt32Ty(Ctx));
71 FArgTypes.push_back(Type::getInt64Ty(Ctx));
73 FunctionType::get(Type::getVoidTy(Ctx), FArgTypes, false);
79 SmallVector<Type *, 3> FArgTypes;
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)};
185 Type *Int8Ty = Type::getInt8Ty(C);
185 Type *Int8Ty = Type::getInt8Ty(C);
186 Type *Int16Ty = Type::getInt16Ty(C);
186 Type *Int16Ty = Type::getInt16Ty(C);
187 Type *Int32Ty = Type::getInt32Ty(C);
187 Type *Int32Ty = Type::getInt32Ty(C);
188 Type *Int64Ty = Type::getInt64Ty(C);
188 Type *Int64Ty = Type::getInt64Ty(C);
189 Type *V8x8Ty = VectorType::get(Int8Ty, 8);
190 Type *V8x64Ty = VectorType::get(Int64Ty, 8);
191 Type *X86MMXTy = Type::getX86_MMXTy(C);
191 Type *X86MMXTy = Type::getX86_MMXTy(C);
193 Type *HalfTy = Type::getHalfTy(C);
193 Type *HalfTy = Type::getHalfTy(C);
194 Type *FloatTy = Type::getFloatTy(C);
194 Type *FloatTy = Type::getFloatTy(C);
195 Type *DoubleTy = Type::getDoubleTy(C);
195 Type *DoubleTy = Type::getDoubleTy(C);
197 Type *V2Int32Ty = VectorType::get(Int32Ty, 2);
198 Type *V2Int64Ty = VectorType::get(Int64Ty, 2);
199 Type *V4Int16Ty = VectorType::get(Int16Ty, 4);
201 Type *Int32PtrTy = PointerType::get(Int32Ty, 0);
202 Type *Int64PtrTy = PointerType::get(Int64Ty, 0);
204 Type *Int32PtrAS1Ty = PointerType::get(Int32Ty, 1);
205 Type *Int64PtrAS1Ty = PointerType::get(Int64Ty, 1);
207 Type *V2Int32PtrAS1Ty = VectorType::get(Int32PtrAS1Ty, 2);
208 Type *V2Int64PtrAS1Ty = VectorType::get(Int64PtrAS1Ty, 2);
209 Type *V4Int32PtrAS1Ty = VectorType::get(Int32PtrAS1Ty, 4);
210 Type *V4Int64PtrAS1Ty = VectorType::get(Int64PtrAS1Ty, 4);
212 Type *V2Int64PtrTy = VectorType::get(Int64PtrTy, 2);
213 Type *V2Int32PtrTy = VectorType::get(Int32PtrTy, 2);
214 Type *V4Int32PtrTy = VectorType::get(Int32PtrTy, 4);
309 Type *I8Ty = IntegerType::get(C, 8);
310 Type *I32Ty = IntegerType::get(C, 32);
426 Type* Int16Ty = Type::getInt16Ty(C);
426 Type* Int16Ty = Type::getInt16Ty(C);
427 Type* Int32Ty = Type::getInt32Ty(C);
427 Type* Int32Ty = Type::getInt32Ty(C);
428 Type* Int64Ty = Type::getInt64Ty(C);
428 Type* Int64Ty = Type::getInt64Ty(C);
429 Type* Int64PtrTy = Type::getInt64PtrTy(C);
429 Type* Int64PtrTy = Type::getInt64PtrTy(C);
474 Type* Int64PtrTyAS1 = Type::getInt64PtrTy(C, 1);
474 Type* Int64PtrTyAS1 = Type::getInt64PtrTy(C, 1);
475 Type* Int64PtrTyAS2 = Type::getInt64PtrTy(C, 2);
475 Type* Int64PtrTyAS2 = Type::getInt64PtrTy(C, 2);
505 Type *Int32Ty = Type::getInt32Ty(C);
505 Type *Int32Ty = Type::getInt32Ty(C);
506 Type *ArgTys[] = {Int32Ty, Int32Ty, Int32Ty};
540 Type *Int32Ty = Type::getInt32Ty(C);
540 Type *Int32Ty = Type::getInt32Ty(C);
567 Type *Int32Ty = Type::getInt32Ty(C);
567 Type *Int32Ty = Type::getInt32Ty(C);
661 Type *ElementTy = Builder.getInt8Ty();
662 Type *ArrTy = ArrayType::get(ArrayType::get(ElementTy, 64), 64);
705 auto *Int32Ty = Type::getInt32Ty(C);
768 auto *Int32Ty = Type::getInt32Ty(C);
806 Type *Int32Ty = Type::getInt32Ty(Ctx);
806 Type *Int32Ty = Type::getInt32Ty(Ctx);
1051 Type *FltTy = Type::getFloatTy(Context);
1051 Type *FltTy = Type::getFloatTy(Context);
unittests/IR/LegacyPassManagerTest.cpp 474 std::vector<Type*>FuncTy_0_args;
480 std::vector<Type*>FuncTy_2_args;
483 /*Result=*/Type::getVoidTy(Context),
unittests/IR/ManglerTest.cpp 31 Type *VoidTy = Type::getVoidTy(Mod.getContext());
31 Type *VoidTy = Type::getVoidTy(Mod.getContext());
32 Type *I32Ty = Type::getInt32Ty(Mod.getContext());
32 Type *I32Ty = Type::getInt32Ty(Mod.getContext());
unittests/IR/MetadataTest.cpp 109 return ConstantInt::get(Type::getInt32Ty(Context), Counter++);
121 FunctionType::get(Type::getVoidTy(Context), None, false),
211 Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 1);
212 Instruction *I = new BitCastInst(C, Type::getInt32Ty(Context));
262 Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 7);
321 Constant *C = ConstantInt::get(Type::getInt32Ty(Context), 7);
348 auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
372 Function::Create(FunctionType::get(Type::getVoidTy(Context),
373 Type::getMetadataTy(Context), false),
376 auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
407 auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
490 Type *Ty = Type::getInt1PtrTy(Context);
490 Type *Ty = Type::getInt1PtrTy(Context);
729 Type *Ty = Type::getInt1PtrTy(Context);
729 Type *Ty = Type::getInt1PtrTy(Context);
752 Type *Ty = Type::getInt1PtrTy(Context);
752 Type *Ty = Type::getInt1PtrTy(Context);
2529 Type *Ty = Type::getInt1PtrTy(Context);
2529 Type *Ty = Type::getInt1PtrTy(Context);
2590 Type *Ty = Type::getInt1PtrTy(Context);
2590 Type *Ty = Type::getInt1PtrTy(Context);
2607 Type *Ty = Type::getInt1PtrTy(Context);
2607 Type *Ty = Type::getInt1PtrTy(Context);
2621 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 1));
2623 ConstantAsMetadata::get(ConstantInt::get(Type::getInt32Ty(Context), 2));
unittests/IR/ModuleTest.cpp 33 Type *T = Type::getInt8Ty(Context);
33 Type *T = Type::getInt8Ty(Context);
unittests/IR/PatternMatch.cpp 43 FunctionType::get(Type::getVoidTy(Ctx), /* IsVarArg */ false),
69 Type *IntTy = IRB.getInt32Ty();
108 Type *IntTy = IRB.getInt32Ty();
147 Type *IntTy = IRB.getInt32Ty();
186 Type *IntTy = IRB.getInt32Ty();
225 Type *IntTy = IRB.getInt32Ty();
264 Type *IntTy = IRB.getInt32Ty();
303 Type *IntTy = IRB.getInt32Ty();
342 Type *IntTy = IRB.getInt32Ty();
381 Type *IntTy = IRB.getInt32Ty();
420 Type *IntTy = IRB.getInt32Ty();
581 Type *FltTy = IRB.getFloatTy();
631 Type *FltTy = IRB.getFloatTy();
682 Type *FltTy = IRB.getFloatTy();
732 Type *FltTy = IRB.getFloatTy();
908 Type *VecTy = VectorType::get(IRB.getInt8Ty(), 2);
909 Type *i32 = IRB.getInt32Ty();
910 Type *i32VecTy = VectorType::get(i32, 2);
1000 Type *ScalarTy = IRB.getInt8Ty();
1001 Type *VectorTy = VectorType::get(ScalarTy, 4);
1028 Type *ScalarTy = IRB.getFloatTy();
1029 Type *VectorTy = VectorType::get(ScalarTy, 4);
1056 Type *FltTy = IRB.getFloatTy();
unittests/IR/UserTest.cpp 123 FunctionType *RetVoidTy = FunctionType::get(Type::getVoidTy(Context), false);
unittests/IR/ValueHandleTest.cpp 27 : ConstantV(ConstantInt::get(Type::getInt32Ty(Context), 0)),
28 BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(Context))) {}
327 Constant::getNullValue(Type::getInt32Ty(*Context)));
343 RVH, Constant::getNullValue(Type::getInt32Ty(Context))));
514 BitcastV.reset(new BitCastInst(ConstantV, Type::getInt32Ty(Context)));
533 BitcastV.reset(new BitCastInst(ConstantV, Type::getInt32Ty(Context)));
unittests/IR/ValueMapTest.cpp 30 : ConstantV(ConstantInt::get(Type::getInt32Ty(Context), 0)),
31 BitcastV(new BitCastInst(ConstantV, Type::getInt32Ty(Context))),
unittests/IR/ValueTest.cpp 49 Type *Int8Ty = Type::getInt8Ty(Ctx);
49 Type *Int8Ty = Type::getInt8Ty(Ctx);
50 Type *Int32Ty = Type::getInt32Ty(Ctx);
50 Type *Int32Ty = Type::getInt32Ty(Ctx);
97 Type *Int32Ty = Type::getInt32Ty(Ctx);
97 Type *Int32Ty = Type::getInt32Ty(Ctx);
unittests/IR/VectorTypesTest.cpp 20 Type *Int16Ty = Type::getInt16Ty(Ctx);
20 Type *Int16Ty = Type::getInt16Ty(Ctx);
21 Type *Int32Ty = Type::getInt32Ty(Ctx);
21 Type *Int32Ty = Type::getInt32Ty(Ctx);
22 Type *Int64Ty = Type::getInt64Ty(Ctx);
22 Type *Int64Ty = Type::getInt64Ty(Ctx);
23 Type *Float64Ty = Type::getDoubleTy(Ctx);
23 Type *Float64Ty = Type::getDoubleTy(Ctx);
94 Type *Int16Ty = Type::getInt16Ty(Ctx);
94 Type *Int16Ty = Type::getInt16Ty(Ctx);
95 Type *Int32Ty = Type::getInt32Ty(Ctx);
95 Type *Int32Ty = Type::getInt32Ty(Ctx);
96 Type *Int64Ty = Type::getInt64Ty(Ctx);
96 Type *Int64Ty = Type::getInt64Ty(Ctx);
97 Type *Float64Ty = Type::getDoubleTy(Ctx);
97 Type *Float64Ty = Type::getDoubleTy(Ctx);
169 Type *Int32Ty = Type::getInt32Ty(Ctx);
169 Type *Int32Ty = Type::getInt32Ty(Ctx);
170 Type *Int64Ty = Type::getInt64Ty(Ctx);
170 Type *Int64Ty = Type::getInt64Ty(Ctx);
218 Type *Int32Ty = Type::getInt32Ty(Ctx);
218 Type *Int32Ty = Type::getInt32Ty(Ctx);
219 Type *Int64Ty = Type::getInt64Ty(Ctx);
219 Type *Int64Ty = Type::getInt64Ty(Ctx);
261 Type *Int32Ty = Type::getInt32Ty(Ctx);
261 Type *Int32Ty = Type::getInt32Ty(Ctx);
unittests/IR/VerifierTest.cpp 28 FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg=*/false);
51 FunctionType *FTy = FunctionType::get(Type::getInt32Ty(C), /*isVarArg=*/false);
69 FunctionType *FTy = FunctionType::get(Type::getInt32Ty(C), /*isVarArg=*/false);
84 Constant *ConstZero = ConstantInt::get(Type::getInt32Ty(C), 0);
126 new GlobalVariable(M, Type::getInt8Ty(C), false,
140 FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg=*/false);
173 new GlobalVariable(M, Type::getInt8Ty(C), false,
176 auto *F = Function::Create(FunctionType::get(Type::getVoidTy(C), false),
unittests/IR/WaymarkTest.cpp 26 return ConstantInt::get(Type::getInt8Ty(Context), c);
28 FunctionType *FT = FunctionType::get(Type::getVoidTy(Context), true);
unittests/Linker/LinkModulesTest.cpp 31 Type::getInt8PtrTy(Ctx), Type::getInt32Ty(Ctx), false /*=isVarArg*/);
31 Type::getInt8PtrTy(Ctx), Type::getInt32Ty(Ctx), false /*=isVarArg*/);
40 AT = ArrayType::get(Type::getInt8PtrTy(Ctx), 3);
53 ConstantInt *One = ConstantInt::get(Type::getInt32Ty(Ctx), 1);
55 Type::getInt8PtrTy(Ctx));
82 GEPIndices.push_back(ConstantInt::get(Type::getInt32Ty(Ctx), 0));
97 Builder.CreateRet(ConstantPointerNull::get(Type::getInt8PtrTy(Ctx)));
112 ArrayType *AT = ArrayType::get(Type::getInt8PtrTy(Ctx), 3);
136 Type::getVoidTy(Ctx), Type::getInt8PtrTy(Ctx), false /*=isVarArgs*/);
136 Type::getVoidTy(Ctx), Type::getInt8PtrTy(Ctx), false /*=isVarArgs*/);
151 Type::getVoidTy(Ctx), Type::getInt8PtrTy(Ctx), false /*=isVarArgs*/);
151 Type::getVoidTy(Ctx), Type::getInt8PtrTy(Ctx), false /*=isVarArgs*/);
unittests/ProfileData/InstrProfTest.cpp 289 FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
893 FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
unittests/ProfileData/SampleProfTest.cpp 129 FunctionType::get(Type::getVoidTy(Context), {}, false);
287 FunctionType::get(Type::getVoidTy(Context), {}, false);
unittests/Transforms/Scalar/LoopPassManagerTest.cpp 909 auto *Cond = new LoadInst(Type::getInt1Ty(Context), &Ptr, Name,
1112 auto *Cond = new LoadInst(Type::getInt1Ty(Context), &Ptr, Name,
1507 new LoadInst(Type::getInt1Ty(Context), &Ptr, "cond.0.3",
unittests/Transforms/Utils/CloningTest.cpp 68 V = new Argument(Type::getInt32Ty(context));
138 V = new Argument(Type::getInt32PtrTy(context));
140 Constant *Z = Constant::getNullValue(Type::getInt32Ty(context));
144 GetElementPtrInst::Create(Type::getInt32Ty(context), V, ops);
152 V = new Argument(Type::getInt32Ty(context));
162 Type *ArgTy1[] = { Type::getInt32PtrTy(context) };
162 Type *ArgTy1[] = { Type::getInt32PtrTy(context) };
163 FunctionType *FT1 = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
187 Type *ArgTy1[] = { Type::getInt32PtrTy(context) };
187 Type *ArgTy1[] = { Type::getInt32PtrTy(context) };
188 FunctionType *FT1 = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
210 Type *ArgTy1[] = {Type::getInt32PtrTy(context)};
210 Type *ArgTy1[] = {Type::getInt32PtrTy(context)};
211 FunctionType *FT = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
212 V = new Argument(Type::getInt32Ty(context));
259 Type *ArgTy1[] = {Type::getInt32PtrTy(context)};
259 Type *ArgTy1[] = {Type::getInt32PtrTy(context)};
260 FunctionType *FT = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
261 V = new Argument(Type::getInt32Ty(context));
312 Type *ArgTy1[] = {Type::getInt32PtrTy(context)};
312 Type *ArgTy1[] = {Type::getInt32PtrTy(context)};
313 FunctionType *FT = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
314 V = new Argument(Type::getInt32Ty(context));
461 FunctionType* FuncType = FunctionType::get(Type::getVoidTy(C), false);
726 *OldM, Type::getInt32Ty(C), false, GlobalValue::ExternalLinkage,
727 ConstantInt::get(Type::getInt32Ty(C), 1), "gv");
734 auto *FuncType = FunctionType::get(Type::getVoidTy(C), false);
unittests/Transforms/Utils/FunctionComparatorTest.cpp 24 Type *T;
92 int testCmpTypes(Type *TyL, Type *TyR) {
92 int testCmpTypes(Type *TyL, Type *TyR) {
unittests/Transforms/Utils/IntegerDivisionTest.cpp 27 SmallVector<Type*, 2> ArgTys(2, Builder.getInt32Ty());
57 SmallVector<Type*, 2> ArgTys(2, Builder.getInt32Ty());
87 SmallVector<Type*, 2> ArgTys(2, Builder.getInt32Ty());
117 SmallVector<Type*, 2> ArgTys(2, Builder.getInt32Ty());
148 SmallVector<Type*, 2> ArgTys(2, Builder.getInt64Ty());
178 SmallVector<Type*, 2> ArgTys(2, Builder.getInt64Ty());
208 SmallVector<Type*, 2> ArgTys(2, Builder.getInt64Ty());
238 SmallVector<Type*, 2> ArgTys(2, Builder.getInt64Ty());
unittests/Transforms/Utils/LocalTest.cpp 35 PHINode *phi = builder.CreatePHI(Type::getInt32Ty(C), 2);
52 phi = builder.CreatePHI(Type::getInt32Ty(C), 0);
57 phi = builder.CreatePHI(Type::getInt32Ty(C), 0);
81 AssertingVH<PHINode> P1 = B.CreatePHI(Type::getInt32Ty(C), 2);
84 PHINode *P2 = B.CreatePHI(Type::getInt32Ty(C), 2);
87 AssertingVH<PHINode> P3 = B.CreatePHI(Type::getInt32Ty(C), 2);
91 PHINode *P4 = B.CreatePHI(Type::getInt32Ty(C), 2);
154 Value *NewBase = Constant::getNullValue(Type::getInt32PtrTy(C));
unittests/Transforms/Utils/SSAUpdaterBulkTest.cpp 26 Type *I32Ty = B.getInt32Ty();
113 Type *I32Ty = B.getInt32Ty();
unittests/Transforms/Utils/ValueMapperTest.cpp 68 auto *PtrTy = Type::getInt8Ty(Context)->getPointerTo();
175 FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
175 FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
234 FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
234 FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
269 FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
269 FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
288 FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
288 FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
329 auto *Int8 = Type::getInt8Ty(Context);
330 FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), Int8, false);
usr/include/c++/7.4.0/bits/move.h 72 constexpr _Tp&&
83 constexpr _Tp&&
usr/include/c++/7.4.0/bits/std_function.h 299 _M_invoke(const _Any_data& __functor, _ArgTypes&&... __args)
628 using _Invoker_type = _Res (*)(const _Any_data&, _ArgTypes&&...);
usr/include/c++/7.4.0/type_traits 1659 { typedef _Tp&& type; };
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)) {