reference, declaration → definition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

Declarations

include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
   39 class FunctionType;
include/llvm/IR/InlineAsm.h
   26 class FunctionType;
include/llvm/IR/Intrinsics.h
   26 class FunctionType;
include/llvm/IR/Module.h
   45 class FunctionType;
lib/Target/AMDGPU/AMDGPULibFunc.h
   16 class FunctionType;
tools/clang/include/clang/CodeGen/CodeGenABITypes.h
   34   class FunctionType;
tools/clang/lib/CodeGen/CGBlocks.h
   33 class FunctionType;
tools/clang/lib/CodeGen/CGOpenMPRuntime.h
   31 class FunctionType;
tools/clang/lib/CodeGen/CodeGenModule.h
   46 class FunctionType;
tools/clang/lib/CodeGen/CodeGenTypes.h
   23 class FunctionType;

References

examples/BrainF/BrainF.cpp
   85   brainf_func = Function::Create(FunctionType::get(Type::getVoidTy(C), false),
examples/BrainF/BrainFDriver.cpp
   75   FunctionType *main_func_fty = FunctionType::get(
   75   FunctionType *main_func_fty = FunctionType::get(
examples/Fibonacci/fibonacci.cpp
   54   FunctionType *FibFTy = FunctionType::get(Type::getInt32Ty(Context),
   54   FunctionType *FibFTy = FunctionType::get(Type::getInt32Ty(Context),
examples/HowToUseJIT/HowToUseJIT.cpp
   72       Function::Create(FunctionType::get(Type::getInt32Ty(Context),
  103       Function::Create(FunctionType::get(Type::getInt32Ty(Context), {}, false),
examples/HowToUseLLJIT/HowToUseLLJIT.cpp
   29       Function::Create(FunctionType::get(Type::getInt32Ty(*Context),
examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp
 1038   FunctionType *FT =
 1039       FunctionType::get(Type::getDoubleTy(*TheContext), Doubles, false);
examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp
 1038   FunctionType *FT =
 1039       FunctionType::get(Type::getDoubleTy(*TheContext), Doubles, false);
examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp
 1037   FunctionType *FT =
 1038       FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp
 1023   FunctionType *FT =
 1024       FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/BuildingAJIT/Chapter5/toy.cpp
 1047   FunctionType *FT =
 1048       FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/Chapter3/toy.cpp
  469   FunctionType *FT =
  470       FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/Chapter4/toy.cpp
  497   FunctionType *FT =
  498       FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/Chapter5/toy.cpp
  771   FunctionType *FT =
  772       FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/Chapter6/toy.cpp
  883   FunctionType *FT =
  884       FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/Chapter7/toy.cpp
 1043   FunctionType *FT =
 1044       FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/Chapter8/toy.cpp
 1042   FunctionType *FT =
 1043       FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/Kaleidoscope/Chapter9/toy.cpp
 1209   FunctionType *FT =
 1210       FunctionType::get(Type::getDoubleTy(TheContext), Doubles, false);
examples/ModuleMaker/ModuleMaker.cpp
   38   FunctionType *FT =
   39     FunctionType::get(Type::getInt32Ty(Context), /*not vararg*/false);
examples/ParallelJIT/ParallelJIT.cpp
   54       Function::Create(FunctionType::get(Type::getInt32Ty(Context),
   84   FunctionType *FibFTy = FunctionType::get(Type::getInt32Ty(Context),
   84   FunctionType *FibFTy = FunctionType::get(Type::getInt32Ty(Context),
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/Analysis/TargetLibraryInfo.h
   76   bool isValidProtoForLibFunc(const FunctionType &FTy, LibFunc F,
include/llvm/Analysis/TargetTransformInfo.h
  242   int getCallCost(FunctionType *FTy, int NumArgs = -1,
 1167   virtual int getCallCost(FunctionType *FTy, int NumArgs, const User *U) = 0;
 1401   int getCallCost(FunctionType *FTy, int NumArgs, const User *U) override {
include/llvm/Analysis/TargetTransformInfoImpl.h
  126   unsigned getCallCost(FunctionType *FTy, int NumArgs, const User *U) {
  708       FunctionType *FTy = F->getFunctionType();
  869             ->getCallCost(cast<FunctionType>(FTy), CS.arg_size(), U);
include/llvm/CodeGen/FastISel.h
  104     CallLoweringInfo &setCallee(Type *ResultTy, FunctionType *FuncTy,
  126     CallLoweringInfo &setCallee(Type *ResultTy, FunctionType *FuncTy,
include/llvm/CodeGen/TargetLowering.h
 3504     CallLoweringInfo &setCallee(Type *ResultType, FunctionType *FTy,
include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h
  668           return Function::Create(cast<FunctionType>(Ty),
include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
  413 Constant *createIRTypedAddress(FunctionType &FT, JITTargetAddress Addr);
include/llvm/IR/CallSite.h
  328   FunctionType *getFunctionType() const {
  332   void mutateFunctionType(FunctionType *Ty) const {
include/llvm/IR/DerivedTypes.h
  112   FunctionType(const FunctionType &) = delete;
  113   FunctionType &operator=(const FunctionType &) = delete;
  113   FunctionType &operator=(const FunctionType &) = delete;
  116   static FunctionType *get(Type *Result,
  120   static FunctionType *get(Type *Result, bool isVarArg);
  151 static_assert(alignof(FunctionType) >= alignof(Type *),
  155   return cast<FunctionType>(this)->isVarArg();
  159   return cast<FunctionType>(this)->getParamType(i);
  163   return cast<FunctionType>(this)->getNumParams();
  178   FunctionCallee(FunctionType *FnTy, Value *Callee)
  187   FunctionType *getFunctionType() { return FnTy; }
  194   FunctionType *FnTy = nullptr;
include/llvm/IR/Function.h
  122   Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
  135   static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
  142   static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
  151   static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
  163   FunctionType *getFunctionType() const {
  164     return cast<FunctionType>(getValueType());
include/llvm/IR/IRBuilder.h
  943   InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
  952   InvokeInst *CreateInvoke(FunctionType *Ty, Value *Callee,
  982         cast<FunctionType>(
  993         cast<FunctionType>(
  999   CallBrInst *CreateCallBr(FunctionType *Ty, Value *Callee,
 1007   CallBrInst *CreateCallBr(FunctionType *Ty, Value *Callee,
 2257   CallInst *CreateCall(FunctionType *FTy, Value *Callee,
 2268   CallInst *CreateCall(FunctionType *FTy, Value *Callee, ArrayRef<Value *> Args,
 2296         cast<FunctionType>(Callee->getType()->getPointerElementType()), Callee,
 2305         cast<FunctionType>(Callee->getType()->getPointerElementType()), Callee,
include/llvm/IR/InlineAsm.h
   42   FunctionType *FTy;
   47   InlineAsm(FunctionType *Ty, const std::string &AsmString,
   61   static InlineAsm *get(FunctionType *Ty, StringRef AsmString,
   78   FunctionType *getFunctionType() const;
   87   static bool Verify(FunctionType *Ty, StringRef Constraints);
include/llvm/IR/InstrTypes.h
 1111   FunctionType *FTy;
 1114   CallBase(AttributeList const &A, FunctionType *FT, ArgsTy &&... Args)
 1149   FunctionType *getFunctionType() const { return FTy; }
 1151   void mutateFunctionType(FunctionType *FTy) {
 1339   void setCalledFunction(FunctionType *FTy, Value *Fn) {
include/llvm/IR/Instructions.h
 1405   inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
 1409   inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
 1415   inline CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
 1419   explicit CallInst(FunctionType *Ty, Value *F, const Twine &NameStr,
 1422   CallInst(FunctionType *ty, Value *F, const Twine &NameStr,
 1425   void init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
 1427   void init(FunctionType *FTy, Value *Func, const Twine &NameStr);
 1443   static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr = "",
 1448   static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
 1455   static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
 1467   static CallInst *Create(FunctionType *Ty, Value *F, const Twine &NameStr,
 1472   static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
 1478   static CallInst *Create(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
 1532     return Create(cast<FunctionType>(
 1541     return Create(cast<FunctionType>(
 1551     return Create(cast<FunctionType>(
 1559     return Create(cast<FunctionType>(
 1567     return Create(cast<FunctionType>(
 1576     return Create(cast<FunctionType>(
 1687 CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
 1698 CallInst::CallInst(FunctionType *Ty, Value *Func, ArrayRef<Value *> Args,
 3672   inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
 3677   inline InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
 3682   void init(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
 3700   static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
 3710   static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
 3724   static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
 3733   static InvokeInst *Create(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
 3783     return Create(cast<FunctionType>(
 3795     return Create(cast<FunctionType>(
 3805     return Create(cast<FunctionType>(
 3815     return Create(cast<FunctionType>(
 3889 InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
 3899 InvokeInst::InvokeInst(FunctionType *Ty, Value *Func, BasicBlock *IfNormal,
 3926   inline CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
 3932   inline CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
 3938   void init(FunctionType *FTy, Value *Func, BasicBlock *DefaultDest,
 3960   static CallBrInst *Create(FunctionType *Ty, Value *Func,
 3971   static CallBrInst *Create(FunctionType *Ty, Value *Func,
 3987   static CallBrInst *Create(FunctionType *Ty, Value *Func,
 3998   static CallBrInst *Create(FunctionType *Ty, Value *Func,
 4129 CallBrInst::CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
 4140 CallBrInst::CallBrInst(FunctionType *Ty, Value *Func, BasicBlock *DefaultDest,
 4146           cast<FunctionType>(
include/llvm/IR/Intrinsics.h
   59   FunctionType *getType(LLVMContext &Context, ID id,
  184   matchIntrinsicSignature(FunctionType *FTy, ArrayRef<IITDescriptor> &Infos,
include/llvm/IR/Module.h
  345   FunctionCallee getOrInsertFunction(StringRef Name, FunctionType *T,
  348   FunctionCallee getOrInsertFunction(StringRef Name, FunctionType *T);
  362                                FunctionType::get(RetTy, ArgTys, false),
  377                       FunctionType *Invalid, ArgsTy... Args) = delete;
include/llvm/IR/Statepoint.h
  158     auto *FTy = cast<FunctionType>(
  158     auto *FTy = cast<FunctionType>(
include/llvm/Support/Casting.h
   58     return To::classof(&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) {
  265   return cast_convert_val<X, Y*,
  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) {
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
include/llvm/Support/PointerLikeTypeTraits.h
   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
lib/Analysis/Lint.cpp
  237     FunctionType *FT = F->getFunctionType();
lib/Analysis/MemoryBuiltins.cpp
  158   FunctionType *FTy = Callee->getFunctionType();
  450   FunctionType *FTy = F->getFunctionType();
lib/Analysis/StackSafetyAnalysis.cpp
  191   const FunctionType *Type = cast<FunctionType>(Aliasee->getValueType());
  191   const FunctionType *Type = cast<FunctionType>(Aliasee->getValueType());
lib/Analysis/TargetLibraryInfo.cpp
  633 bool TargetLibraryInfoImpl::isValidProtoForLibFunc(const FunctionType &FTy,
lib/Analysis/TargetTransformInfo.cpp
  155 int TargetTransformInfo::getCallCost(FunctionType *FTy, int NumArgs,
lib/AsmParser/LLParser.cpp
 1366   if (auto *FT = dyn_cast<FunctionType>(PTy->getElementType()))
 1366   if (auto *FT = dyn_cast<FunctionType>(PTy->getElementType()))
 2595     if (!FunctionType::isValidArgumentType(ArgTy))
 2647   if (!FunctionType::isValidReturnType(Result))
 2668   Result = FunctionType::get(Result, ArgListTy, isVarArg);
 5349   if (!FunctionType::isValidReturnType(RetType))
 5435   FunctionType *FT =
 5436     FunctionType::get(RetType, ParamTypeList, isVarArg);
 6068   FunctionType *Ty = dyn_cast<FunctionType>(RetType);
 6068   FunctionType *Ty = dyn_cast<FunctionType>(RetType);
 6075     if (!FunctionType::isValidReturnType(RetType))
 6078     Ty = FunctionType::get(RetType, ParamTypes, false);
 6095   FunctionType::param_iterator I = Ty->param_begin();
 6096   FunctionType::param_iterator E = Ty->param_end();
 6395   FunctionType *Ty = dyn_cast<FunctionType>(RetType);
 6395   FunctionType *Ty = dyn_cast<FunctionType>(RetType);
 6402     if (!FunctionType::isValidReturnType(RetType))
 6405     Ty = FunctionType::get(RetType, ParamTypes, false);
 6425   FunctionType::param_iterator I = Ty->param_begin();
 6426   FunctionType::param_iterator E = Ty->param_end();
 6797   FunctionType *Ty = dyn_cast<FunctionType>(RetType);
 6797   FunctionType *Ty = dyn_cast<FunctionType>(RetType);
 6804     if (!FunctionType::isValidReturnType(RetType))
 6807     Ty = FunctionType::get(RetType, ParamTypes, false);
 6825   FunctionType::param_iterator I = Ty->param_begin();
 6826   FunctionType::param_iterator E = Ty->param_end();
lib/AsmParser/LLParser.h
   62     FunctionType *FTy = nullptr;
lib/Bitcode/Reader/BitcodeReader.cpp
  497   DenseMap<Function *, FunctionType *> FunctionTypes;
 1797       ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
 1807           if (!FunctionType::isValidArgumentType(T))
 1819       ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
 2748           cast<FunctionType>(getPointerElementFlatType(CurFullTy)), AsmStr,
 2774           cast<FunctionType>(getPointerElementFlatType(CurFullTy)), AsmStr,
 3209   if (!isa<FunctionType>(FTy))
 3220       Function::Create(cast<FunctionType>(FTy), GlobalValue::ExternalLinkage,
 3225   FunctionTypes[Func] = cast<FunctionType>(FullFTy);
 3240     Type *PTy = cast<FunctionType>(FullFTy)->getParamType(i);
 3708   FunctionType *FullFTy = FunctionTypes[F];
 4476       FunctionType *FTy = nullptr;
 4477       FunctionType *FullFTy = nullptr;
 4480             dyn_cast<FunctionType>(getFullyStructuredTypeByID(Record[OpNum++]));
 4483         FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
 4495             dyn_cast<FunctionType>(cast<PointerType>(FullTy)->getElementType());
 4498         FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
 4563       FunctionType *FTy = nullptr;
 4564       FunctionType *FullFTy = nullptr;
 4567             dyn_cast<FunctionType>(getFullyStructuredTypeByID(Record[OpNum++]));
 4570         FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
 4582             dyn_cast<FunctionType>(cast<PointerType>(FullTy)->getElementType());
 4585         FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
 5004       FunctionType *FTy = nullptr;
 5005       FunctionType *FullFTy = nullptr;
 5008             dyn_cast<FunctionType>(getFullyStructuredTypeByID(Record[OpNum++]));
 5011         FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
 5023             dyn_cast<FunctionType>(cast<PointerType>(FullTy)->getElementType());
 5026         FTy = cast<FunctionType>(flattenPointerTypes(FullFTy));
lib/Bitcode/Writer/BitcodeWriter.cpp
  902       FunctionType *FT = cast<FunctionType>(T);
  902       FunctionType *FT = cast<FunctionType>(T);
 2758     FunctionType *FTy = II->getFunctionType();
 2834     FunctionType *FTy = CBI->getFunctionType();
 2991     FunctionType *FTy = CI.getFunctionType();
lib/CodeGen/AtomicExpandPass.cpp
 1773   FunctionType *FnType = FunctionType::get(ResultTy, ArgTys, false);
 1773   FunctionType *FnType = FunctionType::get(ResultTy, ArgTys, false);
lib/CodeGen/DwarfEHPrepare.cpp
  210     FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
  210     FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
lib/CodeGen/IntrinsicLowering.cpp
   42       M->getOrInsertFunction(NewFn, FunctionType::get(RetTy, ParamTys, false));
lib/CodeGen/MIRParser/MIRParser.cpp
  263       Function::Create(FunctionType::get(Type::getVoidTy(Context), false),
lib/CodeGen/MachineOutliner.cpp
 1100   Function *F = Function::Create(FunctionType::get(Type::getVoidTy(C), false),
lib/CodeGen/SelectionDAG/FastISel.cpp
 1109   FunctionType *FTy = CS.getFunctionType();
 1251   FunctionType *FuncTy = CS.getFunctionType();
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
 2533     FunctionType *FnTy = GuardCheckFn->getFunctionType();
 7100   FunctionType *FTy = CS.getFunctionType();
lib/CodeGen/SelectionDAG/StatepointLowering.cpp
  980         cast<FunctionType>(CalleeType->getElementType())->getReturnType();
lib/ExecutionEngine/ExecutionEngine.cpp
  435   FunctionType *FTy = Fn->getFunctionType();
lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp
   62 typedef GenericValue (*ExFunc)(FunctionType *, ArrayRef<GenericValue>);
  104   FunctionType *FT = F->getFunctionType();
  310 static GenericValue lle_X_atexit(FunctionType *FT,
  320 static GenericValue lle_X_exit(FunctionType *FT, ArrayRef<GenericValue> Args) {
  326 static GenericValue lle_X_abort(FunctionType *FT, ArrayRef<GenericValue> Args) {
  335 static GenericValue lle_X_sprintf(FunctionType *FT,
  417 static GenericValue lle_X_printf(FunctionType *FT,
  429 static GenericValue lle_X_sscanf(FunctionType *FT,
  444 static GenericValue lle_X_scanf(FunctionType *FT, ArrayRef<GenericValue> args) {
  459 static GenericValue lle_X_fprintf(FunctionType *FT,
  472 static GenericValue lle_X_memset(FunctionType *FT,
  484 static GenericValue lle_X_memcpy(FunctionType *FT,
lib/ExecutionEngine/MCJIT/MCJIT.cpp
  513   FunctionType *FTy = F->getFunctionType();
lib/ExecutionEngine/Orc/IndirectionUtils.cpp
  219 Constant* createIRTypedAddress(FunctionType &FT, JITTargetAddress Addr) {
  289     Function::Create(cast<FunctionType>(F.getValueType()),
lib/ExecutionEngine/Orc/OrcMCJITReplacement.cpp
   32   FunctionType *FTy = F->getFunctionType();
lib/ExecutionEngine/Orc/Speculation.cpp
   72     auto RuntimeCallTy = FunctionType::get(
lib/FuzzMutate/IRMutator.cpp
   28   Function *F = Function::Create(FunctionType::get(Type::getVoidTy(Context), {},
lib/IR/AsmWriter.cpp
  575     FunctionType *FTy = cast<FunctionType>(Ty);
  575     FunctionType *FTy = cast<FunctionType>(Ty);
  578     for (FunctionType::param_iterator I = FTy->param_begin(),
 3445   FunctionType *FT = F->getFunctionType();
 3847     FunctionType *FTy = CI->getFunctionType();
 3886     FunctionType *FTy = II->getFunctionType();
 3929     FunctionType *FTy = CBI->getFunctionType();
lib/IR/AutoUpgrade.cpp
  515       FunctionType* fType = FunctionType::get(F->getReturnType(), args, false);
  515       FunctionType* fType = FunctionType::get(F->getReturnType(), args, false);
  531       FunctionType* fType = FunctionType::get(F->getReturnType(), Tys, false);
  531       FunctionType* fType = FunctionType::get(F->getReturnType(), Tys, false);
  725       const auto *FT = F->getFunctionType();
 3877       FunctionType *NewFuncTy = NewFn->getFunctionType();
lib/IR/ConstantsContext.h
  415   FunctionType *FTy;
  421                    FunctionType *FTy, bool HasSideEffects, bool IsAlignStack,
lib/IR/Core.cpp
  460   return wrap(InlineAsm::get(unwrap<FunctionType>(Ty),
  646   return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0));
  650   return unwrap<FunctionType>(FunctionTy)->isVarArg();
  654   return wrap(unwrap<FunctionType>(FunctionTy)->getReturnType());
  658   return unwrap<FunctionType>(FunctionTy)->getNumParams();
  662   FunctionType *Ty = unwrap<FunctionType>(FunctionTy);
  662   FunctionType *Ty = unwrap<FunctionType>(FunctionTy);
  663   for (FunctionType::param_iterator I = Ty->param_begin(),
 1810   return wrap(InlineAsm::get(dyn_cast<FunctionType>(unwrap(Ty)), AsmString,
 2256   return wrap(Function::Create(unwrap<FunctionType>(FunctionTy),
 3113   FunctionType *FnT =
 3114       cast<FunctionType>(cast<PointerType>(V->getType())->getElementType());
 3126       unwrap<FunctionType>(Ty), unwrap(Fn), unwrap(Then), unwrap(Catch),
 3842   FunctionType *FnT =
 3843       cast<FunctionType>(cast<PointerType>(V->getType())->getElementType());
 3852   FunctionType *FTy = unwrap<FunctionType>(Ty);
 3852   FunctionType *FTy = unwrap<FunctionType>(Ty);
lib/IR/Function.cpp
  217 Function *Function::Create(FunctionType *Ty, LinkageTypes Linkage,
  242 Function::Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
  284   auto *FT = getFunctionType();
  607   } else if (FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
  607   } else if (FunctionType *FT = dyn_cast<FunctionType>(Ty)) {
 1049 FunctionType *Intrinsic::getType(LLVMContext &Context,
 1065     return FunctionType::get(ResultTy, ArgTys, true);
 1067   return FunctionType::get(ResultTy, ArgTys, false);
 1344 Intrinsic::matchIntrinsicSignature(FunctionType *FTy,
 1394   FunctionType *FTy = F->getFunctionType();
lib/IR/InlineAsm.cpp
   30 InlineAsm::InlineAsm(FunctionType *FTy, const std::string &asmString,
   42 InlineAsm *InlineAsm::get(FunctionType *FTy, StringRef AsmString,
   56 FunctionType *InlineAsm::getFunctionType() const {
  253 bool InlineAsm::Verify(FunctionType *Ty, StringRef ConstStr) {
lib/IR/Instructions.cpp
  385 void CallInst::init(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
  412 void CallInst::init(FunctionType *FTy, Value *Func, const Twine &NameStr) {
  422 CallInst::CallInst(FunctionType *Ty, Value *Func, const Twine &Name,
  429 CallInst::CallInst(FunctionType *Ty, Value *Func, const Twine &Name,
  716 void InvokeInst::init(FunctionType *FTy, Value *Fn, BasicBlock *IfNormal,
  783 void CallBrInst::init(FunctionType *FTy, Value *Fn, BasicBlock *Fallthrough,
lib/IR/LLVMContextImpl.h
  157     KeyTy(const FunctionType *FT)
  175   static inline FunctionType* getEmptyKey() {
  176     return DenseMapInfo<FunctionType*>::getEmptyKey();
  179   static inline FunctionType* getTombstoneKey() {
  180     return DenseMapInfo<FunctionType*>::getTombstoneKey();
  190   static unsigned getHashValue(const FunctionType *FT) {
  194   static bool isEqual(const KeyTy& LHS, const FunctionType *RHS) {
  200   static bool isEqual(const FunctionType *LHS, const FunctionType *RHS) {
  200   static bool isEqual(const FunctionType *LHS, const FunctionType *RHS) {
 1329   using FunctionTypeSet = DenseSet<FunctionType *, FunctionTypeKeyInfo>;
lib/IR/Mangler.cpp
  169   FunctionType *FT = MSFunc->getFunctionType();
lib/IR/Module.cpp
  143 FunctionCallee Module::getOrInsertFunction(StringRef Name, FunctionType *Ty,
  167 FunctionCallee Module::getOrInsertFunction(StringRef Name, FunctionType *Ty) {
lib/IR/Type.cpp
  301 FunctionType *FunctionType::get(Type *ReturnType,
  305   FunctionType *FT;
  316         sizeof(FunctionType) + sizeof(Type *) * (Params.size() + 1),
  317         alignof(FunctionType));
  318     new (FT) FunctionType(ReturnType, Params, isVarArg);
  327 FunctionType *FunctionType::get(Type *Result, bool isVarArg) {
lib/IR/Verifier.cpp
  505   void verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs,
  646           FunctionType::get(Type::getVoidTy(Context), false)->
 1688 void Verifier::verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs,
 1961   FunctionType *TargetFuncType = cast<FunctionType>(PT->getElementType());
 1961   FunctionType *TargetFuncType = cast<FunctionType>(PT->getElementType());
 2138   FunctionType *FT = F.getFunctionType();
 2828   FunctionType *FTy = Call.getFunctionType();
 3056   FunctionType *CallerTy = F->getFunctionType();
 3057   FunctionType *CalleeTy = CI.getFunctionType();
 4239   FunctionType *IFTy = IF->getFunctionType();
 4491     auto *TargetFuncType = cast<FunctionType>(PT->getElementType());
 4491     auto *TargetFuncType = cast<FunctionType>(PT->getElementType());
lib/Linker/IRMover.cpp
   69   FunctionType *get(FunctionType *T) {
   69   FunctionType *get(FunctionType *T) {
   70     return cast<FunctionType>(get((Type *)T));
  168   } else if (FunctionType *FT = dyn_cast<FunctionType>(DstTy)) {
  168   } else if (FunctionType *FT = dyn_cast<FunctionType>(DstTy)) {
  169     if (FT->isVarArg() != cast<FunctionType>(SrcTy)->isVarArg())
  313     return *Entry = FunctionType::get(ElementTypes[0],
  315                                       cast<FunctionType>(Ty)->isVarArg());
  697           Function::Create(cast<FunctionType>(TypeMap.get(SGV->getValueType())),
lib/Linker/LinkModules.cpp
  443     if (auto *FTy = dyn_cast<FunctionType>(Alias.getValueType())) {
  443     if (auto *FTy = dyn_cast<FunctionType>(Alias.getValueType())) {
lib/Target/AArch64/AArch64Subtarget.cpp
  240   if (AllowTaggedGlobals && !isa<FunctionType>(GV->getValueType()))
lib/Target/AMDGPU/AMDGPULibCalls.cpp
  616   auto *FTy = FunctionType::get(Callee->getReturnType(),
  616   auto *FTy = FunctionType::get(Callee->getReturnType(),
lib/Target/AMDGPU/AMDGPULibFunc.cpp
  914 FunctionType *AMDGPUMangledLibFunc::getFunctionType(Module &M) const {
  922   return FunctionType::get(
  969   FunctionType *FuncTy = fInfo.getFunctionType(*M);
  972   for (FunctionType::param_iterator
 1041 AMDGPULibFunc::AMDGPULibFunc(StringRef Name, FunctionType *FT) {
lib/Target/AMDGPU/AMDGPULibFunc.h
  347   virtual FunctionType *getFunctionType(Module &M) const = 0;
  364   explicit AMDGPULibFunc(StringRef FName, FunctionType *FT);
  391   FunctionType *getFunctionType(Module &M) const {
  416   FunctionType *getFunctionType(Module &M) const override;
  436   FunctionType *FuncTy;
  440   explicit AMDGPUUnmangledLibFunc(StringRef FName, FunctionType *FT) {
  446   FunctionType *getFunctionType(Module &M) const override { return FuncTy; }
  455   void setFunctionType(FunctionType *FT) { FuncTy = FT; }
lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp
  329       FunctionType *FTy_alloc = FunctionType::get(I8Ptr, Tys_alloc, false);
  329       FunctionType *FTy_alloc = FunctionType::get(I8Ptr, Tys_alloc, false);
lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp
  626   FunctionType *FTy = F.getFunctionType();
lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp
  357   FunctionType *NewFuncTy = FunctionType::get(NewRetTy,
  357   FunctionType *NewFuncTy = FunctionType::get(NewRetTy,
lib/Target/AMDGPU/R600OpenCLImageTypeLoweringPass.cpp
  272     FunctionType *FT = F->getFunctionType();
  305     auto NewFT = FunctionType::get(FT->getReturnType(), ArgTypes, false);
lib/Target/AMDGPU/SIISelLowering.cpp
 1567                                    FunctionType *FType,
 2025   FunctionType *FType = MF.getFunction().getFunctionType();
lib/Target/ARM/ARMFastISel.cpp
 2310   FunctionType *FTy = CS.getFunctionType();
lib/Target/Mips/Mips16HardFloat.cpp
   50   FunctionType *AsmFTy =
   51       FunctionType::get(Type::getVoidTy(C), AsmArgTypes, false);
  175 static bool needsFPReturnHelper(FunctionType &FT) {
  420         FunctionType *FT = CI->getFunctionType();
lib/Target/NVPTX/NVPTXAsmPrinter.cpp
 1398   auto *FTy = dyn_cast<FunctionType>(Ty);
 1398   auto *FTy = dyn_cast<FunctionType>(Ty);
lib/Target/RISCV/RISCVISelLowering.cpp
 1622   FunctionType *FType = MF.getFunction().getFunctionType();
lib/Target/WebAssembly/WebAssemblyAddMissingPrototypes.cpp
   91     FunctionType *NewType = nullptr;
   96         if (auto *DestType = dyn_cast<FunctionType>(
   96         if (auto *DestType = dyn_cast<FunctionType>(
  122       NewType = FunctionType::get(F.getFunctionType()->getReturnType(), false);
lib/Target/WebAssembly/WebAssemblyFastISel.cpp
  761   FunctionType *FuncTy = Call->getFunctionType();
lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp
  118 static Function *createWrapper(Function *F, FunctionType *Ty) {
  130   FunctionType::param_iterator PI = F->getFunctionType()->param_begin();
  131   FunctionType::param_iterator PE = F->getFunctionType()->param_end();
  228 static bool shouldFixMainFunction(FunctionType *FuncTy, FunctionType *MainTy) {
  228 static bool shouldFixMainFunction(FunctionType *FuncTy, FunctionType *MainTy) {
  258       FunctionType *MainTy = FunctionType::get(Type::getInt32Ty(C), MainArgTys,
  258       FunctionType *MainTy = FunctionType::get(Type::getInt32Ty(C), MainArgTys,
  274   DenseMap<std::pair<Function *, FunctionType *>, Function *> Wrappers;
  280     auto *Ty = dyn_cast<FunctionType>(PTy->getElementType());
  280     auto *Ty = dyn_cast<FunctionType>(PTy->getElementType());
lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp
  330 static std::string getSignature(FunctionType *FTy) {
  358   FunctionType *FTy = FunctionType::get(Int8PtrTy, Args, false);
  358   FunctionType *FTy = FunctionType::get(Int8PtrTy, Args, false);
  450   FunctionType *CalleeFTy;
  455     CalleeFTy = dyn_cast<FunctionType>(CalleeTy);
  467   FunctionType *FTy = FunctionType::get(CalleeFTy->getReturnType(), ArgTys,
  467   FunctionType *FTy = FunctionType::get(CalleeFTy->getReturnType(), ArgTys,
  642       Function::Create(FunctionType::get(IRB.getInt32Ty(), false),
  645       FunctionType::get(IRB.getVoidTy(), IRB.getInt32Ty(), false),
  655     FunctionType *ResumeFTy =
  656         FunctionType::get(IRB.getVoidTy(), IRB.getInt8PtrTy(), false);
  661     FunctionType *EHTypeIDTy =
  662         FunctionType::get(IRB.getInt32Ty(), IRB.getInt8PtrTy(), false);
  689       FunctionType *SetjmpFTy = SetjmpF->getFunctionType();
  693       FunctionType *FTy =
  694           FunctionType::get(Type::getInt32PtrTy(C), Params, false);
  700       FTy = FunctionType::get(IRB.getInt32Ty(), Params, false);
  704       FTy = FunctionType::get(IRB.getVoidTy(),
lib/Target/WebAssembly/WebAssemblyLowerGlobalDtors.cpp
  108   FunctionType *AtExitFuncTy =
  109       FunctionType::get(Type::getVoidTy(C), AtExitFuncArgs,
  114       FunctionType::get(Type::getInt32Ty(C),
  146       FunctionType *VoidVoid = FunctionType::get(Type::getVoidTy(C),
  146       FunctionType *VoidVoid = FunctionType::get(Type::getVoidTy(C),
lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp
   52   if (const auto *FuncTy = dyn_cast<FunctionType>(Global->getValueType())) {
   52   if (const auto *FuncTy = dyn_cast<FunctionType>(Global->getValueType())) {
lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.cpp
   45 void llvm::computeSignatureVTs(const FunctionType *Ty, const Function &F,
lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.h
  144 void computeSignatureVTs(const FunctionType *Ty, const Function &F,
lib/Target/X86/X86ISelLowering.cpp
24449       FunctionType *FTy = Func->getFunctionType();
24456         for (FunctionType::param_iterator I = FTy->param_begin(),
lib/Target/X86/X86RetpolineThunks.cpp
  200   auto Type = FunctionType::get(Type::getVoidTy(Ctx), false);
lib/Target/X86/X86WinEHState.cpp
  176       "_setjmp3", FunctionType::get(
  303         FunctionType::get(VoidTy, Int8PtrType, /*isVarArg=*/false));
  358         FunctionType::get(Type::getVoidTy(TheModule->getContext()), Int8PtrType,
  395   FunctionType *TrampolineTy =
  396       FunctionType::get(Int32Ty, makeArrayRef(&ArgTys[0], 4),
  398   FunctionType *TargetFuncTy =
  399       FunctionType::get(Int32Ty, makeArrayRef(&ArgTys[0], 5),
lib/Transforms/CFGuard/CFGuard.cpp
  151   FunctionType *GuardFnType = nullptr;
  238   GuardFnType = FunctionType::get(Type::getVoidTy(M.getContext()),
lib/Transforms/Coroutines/CoroEarly.cpp
   39         AnyResumeFnPtrTy(FunctionType::get(Type::getVoidTy(Context), Int8Ptr,
  116     auto *FnTy = FunctionType::get(Type::getVoidTy(C), FramePtrTy,
  116     auto *FnTy = FunctionType::get(Type::getVoidTy(C), FramePtrTy,
lib/Transforms/Coroutines/CoroFrame.cpp
  409     auto *FnTy = FunctionType::get(Type::getVoidTy(C), FramePtrTy,
  409     auto *FnTy = FunctionType::get(Type::getVoidTy(C), FramePtrTy,
 1166   auto FnTy = FunctionType::get(ValueTy, {}, false);
 1181   auto FnTy = FunctionType::get(V->getType()->getPointerTo(),
lib/Transforms/Coroutines/CoroInternal.h
   58   FunctionType *const ResumeFnType;
  158   FunctionType *getResumeFunctionType() const {
  162       return cast<FunctionType>(FnPtrTy->getPointerElementType());
lib/Transforms/Coroutines/CoroSplit.cpp
  397   auto *FnTy = Shape.getResumeFunctionType();
 1402   FunctionType *FnTy = FunctionType::get(Type::getVoidTy(Context),
 1402   FunctionType *FnTy = FunctionType::get(Type::getVoidTy(Context),
 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
   97       ResumeFnType(FunctionType::get(Type::getVoidTy(Context), Int8Ptr,
lib/Transforms/IPO/ArgumentPromotion.cpp
  111   FunctionType *FTy = F->getFunctionType();
  215   FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg());
  215   FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg());
lib/Transforms/IPO/DeadArgumentElimination.cpp
  158   FunctionType *FTy = Fn.getFunctionType();
  161   FunctionType *NFTy = FunctionType::get(FTy->getReturnType(),
  161   FunctionType *NFTy = FunctionType::get(FTy->getReturnType(),
  736   FunctionType *FTy = F->getFunctionType();
  858   FunctionType *NFTy = FunctionType::get(NRetTy, Params, FTy->isVarArg());
  858   FunctionType *NFTy = FunctionType::get(NRetTy, Params, FTy->isVarArg());
lib/Transforms/IPO/ExtractGV.cpp
  135           if (FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
  135           if (FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
lib/Transforms/IPO/FunctionImport.cpp
  926           Function::Create(cast<FunctionType>(GV.getValueType()),
lib/Transforms/IPO/LowerTypeTests.cpp
 1252         FunctionType::get(Type::getVoidTy(M.getContext()),
 1298       Function::Create(cast<FunctionType>(F->getValueType()),
 1392       InlineAsm::get(FunctionType::get(IRB.getVoidTy(), ArgTypes, false),
 1489       Function::Create(FunctionType::get(Type::getVoidTy(M.getContext()),
 1903               FunctionType::get(Type::getVoidTy(M.getContext()), false),
lib/Transforms/IPO/MergeFunctions.cpp
  707   FunctionType *FFTy = F->getFunctionType();
lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp
  141   FunctionType *EmptyFT =
  142       FunctionType::get(Type::getVoidTy(M.getContext()), false);
lib/Transforms/IPO/WholeProgramDevirt.cpp
 1050   FunctionType *FT =
 1051       FunctionType::get(Type::getVoidTy(M.getContext()), {Int8PtrTy}, true);
 1112       FunctionType *NewFT =
 1113           FunctionType::get(CS.getFunctionType()->getReturnType(), NewArgs,
lib/Transforms/InstCombine/InstCombineCalls.cpp
 3933     FunctionType *AssumeIntrinsicTy = II->getFunctionType();
 4360   FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
 4360   FunctionType *FTy = cast<FunctionType>(PTy->getElementType());
 4432   FunctionType *FT = Callee->getFunctionType();
 4528     if (FT->isVarArg()!=cast<FunctionType>(APTy->getElementType())->isVarArg())
 4535         cast<FunctionType>(APTy->getElementType())->isVarArg() &&
 4537         cast<FunctionType>(APTy->getElementType())->getNumParams())
 4697   FunctionType *FTy = Call.getFunctionType();
 4706   FunctionType *NestFTy = NestF->getFunctionType();
 4715     for (FunctionType::param_iterator I = NestFTy->param_begin(),
 4772         FunctionType::param_iterator I = FTy->param_begin(),
 4793       FunctionType *NewFTy = FunctionType::get(FTy->getReturnType(), NewTypes,
 4793       FunctionType *NewFTy = FunctionType::get(FTy->getReturnType(), NewTypes,
lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
 1031   FunctionType *FTy = II->getCalledFunction()->getFunctionType();
lib/Transforms/Instrumentation/AddressSanitizer.cpp
 2032       Function::Create(FunctionType::get(Type::getVoidTy(*C), false),
 2488           FunctionType::get(IRB.getVoidTy(), Args2, false));
 2492           FunctionType::get(IRB.getVoidTy(), Args2, false));
 2500                 FunctionType::get(IRB.getVoidTy(), Args1, false));
 2505                 FunctionType::get(IRB.getVoidTy(), Args1, false));
 2530   EmptyAsm = InlineAsm::get(FunctionType::get(IRB.getVoidTy(), false),
 2567           FunctionType::get(IntptrTy, {AsanShadowGlobal->getType()}, false),
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp
  199     if (isa<FunctionType>(GA.getValueType()))
  217   TransformedFunction(FunctionType* OriginalType,
  218                       FunctionType* TransformedType,
  233   FunctionType *OriginalType;
  236   FunctionType *TransformedType;
  335   FunctionType *GetArgTLSTy;
  336   FunctionType *GetRetvalTLSTy;
  340   FunctionType *DFSanUnionFnTy;
  341   FunctionType *DFSanUnionLoadFnTy;
  342   FunctionType *DFSanUnimplementedFnTy;
  343   FunctionType *DFSanSetLabelFnTy;
  344   FunctionType *DFSanNonzeroLabelFnTy;
  345   FunctionType *DFSanVarargWrapperFnTy;
  362   FunctionType *getArgsFunctionType(FunctionType *T);
  362   FunctionType *getArgsFunctionType(FunctionType *T);
  363   FunctionType *getTrampolineFunctionType(FunctionType *T);
  363   FunctionType *getTrampolineFunctionType(FunctionType *T);
  364   TransformedFunction getCustomFunctionType(FunctionType *T);
  370                                  FunctionType *NewFT);
  371   Constant *getOrBuildTrampolineFunction(FunctionType *FT, StringRef FName);
  485 FunctionType *DataFlowSanitizer::getArgsFunctionType(FunctionType *T) {
  485 FunctionType *DataFlowSanitizer::getArgsFunctionType(FunctionType *T) {
  493   return FunctionType::get(RetType, ArgTypes, T->isVarArg());
  496 FunctionType *DataFlowSanitizer::getTrampolineFunctionType(FunctionType *T) {
  496 FunctionType *DataFlowSanitizer::getTrampolineFunctionType(FunctionType *T) {
  505   return FunctionType::get(T->getReturnType(), ArgTypes, false);
  508 TransformedFunction DataFlowSanitizer::getCustomFunctionType(FunctionType *T) {
  518     FunctionType *FT;
  519     if (isa<PointerType>(param_type) && (FT = dyn_cast<FunctionType>(
  537       T, FunctionType::get(T->getReturnType(), ArgTypes, T->isVarArg()),
  569       FunctionType::get(ShadowTy, DFSanUnionArgs, /*isVarArg=*/ false);
  572       FunctionType::get(ShadowTy, DFSanUnionLoadArgs, /*isVarArg=*/ false);
  573   DFSanUnimplementedFnTy = FunctionType::get(
  576   DFSanSetLabelFnTy = FunctionType::get(Type::getVoidTy(*Ctx),
  578   DFSanNonzeroLabelFnTy = FunctionType::get(
  580   DFSanVarargWrapperFnTy = FunctionType::get(
  586     GetArgTLSTy = FunctionType::get(PointerType::getUnqual(ArgTLSTy), false);
  593     GetRetvalTLSTy = FunctionType::get(PointerType::getUnqual(ShadowTy), false);
  648                                         FunctionType *NewFT) {
  649   FunctionType *FT = F->getFunctionType();
  680 Constant *DataFlowSanitizer::getOrBuildTrampolineFunction(FunctionType *FT,
  682   FunctionType *FTT = getTrampolineFunctionType(FT);
  830     FunctionType *FT = F.getFunctionType();
  839         FunctionType *NewFT = getArgsFunctionType(FT);
  877       FunctionType *NewFT = getInstrumentedABI() == IA_Args
 1573         FunctionType *FT = F->getFunctionType();
 1594           FunctionType *ParamFT;
 1596               (ParamFT = dyn_cast<FunctionType>(
 1672   FunctionType *FT = cast<FunctionType>(
 1672   FunctionType *FT = cast<FunctionType>(
 1708     FunctionType *NewFT = DFSF.DFS.getArgsFunctionType(FT);
lib/Transforms/Instrumentation/GCOVProfiling.cpp
  657     FunctionType *FTy = FunctionType::get(Builder.getVoidTy(), {}, false);
  657     FunctionType *FTy = FunctionType::get(Builder.getVoidTy(), {}, false);
  854     FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
  854     FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
  866     FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
  871     FTy = FunctionType::get(Builder.getVoidTy(), Params, false);
  891   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
  891   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
  907   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
  907   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
  923   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
  923   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
  931   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
  931   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
  936   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);
  942   FunctionType *WriteoutFTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
 1191   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
 1191   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp
  442         FunctionType::get(IRB.getVoidTy(), {IntptrTy, IntptrTy}, false));
  450               FunctionType::get(IRB.getVoidTy(), {IntptrTy}, false));
  485       FunctionType::get(Int8PtrTy, {ShadowGlobal->getType()}, false),
  679           FunctionType::get(IRB.getVoidTy(), {PtrLong->getType()}, false),
  688           FunctionType::get(IRB.getVoidTy(), {PtrLong->getType()}, false),
 1467     FunctionType *ThunkFnTy = FunctionType::get(
 1467     FunctionType *ThunkFnTy = FunctionType::get(
lib/Transforms/Instrumentation/InstrProfiling.cpp
  565     auto *ValueProfilingCallTy =
  566         FunctionType::get(ReturnTy, makeArrayRef(ParamTypes), false);
  576     auto *ValueRangeProfilingCallTy =
  577         FunctionType::get(ReturnTy, makeArrayRef(RangeParamTypes), false);
  949   auto *RegisterFTy = FunctionType::get(VoidTy, false);
  949   auto *RegisterFTy = FunctionType::get(VoidTy, false);
  956   auto *RuntimeRegisterTy = FunctionType::get(VoidTy, VoidPtrTy, false);
  956   auto *RuntimeRegisterTy = FunctionType::get(VoidTy, VoidPtrTy, false);
  968     auto *NamesRegisterTy =
  969         FunctionType::get(VoidTy, makeArrayRef(ParamTypes), false);
  997   auto *User = Function::Create(FunctionType::get(Int32Ty, false),
 1034   auto *F = Function::Create(FunctionType::get(VoidTy, false),
lib/Transforms/Instrumentation/MemorySanitizer.cpp
  836   EmptyAsm = InlineAsm::get(FunctionType::get(IRB.getVoidTy(), false),
 3346     FunctionType *FT = CS.getFunctionType();
lib/Transforms/Instrumentation/SanitizerCoverage.cpp
  443   EmptyAsm = InlineAsm::get(FunctionType::get(IRB.getVoidTy(), false),
lib/Transforms/ObjCARC/ObjCARCContract.cpp
  320 createCallInst(FunctionType *FTy, Value *Func, ArrayRef<Value *> Args,
  495           InlineAsm::get(FunctionType::get(Type::getVoidTy(Inst->getContext()),
lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
 1471       auto *FTy = FunctionType::get(Type::getVoidTy(F->getContext()), DomainTy,
 1471       auto *FTy = FunctionType::get(Type::getVoidTy(F->getContext()), DomainTy,
 1899       "__tmp_use", FunctionType::get(Type::getVoidTy(M->getContext()), true));
lib/Transforms/Utils/BuildLibCalls.cpp
  837   FunctionType *FuncType = FunctionType::get(ReturnType, ParamTypes, IsVaArgs);
  837   FunctionType *FuncType = FunctionType::get(ReturnType, ParamTypes, IsVaArgs);
lib/Transforms/Utils/CloneFunction.cpp
  249   FunctionType *FTy = FunctionType::get(F->getFunctionType()->getReturnType(),
  249   FunctionType *FTy = FunctionType::get(F->getFunctionType()->getReturnType(),
lib/Transforms/Utils/CloneModule.cpp
   77         Function::Create(cast<FunctionType>(I.getValueType()), I.getLinkage(),
   93         GV = Function::Create(cast<FunctionType>(I->getValueType()),
lib/Transforms/Utils/CodeExtractor.cpp
  814   FunctionType *funcType =
  815                   FunctionType::get(RetTy, paramTy,
lib/Transforms/Utils/EntryExitInstrumenter.cpp
   43         Func, FunctionType::get(Type::getVoidTy(C), ArgTypes, false));
lib/Transforms/Utils/EscapeEnumerator.cpp
   26                                 FunctionType::get(Type::getInt32Ty(C), true));
lib/Transforms/Utils/Evaluator.cpp
  289   auto *FTy = F->getFunctionType();
  316   if (auto *FT =
  317           dyn_cast<FunctionType>(CE->getType()->getPointerElementType())) {
lib/Transforms/Utils/FunctionComparator.cpp
  461     FunctionType *FTyL = cast<FunctionType>(TyL);
  461     FunctionType *FTyL = cast<FunctionType>(TyL);
  462     FunctionType *FTyR = cast<FunctionType>(TyR);
  462     FunctionType *FTyR = cast<FunctionType>(TyR);
lib/Transforms/Utils/ModuleUtils.cpp
   25   FunctionType *FnTy = FunctionType::get(IRB.getVoidTy(), false);
   25   FunctionType *FnTy = FunctionType::get(IRB.getVoidTy(), false);
  115       FunctionType::get(Type::getVoidTy(M.getContext()), InitArgTypes, false),
  129       FunctionType::get(Type::getVoidTy(M.getContext()), false),
  136         VersionCheckName, FunctionType::get(IRB.getVoidTy(), {}, false),
lib/Transforms/Utils/SanitizerStats.cpp
   57   FunctionType *StatReportTy =
   58       FunctionType::get(B.getVoidTy(), Int8PtrTy, false);
   94   auto F = Function::Create(FunctionType::get(VoidTy, false),
   99   FunctionType *StatInitTy = FunctionType::get(VoidTy, Int8PtrTy, false);
   99   FunctionType *StatInitTy = FunctionType::get(VoidTy, Int8PtrTy, false);
lib/Transforms/Utils/SimplifyLibCalls.cpp
   75     auto *FuncTy = CI->getFunctionType();
  341   FunctionType *FT = Callee->getFunctionType();
 2381   FunctionType *FT = Callee->getFunctionType();
 2476   FunctionType *FT = Callee->getFunctionType();
 2649   FunctionType *FT = Callee->getFunctionType();
lib/Transforms/Utils/ValueMapper.cpp
  366     FunctionType *NewTy = IA->getFunctionType();
  368       NewTy = cast<FunctionType>(TypeMapper->remapType(NewTy));
  893     FunctionType *FTy = CS.getFunctionType();
  897     CS.mutateFunctionType(FunctionType::get(
lib/Transforms/Vectorize/LoopVectorize.cpp
 4310           FunctionType *FTy = FunctionType::get(RetTy, Tys, false);
 4310           FunctionType *FTy = FunctionType::get(RetTy, Tys, false);
tools/bugpoint/Miscompilation.cpp
  390       std::vector<std::pair<std::string, FunctionType *>> MisCompFunctions;
  413     std::vector<std::pair<std::string, FunctionType *>> MisCompFunctions;
  585   std::vector<std::pair<std::string, FunctionType *>> MisCompFunctions;
  870           FunctionType *FuncTy = F->getFunctionType();
tools/clang/include/clang/CodeGen/CodeGenABITypes.h
   75 llvm::FunctionType *convertFreeFunctionType(CodeGenModule &CGM,
tools/clang/lib/CodeGen/Address.h
  108 template <class U> inline U cast(CodeGen::Address addr) {
tools/clang/lib/CodeGen/CGAtomic.cpp
  308   llvm::FunctionType *fnTy = CGF.CGM.getTypes().GetFunctionType(fnInfo);
tools/clang/lib/CodeGen/CGBlocks.cpp
 1445     auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.VoidTy,
 1571   llvm::FunctionType *fnLLVMType = CGM.getTypes().GetFunctionType(fnInfo);
 2017   llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI);
 2210   llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI);
 2460   llvm::FunctionType *LTy = CGF.CGM.getTypes().GetFunctionType(FI);
 2535   llvm::FunctionType *LTy = CGF.CGM.getTypes().GetFunctionType(FI);
 2987   llvm::FunctionType *fty
 2988     = llvm::FunctionType::get(VoidTy, args, false);
 3000   llvm::FunctionType *fty
 3001     = llvm::FunctionType::get(VoidTy, args, false);
tools/clang/lib/CodeGen/CGBuiltin.cpp
   85   llvm::FunctionType *Ty =
   86     cast<llvm::FunctionType>(getTypes().ConvertType(FD->getType()));
  718   llvm::FunctionType *FTy =
  719       llvm::FunctionType::get(CGF.Int8Ty, {IntPtrType, IntType}, false);
  860       llvm::FunctionType::get(CGF.IntTy, ArgTypes, IsVarArg), Name,
 1066     llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, {Int32Ty}, false);
 1066     llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, {Int32Ty}, false);
 1166   llvm::FunctionType *FuncTy = CGM.getTypes().GetFunctionType(FI);
 1849     llvm::FunctionType *LLVMFuncType = llvm::FunctionType::get(
 1849     llvm::FunctionType *LLVMFuncType = llvm::FunctionType::get(
 2886     llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FuncInfo);
 3583       llvm::FunctionType *FTy = llvm::FunctionType::get(
 3583       llvm::FunctionType *FTy = llvm::FunctionType::get(
 3599       llvm::FunctionType *FTy = llvm::FunctionType::get(
 3599       llvm::FunctionType *FTy = llvm::FunctionType::get(
 3643     llvm::FunctionType *FTy = llvm::FunctionType::get(
 3643     llvm::FunctionType *FTy = llvm::FunctionType::get(
 3683     llvm::FunctionType *FTy =
 3684         llvm::FunctionType::get(llvm::Type::getVoidTy(getLLVMContext()),
 3709     llvm::FunctionType *FTy = llvm::FunctionType::get(
 3709     llvm::FunctionType *FTy = llvm::FunctionType::get(
 3726     auto FTy = llvm::FunctionType::get(NewRetT, {NewArgT}, false);
 3762       llvm::FunctionType *FTy = llvm::FunctionType::get(
 3762       llvm::FunctionType *FTy = llvm::FunctionType::get(
 3836       llvm::FunctionType *FTy = llvm::FunctionType::get(
 3836       llvm::FunctionType *FTy = llvm::FunctionType::get(
 3895         llvm::FunctionType *FTy = llvm::FunctionType::get(
 3895         llvm::FunctionType *FTy = llvm::FunctionType::get(
 3912       llvm::FunctionType *FTy = llvm::FunctionType::get(
 3912       llvm::FunctionType *FTy = llvm::FunctionType::get(
 3934             llvm::FunctionType::get(IntTy, {GenericVoidPtrTy, GenericVoidPtrTy},
 3948             llvm::FunctionType::get(IntTy, {GenericVoidPtrTy, GenericVoidPtrTy},
 3969             llvm::FunctionType::get(
 4157     llvm::FunctionType *FTy = F->getFunctionType();
 6016     llvm::FunctionType *FTy =
 6017         llvm::FunctionType::get(VoidTy, /*Variadic=*/false);
 6075     llvm::FunctionType *FTy = cast<llvm::FunctionType>(Ty);
 6075     llvm::FunctionType *FTy = cast<llvm::FunctionType>(Ty);
 7147     llvm::FunctionType *FTy = cast<llvm::FunctionType>(Ty);
 7147     llvm::FunctionType *FTy = cast<llvm::FunctionType>(Ty);
10146   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy,
10146   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy,
12314     llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
12314     llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
tools/clang/lib/CodeGen/CGCUDANV.cpp
   68   llvm::FunctionType *getRegisterGlobalsFnTy() const;
   69   llvm::FunctionType *getCallbackFnTy() const;
   70   llvm::FunctionType *getRegisterLinkedBinaryFnTy() const;
  103   llvm::Function *makeDummyFunction(llvm::FunctionType *FnTy) {
  175       llvm::FunctionType::get(IntTy, Params, false),
  183         llvm::FunctionType::get(IntTy, CharPtrTy, false), "hipLaunchByPtr");
  187         llvm::FunctionType::get(IntTy, CharPtrTy, false), "cudaLaunch");
  191 llvm::FunctionType *CGNVCUDARuntime::getRegisterGlobalsFnTy() const {
  192   return llvm::FunctionType::get(VoidTy, VoidPtrPtrTy, false);
  195 llvm::FunctionType *CGNVCUDARuntime::getCallbackFnTy() const {
  196   return llvm::FunctionType::get(VoidTy, VoidPtrTy, false);
  199 llvm::FunctionType *CGNVCUDARuntime::getRegisterLinkedBinaryFnTy() const {
  204   return llvm::FunctionType::get(VoidTy, Params, false);
  303       llvm::FunctionType::get(IntTy,
  332   llvm::FunctionType *FTy = dyn_cast<llvm::FunctionType>(Ty);
  332   llvm::FunctionType *FTy = dyn_cast<llvm::FunctionType>(Ty);
  413       llvm::FunctionType::get(IntTy, RegisterFuncParams, false),
  443       llvm::FunctionType::get(IntTy, RegisterVarParams, false),
  506       llvm::FunctionType::get(VoidPtrPtrTy, VoidPtrTy, false),
  529       llvm::FunctionType::get(VoidTy, VoidPtrTy, false),
  685           llvm::FunctionType::get(VoidTy, VoidPtrPtrTy, false),
  721     llvm::FunctionType *AtExitTy =
  722         llvm::FunctionType::get(IntTy, CleanupFn->getType(), false);
  759       llvm::FunctionType::get(VoidTy, VoidPtrPtrTy, false),
  763       llvm::FunctionType::get(VoidTy, VoidPtrTy, false),
tools/clang/lib/CodeGen/CGCXX.cpp
  221     GlobalDecl GD, const CGFunctionInfo *FnInfo, llvm::FunctionType *FnType,
tools/clang/lib/CodeGen/CGCXXABI.cpp
   51   llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
tools/clang/lib/CodeGen/CGCall.cpp
 1056     QualType Ty, CallArg Arg, llvm::FunctionType *IRFuncTy,
 1535 llvm::FunctionType *CodeGenTypes::GetFunctionType(GlobalDecl GD) {
 1540 llvm::FunctionType *
 1666   return llvm::FunctionType::get(resultType, ArgTypes, FI.isVariadic());
 3794   llvm::FunctionType *IRFuncTy = getTypes().GetFunctionType(CallInfo);
 4250     llvm::FunctionType *OrigFT = OrigFn->getFunctionType();
 4432         auto *FnType = llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
 4432         auto *FnType = llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
tools/clang/lib/CodeGen/CGCall.h
   87       llvm::FunctionType *FTy;
  145                                llvm::FunctionType *FTy) {
  207     llvm::FunctionType *getVirtualFunctionType() const {
tools/clang/lib/CodeGen/CGClass.cpp
  795   llvm::FunctionType *FTy =
  796       llvm::FunctionType::get(CGM.VoidTy, Args, false);
 1645    llvm::FunctionType *FnType =
 1646        llvm::FunctionType::get(CGF.VoidTy, ArgTypes, false);
 2491       llvm::FunctionType::get(CGM.Int32Ty, /*isVarArg=*/true)
tools/clang/lib/CodeGen/CGDeclCXX.cpp
  232   llvm::FunctionType *ty = llvm::FunctionType::get(CGM.VoidTy, false);
  232   llvm::FunctionType *ty = llvm::FunctionType::get(CGM.VoidTy, false);
  271   llvm::FunctionType *atexitTy =
  272     llvm::FunctionType::get(IntTy, dtorStub->getType(), false);
  335     llvm::FunctionType *FTy, const Twine &Name, const CGFunctionInfo &FI,
  454   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
  454   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
  542   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
  542   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
  623   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
  623   llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
  729     const std::vector<std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,
  740       llvm::FunctionType *CalleeTy;
  767   llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
tools/clang/lib/CodeGen/CGException.cpp
   34   llvm::FunctionType *FTy =
   35     llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*isVarArg=*/false);
   43   llvm::FunctionType *FTy =
   44     llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*isVarArg=*/false);
   52   llvm::FunctionType *FTy =
   53     llvm::FunctionType::get(VoidTy, /*isVarArg=*/false);
   77   llvm::FunctionType *FTy =
   78     llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*isVarArg=*/false);
  240   return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty, true),
 1379   llvm::FunctionType *rethrowFnTy = rethrowFn.getFunctionType();
 1877   llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FnInfo);
tools/clang/lib/CodeGen/CGExpr.cpp
 2958                                  llvm::FunctionType *FnType,
 3089   llvm::FunctionType *FnType =
 3090     llvm::FunctionType::get(CGM.VoidTy, ArgTypes, false);
 3143         llvm::FunctionType::get(VoidTy, {Int64Ty, Int8PtrTy, Int8PtrTy},
 3150         llvm::FunctionType::get(VoidTy, {Int64Ty, Int8PtrTy}, false));
 3167       llvm::FunctionType::get(VoidTy, {Int64Ty, Int8PtrTy, Int8PtrTy}, false),
 3201       llvm::FunctionType::get(VoidTy, {VoidPtrTy, VoidPtrTy}, false),
tools/clang/lib/CodeGen/CGExprCXX.cpp
  312   llvm::FunctionType *Ty = CGM.getTypes().GetFunctionType(*FInfo);
tools/clang/lib/CodeGen/CGExprComplex.cpp
  642   llvm::FunctionType *FTy = CGF.CGM.getTypes().GetFunctionType(FuncInfo);
tools/clang/lib/CodeGen/CGExprScalar.cpp
 3123   llvm::FunctionType *handlerTy =
 3124       llvm::FunctionType::get(CGF.Int64Ty, argTypes, true);
tools/clang/lib/CodeGen/CGGPUBuiltin.cpp
   26   llvm::FunctionType *VprintfFuncType = llvm::FunctionType::get(
   26   llvm::FunctionType *VprintfFuncType = llvm::FunctionType::get(
tools/clang/lib/CodeGen/CGNonTrivialStruct.cpp
  454     llvm::FunctionType *FuncTy = CGM.getTypes().GetFunctionType(FI);
tools/clang/lib/CodeGen/CGObjC.cpp
 2089     llvm::FunctionType *fnType =
 2090       llvm::FunctionType::get(CGF.Int8PtrTy, CGF.Int8PtrTy, false);
 2173       llvm::FunctionType *type =
 2174         llvm::FunctionType::get(CGF.VoidTy, /*variadic*/false);
 2504       llvm::FunctionType *fnType =
 2505         llvm::FunctionType::get(Builder.getVoidTy(), Int8PtrTy, false);
 2638     llvm::FunctionType *fnType =
 2639         llvm::FunctionType::get(Builder.getVoidTy(), Int8PtrTy, false);
 3468   llvm::FunctionType *extenderType
 3469     = llvm::FunctionType::get(VoidTy, VoidPtrTy, RequiredArgs::All);
 3532   llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI);
 3616   llvm::FunctionType *LTy = CGM.getTypes().GetFunctionType(FI);
 3702     llvm::FunctionType *FTy =
 3703         llvm::FunctionType::get(Int32Ty, {Int32Ty, Int32Ty, Int32Ty}, false);
 3730   llvm::FunctionType *FTy =
 3731       llvm::FunctionType::get(Int32Ty, {VoidPtrTy}, false);
 3735   llvm::FunctionType *CheckFTy = llvm::FunctionType::get(VoidTy, {}, false);
 3735   llvm::FunctionType *CheckFTy = llvm::FunctionType::get(VoidTy, {}, false);
tools/clang/lib/CodeGen/CGObjCGNU.cpp
   59   llvm::FunctionType *FTy;
   80       FTy = llvm::FunctionType::get(RetTy, ArgTys, false);
   83       FTy = llvm::FunctionType::get(RetTy, None, false);
   87   llvm::FunctionType *getType() { return FTy; }
  961     llvm::FunctionType *FT = llvm::FunctionType::get(B.getVoidTy(), Types,
  961     llvm::FunctionType *FT = llvm::FunctionType::get(B.getVoidTy(), Types,
 1522       llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
 1637       auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.VoidTy,
 2232   IMPTy = llvm::PointerType::getUnqual(llvm::FunctionType::get(IdTy, IMPArgs,
 2282       llvm::FunctionType::get(IdTy, PtrToInt8Ty, true), "objc_lookup_class");
 2540         classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
 2543         classLookupFunction = CGM.CreateRuntimeFunction(llvm::FunctionType::get(
 2700             CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true),
 2707             CGM.CreateRuntimeFunction(llvm::FunctionType::get(IdTy, IdTy, true),
 2712                      llvm::FunctionType::get(IdTy, IdTy, true), "objc_msgSend")
 3796       llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), false),
 3804   llvm::FunctionType *FT =
 3805     llvm::FunctionType::get(Builder.getVoidTy(), module->getType(), true);
 3812     llvm::FunctionType *RegisterAliasTy =
 3813       llvm::FunctionType::get(Builder.getVoidTy(),
 3863   llvm::FunctionType *MethodTy =
tools/clang/lib/CodeGen/CGObjCMac.cpp
   67         llvm::FunctionType::get(ObjectPtrTy, params, true), "objc_msgSend",
   80     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy,
   92     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.DoubleTy,
  108     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(resultType,
  120     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
  131     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
  143       llvm::FunctionType::get(CGM.VoidTy, params, true),
  154       llvm::FunctionType::get(CGM.VoidTy, params, true),
  241     llvm::FunctionType *FTy =
  260     llvm::FunctionType *FTy =
  285     llvm::FunctionType *FTy =
  311     llvm::FunctionType *FTy =
  329     llvm::FunctionType *FTy =
  341     llvm::FunctionType *FTy =
  354     llvm::FunctionType *FTy =
  365     llvm::FunctionType *FTy =
  366       llvm::FunctionType::get(ObjectPtrTy, args, false);
  374     llvm::FunctionType *FTy =
  375       llvm::FunctionType::get(ObjectPtrTy, args, false);
  383     llvm::FunctionType *FTy =
  384       llvm::FunctionType::get(ObjectPtrTy, args, false);
  392     llvm::FunctionType *FTy =
  393       llvm::FunctionType::get(ObjectPtrTy, args, false);
  402     llvm::FunctionType *FTy =
  403       llvm::FunctionType::get(ObjectPtrTy, args, false);
  411     llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, args, false);
  411     llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, args, false);
  419     llvm::FunctionType *FTy =
  420       llvm::FunctionType::get(ObjectPtrTy, args, false);
  428     llvm::FunctionType *FTy =
  429       llvm::FunctionType::get(CGM.VoidTy, args, false);
  436     llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false);
  436     llvm::FunctionType *FTy = llvm::FunctionType::get(CGM.VoidTy, false);
  444     llvm::FunctionType *FTy =
  445       llvm::FunctionType::get(CGM.IntTy, args, false);
  453     llvm::FunctionType *FTy =
  454       llvm::FunctionType::get(CGM.IntTy, args, false);
  555       llvm::FunctionType::get(CGM.VoidTy, params, false),
  563       llvm::FunctionType::get(CGM.VoidTy, params, false),
  570     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
  579       llvm::FunctionType::get(CGM.Int32Ty, params, false),
  588         llvm::FunctionType::get(CGM.Int32Ty, params, false), "_setjmp",
  673     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
  681     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
  689     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
  698     return  CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
  707     return  CGM.CreateRuntimeFunction(llvm::FunctionType::get(ObjectPtrTy,
  713     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.VoidTy, false),
  719     return CGM.CreateRuntimeFunction(llvm::FunctionType::get(Int8PtrTy,
  737         llvm::FunctionType::get(ClassnfABIPtrTy, params, false),
 3977   llvm::FunctionType *MethodTy =
 4188     llvm::FunctionType *GetAsmFnType();
 4216   llvm::FunctionType *AsmFnTy = GetAsmFnType();
 4322 llvm::FunctionType *FragileHazards::GetAsmFnType() {
 4326   return llvm::FunctionType::get(CGF.VoidTy, tys, false);
 5956   ImpnfABITy = llvm::FunctionType::get(ObjectPtrTy, params, false)
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp
 1363   llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FnInfo);
 1770     Kmpc_MicroTy = llvm::FunctionType::get(CGM.VoidTy, MicroParams, true);
 1783     auto *FnTy =
 1784         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ true);
 1807     auto *FnTy =
 1808         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg*/ false);
 1818     auto *FnTy =
 1819         llvm::FunctionType::get(CGM.VoidPtrTy, TypeParams, /*isVarArg*/ false);
 1829     auto *FnTy =
 1830         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1840     auto *FnTy =
 1841         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1850         llvm::FunctionType::get(CGM.VoidPtrTy, CGM.VoidPtrTy,
 1855         llvm::FunctionType::get(CGM.VoidPtrTy, KmpcCopyCtorTyArgs,
 1860         llvm::FunctionType::get(CGM.VoidTy, CGM.VoidPtrTy, /*isVarArg*/ false)
 1864     auto *FnTy = llvm::FunctionType::get(CGM.VoidTy, FnTyArgs,
 1864     auto *FnTy = llvm::FunctionType::get(CGM.VoidTy, FnTyArgs,
 1875     auto *FnTy =
 1876         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1884     auto *FnTy =
 1885         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg*/ false);
 1892     auto *FnTy =
 1893         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1900     auto *FnTy =
 1901         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1910     auto *FnTy =
 1911         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1919     auto *FnTy =
 1920         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1928     auto *FnTy =
 1929         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1936     auto *FnTy =
 1937         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1944     auto *FnTy =
 1945         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg=*/false);
 1952     auto *FnTy =
 1953         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 1961     auto *FnTy =
 1962         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg=*/false);
 1969     auto *FnTy =
 1970         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg=*/false);
 1977     auto *FnTy =
 1978         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 1991     auto *FnTy =
 1992         llvm::FunctionType::get(CGM.VoidPtrTy, TypeParams, /*isVarArg=*/false);
 2006     auto *FnTy =
 2007         llvm::FunctionType::get(CGM.VoidPtrTy, TypeParams, /*isVarArg=*/false);
 2016     auto *FnTy =
 2017         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg=*/false);
 2026     auto *CpyFnTy =
 2027         llvm::FunctionType::get(CGM.VoidTy, CpyTypeParams, /*isVarArg=*/false);
 2031     auto *FnTy =
 2032         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2041     auto *ReduceFnTy = llvm::FunctionType::get(CGM.VoidTy, ReduceTypeParams,
 2041     auto *ReduceFnTy = llvm::FunctionType::get(CGM.VoidTy, ReduceTypeParams,
 2047     auto *FnTy =
 2048         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg=*/false);
 2058     auto *ReduceFnTy = llvm::FunctionType::get(CGM.VoidTy, ReduceTypeParams,
 2058     auto *ReduceFnTy = llvm::FunctionType::get(CGM.VoidTy, ReduceTypeParams,
 2064     auto *FnTy =
 2065         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg=*/false);
 2075     auto *FnTy =
 2076         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2086     auto *FnTy =
 2087         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2097     auto *FnTy =
 2098         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2108     auto *FnTy =
 2109         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2117     auto *FnTy =
 2118         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2125     auto *FnTy =
 2126         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2133     auto *FnTy =
 2134         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg=*/false);
 2141     auto *FnTy =
 2142         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2149     auto *FnTy =
 2150         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2158     auto *FnTy =
 2159         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 2170     auto *FnTy =
 2171         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg=*/false);
 2183     auto *FnTy =
 2184         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2192     auto *FnTy =
 2193         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg*/ false);
 2201     auto *FnTy =
 2202         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg*/ false);
 2211     auto *FnTy =
 2212         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg*/ false);
 2221     auto *FnTy =
 2222         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ true);
 2257     auto *FnTy =
 2258         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2269     auto *FnTy =
 2270         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2277     auto *FnTy =
 2278         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2287     auto *FnTy =
 2288         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2297     auto *FnTy =
 2298         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2306     auto *FnTy =
 2307         llvm::FunctionType::get(CGM.VoidPtrTy, TypeParams, /*isVarArg=*/false);
 2316     auto *FnTy =
 2317         llvm::FunctionType::get(CGM.VoidPtrTy, TypeParams, /*isVarArg=*/false);
 2326     auto *FnTy =
 2327         llvm::FunctionType::get(CGM.VoidPtrTy, TypeParams, /*isVarArg=*/false);
 2335     auto *FnTy =
 2336         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2344     llvm::FunctionType *FnTy =
 2345         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2360     auto *FnTy =
 2361         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg*/ false);
 2376     auto *FnTy =
 2377         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg*/ false);
 2394     auto *FnTy =
 2395         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg*/ false);
 2412     auto *FnTy =
 2413         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg*/ false);
 2420     auto *FnTy =
 2421         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 2430     auto *FnTy =
 2431         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg*/ false);
 2440     auto *FnTy =
 2441         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg*/ false);
 2454     auto *FnTy =
 2455         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 2469     auto *FnTy =
 2470         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2483     auto *FnTy =
 2484         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 2498     auto *FnTy =
 2499         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2512     auto *FnTy =
 2513         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 2527     auto *FnTy =
 2528         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2535     auto *FnTy =
 2536         llvm::FunctionType::get(CGM.Int64Ty, TypeParams, /*isVarArg*/ false);
 2545     auto *FnTy =
 2546         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 2576   auto *FnTy =
 2577       llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 2598   auto *FnTy =
 2599       llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 2615   auto *FnTy =
 2616       llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 2638   auto *FnTy =
 2639       llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg*/ false);
 2779       llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
 2812       llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
 2835     auto *CopyCtorTy = llvm::FunctionType::get(CGM.VoidPtrTy, CopyCtorTyArgs,
 2843       auto *CtorTy = llvm::FunctionType::get(CGM.VoidPtrTy, CGM.VoidPtrTy,
 2849       auto *DtorTy = llvm::FunctionType::get(CGM.VoidTy, CGM.VoidPtrTy,
 2855       auto *InitFunctionTy =
 2856           llvm::FunctionType::get(CGM.VoidTy, /*isVarArg*/ false);
 2917       llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
 2955       llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
 4512   llvm::FunctionType *TaskEntryTy =
 4614   llvm::FunctionType *DestructorFnTy =
 4708   llvm::FunctionType *TaskPrivatesMapTy =
 4900   llvm::FunctionType *TaskDupTy = CGM.getTypes().GetFunctionType(TaskDupFnInfo);
 6010   llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FnInfo);
 6087   llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FnInfo);
 6157   llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FnInfo);
 8863   llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FnInfo);
 9871     llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FI);
tools/clang/lib/CodeGen/CGOpenMPRuntime.h
  337   llvm::FunctionType *Kmpc_MicroTy = nullptr;
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp
 1488   auto *ParallelFnTy =
 1489       llvm::FunctionType::get(CGM.VoidTy, {CGM.Int16Ty, CGM.Int32Ty},
 1533     auto *FnTy =
 1534         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1541     auto *FnTy =
 1542         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1550     auto *FnTy =
 1551         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1558     auto *FnTy =
 1559         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1567     auto *FnTy =
 1568         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1577     auto *FnTy =
 1578         llvm::FunctionType::get(RetTy, TypeParams, /*isVarArg*/ false);
 1584     auto *FnTy =
 1585         llvm::FunctionType::get(CGM.VoidTy, llvm::None, /*isVarArg*/ false);
 1593     auto *FnTy =
 1594         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1602     auto *FnTy =
 1603         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1611     auto *FnTy =
 1612         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg*/ false);
 1620     auto *FnTy =
 1621         llvm::FunctionType::get(CGM.Int64Ty, TypeParams, /*isVarArg*/ false);
 1633     auto *ShuffleReduceFnTy =
 1634         llvm::FunctionType::get(CGM.VoidTy, ShuffleReduceTypeParams,
 1637     auto *InterWarpCopyFnTy =
 1638         llvm::FunctionType::get(CGM.VoidTy, InterWarpCopyTypeParams,
 1647     auto *FnTy =
 1648         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg=*/false);
 1656     auto *FnTy =
 1657         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 1676     auto *ShuffleReduceFnTy =
 1677         llvm::FunctionType::get(CGM.VoidTy, ShuffleReduceTypeParams,
 1680     auto *InterWarpCopyFnTy =
 1681         llvm::FunctionType::get(CGM.VoidTy, InterWarpCopyTypeParams,
 1685     auto *GlobalListFnTy =
 1686         llvm::FunctionType::get(CGM.VoidTy, GlobalListTypeParams,
 1699     auto *FnTy =
 1700         llvm::FunctionType::get(CGM.Int32Ty, TypeParams, /*isVarArg=*/false);
 1707     auto *FnTy =
 1708         llvm::FunctionType::get(CGM.VoidTy, llvm::None, /*isVarArg*/ false);
 1714     auto *FnTy =
 1715         llvm::FunctionType::get(CGM.VoidTy, llvm::None, /*isVarArg*/ false);
 1724     auto *FnTy =
 1725         llvm::FunctionType::get(CGM.VoidPtrTy, TypeParams, /*isVarArg=*/false);
 1733     auto *FnTy =
 1734         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 1743     auto *FnTy =
 1744         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1750     auto *FnTy =
 1751         llvm::FunctionType::get(CGM.VoidTy, llvm::None, /*isVarArg*/ false);
 1758     auto *FnTy =
 1759         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1766     auto *FnTy =
 1767         llvm::FunctionType::get(CGM.Int16Ty, TypeParams, /*isVarArg*/ false);
 1773     auto *FnTy = llvm::FunctionType::get(CGM.Int8Ty, /*isVarArg=*/false);
 1773     auto *FnTy = llvm::FunctionType::get(CGM.Int8Ty, /*isVarArg=*/false);
 1782     auto *FnTy =
 1783         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1791     auto *FnTy =
 1792         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg=*/false);
 1800     auto *FnTy =
 1801         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1810     auto *FnTy =
 1811         llvm::FunctionType::get(CGM.VoidTy, TypeParams, /*isVarArg*/ false);
 1818     auto *FnTy =
 1819         llvm::FunctionType::get(CGM.Int32Ty, llvm::None, /*isVarArg=*/false);
 1825     auto *FnTy =
 1826         llvm::FunctionType::get(CGM.VoidTy, CGM.Int32Ty, /*isVarArg=*/false);
 4513   auto *FnType = OutlinedFn.getFunctionType();
tools/clang/lib/CodeGen/CGRecordLayoutBuilder.cpp
  506         llvm::FunctionType::get(getIntNType(32), /*isVarArg=*/true)->
tools/clang/lib/CodeGen/CGStmt.cpp
 2270   llvm::FunctionType *FTy =
 2271     llvm::FunctionType::get(ResultType, ArgTypes, false);
 2414   llvm::FunctionType *FuncLLVMTy = CGM.getTypes().GetFunctionType(FuncInfo);
tools/clang/lib/CodeGen/CGStmtOpenMP.cpp
  470   llvm::FunctionType *FuncLLVMTy = CGM.getTypes().GetFunctionType(FuncInfo);
 2987       llvm::FunctionType *CopyFnTy = llvm::FunctionType::get(
 2987       llvm::FunctionType *CopyFnTy = llvm::FunctionType::get(
 3225       llvm::FunctionType *CopyFnTy = llvm::FunctionType::get(
 3225       llvm::FunctionType *CopyFnTy = llvm::FunctionType::get(
tools/clang/lib/CodeGen/CGVTables.cpp
  516   llvm::FunctionType *ThunkFnTy = CGM.getTypes().GetFunctionType(FnInfo);
  679       llvm::FunctionType *fnTy =
  680           llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
tools/clang/lib/CodeGen/CodeGenABITypes.cpp
   66 llvm::FunctionType *
   71   if (auto FT = dyn_cast<llvm::FunctionType>(T))
tools/clang/lib/CodeGen/CodeGenFunction.h
 3986       const std::vector<std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH,
 4182   void ExpandTypeToArgs(QualType Ty, CallArg Arg, llvm::FunctionType *IRFuncTy,
tools/clang/lib/CodeGen/CodeGenModule.cpp
  321       llvm::FunctionType *FTy = dyn_cast<llvm::FunctionType>(
  321       llvm::FunctionType *FTy = dyn_cast<llvm::FunctionType>(
 1154   llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
 1154   llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
 2399   if (isa<llvm::FunctionType>(DeclTy))
 2753   llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
 2870               llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
 2927     ResolverType = llvm::FunctionType::get(
 3049     llvm::Type *ResolverType = llvm::FunctionType::get(
 3166   llvm::FunctionType *FTy;
 3167   if (isa<llvm::FunctionType>(Ty)) {
 3168     FTy = cast<llvm::FunctionType>(Ty);
 3170     FTy = llvm::FunctionType::get(VoidTy, false);
 3337 CodeGenModule::CreateRuntimeFunction(llvm::FunctionType *FTy, StringRef Name,
 3606     llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
 4394   llvm::FunctionType *Ty = getTypes().GetFunctionType(FI);
 4460   if (isa<llvm::FunctionType>(DeclTy)) {
 5926   auto FTy = llvm::FunctionType::get(SamplerT, {C->getType()}, false);
tools/clang/lib/CodeGen/CodeGenModule.h
  463       std::tuple<llvm::FunctionType *, llvm::WeakTrackingVH, llvm::Constant *>>
  807   CreateGlobalInitOrDestructFunction(llvm::FunctionType *ty, const Twine &name,
  972                        llvm::FunctionType *FnType = nullptr,
  983       llvm::FunctionType *FnType = nullptr, bool DontDefer = false,
 1033   CreateRuntimeFunction(llvm::FunctionType *Ty, StringRef Name,
 1041       llvm::FunctionType *Ty, StringRef Name,
tools/clang/lib/CodeGen/CodeGenTypes.h
  140   llvm::FunctionType *GetFunctionType(const CGFunctionInfo &Info);
  142   llvm::FunctionType *GetFunctionType(GlobalDecl GD);
tools/clang/lib/CodeGen/ItaniumCXXABI.cpp
  586   llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
 1214   llvm::FunctionType *FTy =
 1215     llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
 1228   llvm::FunctionType *FTy =
 1229     llvm::FunctionType::get(CGM.Int8PtrTy, CGM.SizeTy, /*isVarArg=*/false);
 1239   llvm::FunctionType *FTy =
 1240     llvm::FunctionType::get(CGM.VoidTy, Args, /*isVarArg=*/false);
 1291   llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, Args, false);
 1291   llvm::FunctionType *FTy = llvm::FunctionType::get(Int8PtrTy, Args, false);
 1304   llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
 1304   llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
 1362   llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
 1362   llvm::FunctionType *FTy = llvm::FunctionType::get(CGF.VoidTy, false);
 1828   llvm::FunctionType *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
 2027     llvm::FunctionType *FTy =
 2028         llvm::FunctionType::get(CGM.VoidTy, NumElementsPtr.getType(), false);
 2058   llvm::FunctionType *FTy =
 2059       llvm::FunctionType::get(CGF.SizeTy, CGF.SizeTy->getPointerTo(0), false);
 2121   llvm::FunctionType *FTy =
 2122     llvm::FunctionType::get(CGM.getTypes().ConvertType(CGM.getContext().IntTy),
 2134   llvm::FunctionType *FTy =
 2135     llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
 2146   llvm::FunctionType *FTy =
 2147     llvm::FunctionType::get(CGM.VoidTy, GuardPtrTy, /*isVarArg=*/false);
 2371     llvm::FunctionType::get(CGF.VoidTy, CGF.Int8PtrTy, false)->getPointerTo();
 2386   llvm::FunctionType *atexitTy =
 2387     llvm::FunctionType::get(CGF.IntTy, paramTys, false);
 2423     llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
 2423     llvm::FunctionType *FTy = llvm::FunctionType::get(VoidTy, false);
 2527   llvm::FunctionType *FnTy = CGM.getTypes().GetFunctionType(FI);
 2572     llvm::FunctionType *FTy =
 2573         llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
 2637     llvm::FunctionType *InitFnTy = llvm::FunctionType::get(CGM.VoidTy, false);
 2637     llvm::FunctionType *InitFnTy = llvm::FunctionType::get(CGM.VoidTy, false);
 4021   llvm::FunctionType *FTy = llvm::FunctionType::get(
 4021   llvm::FunctionType *FTy = llvm::FunctionType::get(
 4029   llvm::FunctionType *FTy =
 4030       llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
 4037   llvm::FunctionType *FTy = llvm::FunctionType::get(
 4037   llvm::FunctionType *FTy = llvm::FunctionType::get(
 4311   llvm::FunctionType *fnTy =
 4312     llvm::FunctionType::get(CGM.VoidTy, CGM.Int8PtrTy, /*isVarArg=*/false);
tools/clang/lib/CodeGen/MicrosoftCXXABI.cpp
  734     llvm::FunctionType *FTy =
  735         llvm::FunctionType::get(CGM.VoidTy, Args, /*isVarArg=*/false);
  935   llvm::FunctionType *FTy =
  936       llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false);
  991       llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false),
 1011       llvm::FunctionType::get(CGF.Int8PtrTy, ArgTypes, false),
 1917   llvm::FunctionType *Ty = CGF.CGM.getTypes().GetFunctionType(*FInfo);
 1983   llvm::FunctionType *ThunkTy = CGM.getTypes().GetFunctionType(FnInfo);
 2264   llvm::FunctionType *TLRegDtorTy = llvm::FunctionType::get(
 2264   llvm::FunctionType *TLRegDtorTy = llvm::FunctionType::get(
 2330     llvm::FunctionType *FTy =
 2331         llvm::FunctionType::get(CGM.VoidTy, /*isVarArg=*/false);
 2363   llvm::FunctionType *FTy =
 2364       llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()),
 2375   llvm::FunctionType *FTy =
 2376       llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()),
 2387   llvm::FunctionType *FTy =
 2388       llvm::FunctionType::get(llvm::Type::getVoidTy(CGM.getLLVMContext()),
 3331   llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(
 3899   llvm::FunctionType *ThunkTy = CGM.getTypes().GetFunctionType(FnInfo);
tools/clang/lib/CodeGen/TargetInfo.cpp
 9891   auto *InvokeFT = Invoke->getFunctionType();
 9897   auto *FT = llvm::FunctionType::get(llvm::Type::getVoidTy(C), ArgTys, false);
 9897   auto *FT = llvm::FunctionType::get(llvm::Type::getVoidTy(C), ArgTys, false);
 9928   auto *InvokeFT = Invoke->getFunctionType();
 9955   auto *FT = llvm::FunctionType::get(llvm::Type::getVoidTy(C), ArgTys, false);
 9955   auto *FT = llvm::FunctionType::get(llvm::Type::getVoidTy(C), ArgTys, false);
tools/clang/tools/clang-offload-wrapper/ClangOffloadWrapper.cpp
  248     auto *FuncTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg*/ false);
  248     auto *FuncTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg*/ false);
  254     auto *RegFuncTy = FunctionType::get(Type::getVoidTy(C), getBinDescPtrTy(),
  254     auto *RegFuncTy = FunctionType::get(Type::getVoidTy(C), getBinDescPtrTy(),
  269     auto *FuncTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg*/ false);
  269     auto *FuncTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg*/ false);
  275     auto *UnRegFuncTy = FunctionType::get(Type::getVoidTy(C), getBinDescPtrTy(),
  275     auto *UnRegFuncTy = FunctionType::get(Type::getVoidTy(C), getBinDescPtrTy(),
tools/lldb/source/Plugins/ExpressionParser/Clang/IRDynamicChecks.cpp
  247     FunctionType *fun_ty = FunctionType::get(
  247     FunctionType *fun_ty = FunctionType::get(
  271     FunctionType *fun_ty = FunctionType::get(
  271     FunctionType *fun_ty = FunctionType::get(
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp
  476     llvm::FunctionType *CFSCWB_ty =
  477         FunctionType::get(ns_str_ty, CFSCWB_arg_types, false);
  860     llvm::FunctionType *srN_type =
  861         FunctionType::get(sel_ptr_type, srN_arg_types, false);
 1011     llvm::FunctionType *ogC_type =
 1012         FunctionType::get(class_type, ogC_arg_types, false);
tools/lldb/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptx86ABIFixups.cpp
   81 llvm::FunctionType *cloneToStructRetFnTy(llvm::CallInst *call_inst) {
   94   llvm::FunctionType *orig_type = orig->getFunctionType();
  122   return llvm::FunctionType::get(return_type_ptr_type, params,
  157     llvm::FunctionType *new_func_type = cloneToStructRetFnTy(call_inst);
tools/lli/lli.cpp
  321       Function::Create(FunctionType::get(ReturnTy, {}, false),
tools/llvm-exegesis/lib/Assembler.cpp
   79   FunctionType *FunctionType =
   80       FunctionType::get(ReturnType, {MemParamType}, false);
tools/llvm-stress/llvm-stress.cpp
  166   auto *FuncTy = FunctionType::get(Type::getVoidTy(Context), ArgsTy, false);
  166   auto *FuncTy = FunctionType::get(Type::getVoidTy(Context), ArgsTy, false);
tools/polly/lib/CodeGen/LoopGeneratorsGOMP.cpp
   32     Type *Params[] = {PointerType::getUnqual(FunctionType::get(
   40     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Params, false);
   40     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Params, false);
   61   FunctionType *FT =
   62       FunctionType::get(Builder.getVoidTy(), {Builder.getInt8PtrTy()}, false);
  182     FunctionType *Ty = FunctionType::get(Builder.getInt8Ty(), Params, false);
  182     FunctionType *Ty = FunctionType::get(Builder.getInt8Ty(), Params, false);
  202     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), false);
  202     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), false);
  218     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), false);
  218     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), false);
tools/polly/lib/CodeGen/LoopGeneratorsKMP.cpp
   33     KMPCMicroTy = FunctionType::get(Builder.getVoidTy(), MicroParams, true);
   44     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Params, true);
   44     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Params, true);
   84   FunctionType *FT = FunctionType::get(Builder.getVoidTy(), Arguments, false);
   84   FunctionType *FT = FunctionType::get(Builder.getVoidTy(), Arguments, false);
  283     FunctionType *Ty = FunctionType::get(Builder.getInt32Ty(), Params, false);
  283     FunctionType *Ty = FunctionType::get(Builder.getInt32Ty(), Params, false);
  303     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Params, false);
  303     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Params, false);
  336     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Params, false);
  336     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Params, false);
  365     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Params, false);
  365     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Params, false);
  395     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Params, false);
  395     FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), Params, false);
  434     FunctionType *Ty = FunctionType::get(Builder.getInt32Ty(), Params, false);
  434     FunctionType *Ty = FunctionType::get(Builder.getInt32Ty(), Params, false);
tools/polly/lib/CodeGen/PerfMonitor.cpp
   27     FunctionType *Ty = FunctionType::get(Builder.getInt32Ty(),
   27     FunctionType *Ty = FunctionType::get(Builder.getInt32Ty(),
  126   FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), {}, false);
  126   FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), {}, false);
  217   FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), {}, false);
  217   FunctionType *Ty = FunctionType::get(Builder.getVoidTy(), {}, false);
tools/polly/lib/CodeGen/RuntimeDebugBuilder.cpp
   27     FunctionType *Ty = FunctionType::get(
   27     FunctionType *Ty = FunctionType::get(
   48     FunctionType *Ty = FunctionType::get(
   48     FunctionType *Ty = FunctionType::get(
  251     FunctionType *Ty = FunctionType::get(Builder.getInt32Ty(), true);
  251     FunctionType *Ty = FunctionType::get(Builder.getInt32Ty(), true);
  276     FunctionType *Ty =
  277         FunctionType::get(Builder.getInt32Ty(), Builder.getInt8PtrTy(), false);
unittests/Analysis/AliasAnalysisTest.cpp
  168   FunctionType *FTy =
  169       FunctionType::get(Type::getVoidTy(C), std::vector<Type *>(), false);
unittests/Analysis/BasicAliasAnalysisTest.cpp
   72       FunctionType::get(B.getVoidTy(), {B.getInt32Ty()->getPointerTo()}, false),
  106       FunctionType::get(B.getVoidTy(), {B.getInt64Ty()}, false),
unittests/Analysis/DivergenceAnalysisTest.cpp
   79   FunctionType *FTy =
   80       FunctionType::get(Type::getVoidTy(Context), {IntTy}, false);
unittests/Analysis/MemoryBuiltinsTest.cpp
   29       FunctionType::get(Type::getInt8PtrTy(Context), {ArgTy}, false),
unittests/Analysis/MemorySSATest.cpp
   76       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
  114       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
  204       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
  248       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
  298       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
  334       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
  380       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
  424       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
  479       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
  524       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
  597   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
  628   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
  658   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
  702   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
  766   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
  795   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
  826   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
  885       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
  924       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
  969       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
 1004   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
 1047   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
 1096   F = Function::Create(FunctionType::get(B.getVoidTy(),
 1138   F = Function::Create(FunctionType::get(B.getVoidTy(),
 1221       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
 1270   F = Function::Create(FunctionType::get(B.getVoidTy(), {B.getInt1Ty()}, false),
 1333   F = Function::Create(FunctionType::get(B.getVoidTy(),
 1412       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
 1468       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
 1540       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
unittests/Analysis/OrderedInstructionsTest.cpp
   26   FunctionType *FTy =
   27       FunctionType::get(Type::getVoidTy(Ctx), {B.getInt8PtrTy()}, false);
unittests/Analysis/PhiValuesTest.cpp
   29   Function *F = Function::Create(FunctionType::get(VoidTy, false),
   96   Function *F = Function::Create(FunctionType::get(VoidTy, false),
unittests/Analysis/ScalarEvolutionTest.cpp
   69   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context),
   69   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context),
  118   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context),
  118   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context),
  152   FunctionType *FTy =
  153       FunctionType::get(Type::getVoidTy(Context), std::vector<Type *>(), false);
  335   FunctionType *FTy =
  336       FunctionType::get(Type::getVoidTy(Context), std::vector<Type *>(), false);
  405   FunctionType *FTy =
  406       FunctionType::get(Type::getVoidTy(Context), {IntPtrTy, IntPtrTy}, false);
  443   FunctionType *FTy =
  444       FunctionType::get(Type::getVoidTy(Context), ArgTys, false);
  678   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), {}, false);
  678   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), {}, false);
  756   FunctionType *FTy =
  757       FunctionType::get(Type::getVoidTy(Context), {T_pint64}, false);
  830   FunctionType *FTy =
  831       FunctionType::get(Type::getVoidTy(Context), {T_pint64}, false);
  928   FunctionType *FTy =
  929       FunctionType::get(Type::getVoidTy(Context), {T_pint64}, false);
  988   FunctionType *FTy =
  989       FunctionType::get(Type::getVoidTy(Context), std::vector<Type *>(), false);
 1046   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), Types, false);
 1046   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), Types, false);
 1101   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), Types, false);
 1101   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), Types, false);
 1156   FunctionType *FTy =
 1157       FunctionType::get(Type::getVoidTy(Context), {T_pint64}, false);
 1217   FunctionType *FTy =
 1218       FunctionType::get(Type::getVoidTy(Context), { T_int64 }, false);
 1269   FunctionType *FTy =
 1270       FunctionType::get(Type::getVoidTy(Context), { T_int64 }, false);
 1319   FunctionType *FTy =
 1320       FunctionType::get(Type::getVoidTy(Context), { T_int64 }, false);
 1370   FunctionType *FTy =
 1371       FunctionType::get(Type::getVoidTy(Context), { T_int64 }, false);
 1420   FunctionType *FTy =
 1421       FunctionType::get(Type::getVoidTy(Context), { T_int64, T_int64 }, false);
unittests/Analysis/SparsePropagation.cpp
  257   Function *F = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
  259   Function *G = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
  293   Function *F = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
  295   Function *G = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
  334   Function *F = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
  336   Function *G = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
  376       Function::Create(FunctionType::get(Builder.getInt64Ty(),
  416       Function::Create(FunctionType::get(Builder.getInt64Ty(),
  459   Function *F = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
  462       FunctionType::get(Builder.getVoidTy(),
  512   Function *P = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
  514   Function *G = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
  516   Function *F = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
unittests/Analysis/TBAATest.cpp
   35   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), {});
   35   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), {});
unittests/Analysis/TargetLibraryInfoTest.cpp
   65   auto *InvalidFTy = FunctionType::get(StructTy, /*isVarArg=*/false);
   65   auto *InvalidFTy = FunctionType::get(StructTy, /*isVarArg=*/false);
unittests/Analysis/VectorUtilsTest.cpp
   71             FunctionType::get(Type::getVoidTy(Ctx), /* IsVarArg */ false),
unittests/CodeGen/MachineInstrTest.cpp
  156   auto Type = FunctionType::get(Type::getVoidTy(Ctx), false);
unittests/ExecutionEngine/MCJIT/MCJITMultipleModuleTest.cpp
  213                      FunctionType::get(Builder.getInt32Ty(), {}, false), "FA");
  216                      FunctionType::get(Builder.getInt32Ty(), {}, false), "FB");
unittests/ExecutionEngine/MCJIT/MCJITTest.cpp
  102       startFunction(M.get(), FunctionType::get(Builder.getInt32Ty(), {}, false),
  168       M.get(), FunctionType::get(Builder.getInt32Ty(), {}, false), "Inner");
  176                           FunctionType::get(Builder.getInt32Ty(), {}, false),
  200       M.get(), FunctionType::get(Builder.getVoidTy(), {}, false), "_exit");
  215       M.get(), FunctionType::get(Builder.getInt32Ty(), {}, false),
  217   startFunction(M.get(), FunctionType::get(Builder.getInt32Ty(), {}, false),
  253   FunctionType *Int32VoidFnTy =
  254       FunctionType::get(Builder.getInt32Ty(), {}, false);
unittests/ExecutionEngine/MCJIT/MCJITTestBase.h
   47   Function *startFunction(Module *M, FunctionType *FT, StringRef Name) {
   81         M, FunctionType::get(Type::getInt32Ty(Context), {}, false), "main");
   95         FunctionType::get(
  111   Function *insertExternalReferenceToFunction(Module *M, FunctionType *FTy,
  157                       FunctionType::get(Type::getInt32Ty(Context),
unittests/ExecutionEngine/Orc/IndirectionUtilsTest.cpp
   21   FunctionType *FTy = FunctionType::get(
   21   FunctionType *FTy = FunctionType::get(
unittests/ExecutionEngine/Orc/LegacyRTDyldObjectLinkingLayerTest.cpp
  160         MB1.createFunctionDecl(FunctionType::get(Int32Ty, {}, false), "bar");
  174         MB2.createFunctionDecl(FunctionType::get(Int32Ty, {}, false), "bar");
  176         MB2.createFunctionDecl(FunctionType::get(Int32Ty, {}, false), "foo");
  246         MB1.createFunctionDecl(FunctionType::get(Int32Ty, {}, false), "foo");
  260         MB2.createFunctionDecl(FunctionType::get(Int32Ty, {}, false), "bar");
unittests/ExecutionEngine/Orc/OrcCAPITest.cpp
   31         MB.createFunctionDecl(FunctionType::get(IntTy, {}, false), "testFunc");
   33         FunctionType::get(
unittests/ExecutionEngine/Orc/OrcTestCommon.h
  170   Function *createFunctionDecl(FunctionType *FTy, StringRef Name) {
unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp
  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),
unittests/FuzzMutate/OperationsTest.cpp
  178   Function *F = Function::Create(FunctionType::get(Type::getVoidTy(Ctx), {},
  248   Function *F = Function::Create(FunctionType::get(Type::getVoidTy(Ctx), {},
  286   Function *F = Function::Create(FunctionType::get(Type::getVoidTy(Ctx), {},
unittests/IR/BasicBlockTest.cpp
   99   FunctionType *FT = FunctionType::get(Type::getVoidTy(Ctx), ArgTy1, false);
   99   FunctionType *FT = FunctionType::get(Type::getVoidTy(Ctx), ArgTy1, false);
unittests/IR/CFGBuilder.cpp
   25   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Context), {}, false);
   25   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Context), {}, false);
unittests/IR/ConstantsTest.cpp
  482   FunctionType *FuncType(FunctionType::get(VoidType, false));
  482   FunctionType *FuncType(FunctionType::get(VoidType, false));
unittests/IR/FunctionTest.cpp
   20   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), ArgTypes, false);
   20   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), ArgTypes, false);
   50   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), ArgTypes, false);
   50   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), ArgTypes, false);
  126       Function::Create(llvm::FunctionType::get(llvm::Type::getVoidTy(C), false),
  143   FunctionType *FuncType(FunctionType::get(VoidType, false));
  143   FunctionType *FuncType(FunctionType::get(VoidType, false));
unittests/IR/IRBuilderTest.cpp
   30     FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
   30     FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
  128   FunctionType *FTy;
  541   auto CalleeTy = FunctionType::get(Type::getFloatTy(Ctx),
  798   auto CalleeTy = FunctionType::get(Type::getVoidTy(Ctx),
unittests/IR/InstructionsTest.cpp
   72     FunctionType *FTy =
   73         FunctionType::get(Type::getVoidTy(Ctx), FArgTypes, false);
  507   FunctionType *FnTy = FunctionType::get(Int32Ty, ArgTys, /*isVarArg=*/false);
  507   FunctionType *FnTy = FunctionType::get(Int32Ty, ArgTys, /*isVarArg=*/false);
  541   FunctionType *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false);
  541   FunctionType *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false);
  568   FunctionType *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false);
  568   FunctionType *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false);
unittests/IR/LegacyPassManagerTest.cpp
  475       FunctionType *FuncTy_0 = FunctionType::get(
  475       FunctionType *FuncTy_0 = FunctionType::get(
  482       FunctionType *FuncTy_2 = FunctionType::get(
  482       FunctionType *FuncTy_2 = FunctionType::get(
unittests/IR/ManglerTest.cpp
   33   FunctionType *FTy =
   34       FunctionType::get(VoidTy, {I32Ty, I32Ty, I32Ty}, /*isVarArg=*/false);
unittests/IR/MetadataTest.cpp
  121         FunctionType::get(Type::getVoidTy(Context), None, false),
  348   auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
  348   auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
  372       Function::Create(FunctionType::get(Type::getVoidTy(Context),
  376   auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
  376   auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
  407   auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
  407   auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
unittests/IR/PatternMatch.cpp
   43             FunctionType::get(Type::getVoidTy(Ctx), /* IsVarArg */ false),
unittests/IR/UserTest.cpp
  123   FunctionType *RetVoidTy = FunctionType::get(Type::getVoidTy(Context), false);
  123   FunctionType *RetVoidTy = FunctionType::get(Type::getVoidTy(Context), false);
unittests/IR/VerifierTest.cpp
   28   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg=*/false);
   28   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg=*/false);
   51   FunctionType *FTy = FunctionType::get(Type::getInt32Ty(C), /*isVarArg=*/false);
   51   FunctionType *FTy = FunctionType::get(Type::getInt32Ty(C), /*isVarArg=*/false);
   69   FunctionType *FTy = FunctionType::get(Type::getInt32Ty(C), /*isVarArg=*/false);
   69   FunctionType *FTy = FunctionType::get(Type::getInt32Ty(C), /*isVarArg=*/false);
  140   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg=*/false);
  140   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg=*/false);
  176     auto *F = Function::Create(FunctionType::get(Type::getVoidTy(C), false),
unittests/IR/WaymarkTest.cpp
   28   FunctionType *FT = FunctionType::get(Type::getVoidTy(Context), true);
   28   FunctionType *FT = FunctionType::get(Type::getVoidTy(Context), true);
unittests/Linker/LinkModulesTest.cpp
   30     FunctionType *FTy = FunctionType::get(
   30     FunctionType *FTy = FunctionType::get(
  135   FunctionType *FTy = FunctionType::get(
  135   FunctionType *FTy = FunctionType::get(
  150   FunctionType *FTy = FunctionType::get(
  150   FunctionType *FTy = FunctionType::get(
unittests/ProfileData/InstrProfTest.cpp
  289   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
  289   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
  893   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
  893   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
unittests/ProfileData/SampleProfTest.cpp
  128     FunctionType *fn_type =
  129         FunctionType::get(Type::getVoidTy(Context), {}, false);
  286     FunctionType *FnType =
  287         FunctionType::get(Type::getVoidTy(Context), {}, false);
unittests/Transforms/Utils/CloningTest.cpp
  163   FunctionType *FT1 =  FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
  163   FunctionType *FT1 =  FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
  188   FunctionType *FT1 =  FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
  188   FunctionType *FT1 =  FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
  211   FunctionType *FT = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
  211   FunctionType *FT = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
  260   FunctionType *FT = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
  260   FunctionType *FT = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
  313   FunctionType *FT = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
  313   FunctionType *FT = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
  461     FunctionType* FuncType = FunctionType::get(Type::getVoidTy(C), false);
  461     FunctionType* FuncType = FunctionType::get(Type::getVoidTy(C), false);
  734     auto *FuncType = FunctionType::get(Type::getVoidTy(C), false);
  734     auto *FuncType = FunctionType::get(Type::getVoidTy(C), false);
unittests/Transforms/Utils/FunctionComparatorTest.cpp
   29     F = Function::Create(FunctionType::get(T, {B.getInt8PtrTy()}, false),
unittests/Transforms/Utils/IntegerDivisionTest.cpp
   28   Function *F = Function::Create(FunctionType::get(Builder.getInt32Ty(),
   58   Function *F = Function::Create(FunctionType::get(Builder.getInt32Ty(),
   88   Function *F = Function::Create(FunctionType::get(Builder.getInt32Ty(),
  118   Function *F = Function::Create(FunctionType::get(Builder.getInt32Ty(),
  149   Function *F = Function::Create(FunctionType::get(Builder.getInt64Ty(),
  179   Function *F = Function::Create(FunctionType::get(Builder.getInt64Ty(),
  209   Function *F = Function::Create(FunctionType::get(Builder.getInt64Ty(),
  239   Function *F = Function::Create(FunctionType::get(Builder.getInt64Ty(),
unittests/Transforms/Utils/LocalTest.cpp
   73       Function::Create(FunctionType::get(B.getVoidTy(), false),
unittests/Transforms/Utils/SSAUpdaterBulkTest.cpp
   27   auto *F = Function::Create(FunctionType::get(B.getVoidTy(), {I32Ty}, false),
  114   auto *F = Function::Create(FunctionType::get(B.getVoidTy(), {I32Ty}, false),
unittests/Transforms/Utils/ValueMapperTest.cpp
  174   FunctionType *FTy =
  175       FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
  233   FunctionType *FTy =
  234       FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
  268   FunctionType *FTy =
  269       FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
  287   FunctionType *FTy =
  288       FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
  330   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), Int8, false);
  330   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), Int8, false);
usr/include/c++/7.4.0/type_traits
 1983     { typedef _Up     type; };