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

Declarations

include/llvm/Analysis/AssumptionCache.h
   30 class Function;
include/llvm/Analysis/BasicAliasAnalysis.h
   39 class Function;
include/llvm/Analysis/BlockFrequencyInfo.h
   27 class Function;
include/llvm/Analysis/BlockFrequencyInfoImpl.h
   52 class Function;
include/llvm/Analysis/BranchProbabilityInfo.h
   34 class Function;
include/llvm/Analysis/CFG.h
   24 class Function;
include/llvm/Analysis/CFLAndersAliasAnalysis.h
   28 class Function;
include/llvm/Analysis/CFLSteensAliasAnalysis.h
   30 class Function;
include/llvm/Analysis/CodeMetrics.h
   24 class Function;
include/llvm/Analysis/ConstantFolding.h
   30 class Function;
include/llvm/Analysis/DemandedBits.h
   35 class Function;
include/llvm/Analysis/DominanceFrontier.h
   33 class Function;
include/llvm/Analysis/EHPersonalities.h
   19 class Function;
include/llvm/Analysis/InlineCost.h
   27 class Function;
include/llvm/Analysis/InstructionSimplify.h
   40 class Function;
include/llvm/Analysis/LazyBlockFrequencyInfo.h
   26 class Function;
include/llvm/Analysis/LazyBranchProbabilityInfo.h
   24 class Function;
include/llvm/Analysis/Lint.h
   26 class Function;
include/llvm/Analysis/LoopPass.h
   25 class Function;
include/llvm/Analysis/MemoryDependenceAnalysis.h
   40 class Function;
include/llvm/Analysis/MemorySSA.h
  110 class Function;
include/llvm/Analysis/MemorySSAUpdater.h
   58 class Function;
include/llvm/Analysis/ModuleSummaryAnalysis.h
   25 class Function;
include/llvm/Analysis/PhiValues.h
   35 class Function;
include/llvm/Analysis/PostDominators.h
   23 class Function;
include/llvm/Analysis/RegionPass.h
   27 class Function;
include/llvm/Analysis/RegionPrinter.h
   19   class Function;
include/llvm/Analysis/ScopedNoAliasAA.h
   25 class Function;
include/llvm/Analysis/SyntheticCountsUtils.h
   23 class Function;
include/llvm/Analysis/TargetTransformInfo.h
   44 class Function;
include/llvm/Analysis/Trace.h
   26 class Function;
include/llvm/Analysis/TypeBasedAliasAnalysis.h
   26 class Function;
include/llvm/Analysis/ValueLatticeUtils.h
   19 class Function;
include/llvm/CodeGen/BasicTTIImpl.h
   58 class Function;
include/llvm/CodeGen/FunctionLoweringInfo.h
   40 class Function;
include/llvm/CodeGen/GCMetadata.h
   51 class Function;
include/llvm/CodeGen/GlobalISel/CallLowering.h
   32 class Function;
include/llvm/CodeGen/MachineFunction.h
   55 class Function;
include/llvm/CodeGen/MachineModuleInfo.h
   48 class Function;
include/llvm/CodeGen/RegisterUsageInfo.h
   30 class Function;
include/llvm/CodeGen/StackProtector.h
   30 class Function;
include/llvm/CodeGen/SwiftErrorValueTracking.h
   29   class Function;
include/llvm/CodeGen/WinEHFuncInfo.h
   28 class Function;
include/llvm/ExecutionEngine/ExecutionEngine.h
   45 class Function;
include/llvm/ExecutionEngine/Orc/ExecutionUtils.h
   34 class Function;
include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
   38 class Function;
include/llvm/FuzzMutate/IRMutator.h
   24 class Function;
include/llvm/IR/AssemblyAnnotationWriter.h
   21 class Function;
include/llvm/IR/Attributes.h
   41 class Function;
include/llvm/IR/AutoUpgrade.h
   21   class Function;
include/llvm/IR/BasicBlock.h
   35 class Function;
include/llvm/IR/DIBuilder.h
   35   class Function;
include/llvm/IR/DiagnosticInfo.h
   35 class Function;
include/llvm/IR/Dominators.h
   30 class Function;
include/llvm/IR/IRPrintingPasses.h
   27 class Function;
include/llvm/IR/Intrinsics.h
   27 class Function;
include/llvm/IR/LLVMContext.h
   29 class Function;
include/llvm/IR/ModuleSlotTracker.h
   17 class Function;
include/llvm/IR/SafepointIRVerifier.h
   25 class Function;
include/llvm/IR/SymbolTableListTraits.h
   35 class Function;
include/llvm/IR/UseListOrder.h
   22 class Function;
include/llvm/IR/Value.h
   36 class Function;
include/llvm/IR/ValueSymbolTable.h
   25 class Function;
include/llvm/IR/Verifier.h
   30 class Function;
include/llvm/LTO/legacy/LTOModule.h
   29   class Function;
include/llvm/Pass.h
   39 class Function;
include/llvm/PassAnalysisSupport.h
   30 class Function;
include/llvm/ProfileData/InstrProf.h
   48 class Function;
include/llvm/Target/TargetIntrinsicInfo.h
   22 class Function;
include/llvm/Target/TargetMachine.h
   26 class Function;
include/llvm/Transforms/IPO.h
   28 class Function;
include/llvm/Transforms/IPO/Attributor.h
  116 class Function;
include/llvm/Transforms/IPO/FunctionAttrs.h
   25 class Function;
include/llvm/Transforms/IPO/SyntheticCountsPropagation.h
   10 class Function;
include/llvm/Transforms/IPO/WholeProgramDevirt.h
   30 class Function;
include/llvm/Transforms/Instrumentation/PGOInstrumentation.h
   25 class Function;
include/llvm/Transforms/Scalar.h
   22 class Function;
include/llvm/Transforms/Scalar/ADCE.h
   23 class Function;
include/llvm/Transforms/Scalar/ConstantHoisting.h
   57 class Function;
include/llvm/Transforms/Scalar/CorrelatedValuePropagation.h
   16 class Function;
include/llvm/Transforms/Scalar/DeadStoreElimination.h
   24 class Function;
include/llvm/Transforms/Scalar/EarlyCSE.h
   21 class Function;
include/llvm/Transforms/Scalar/GVN.h
   44 class Function;
include/llvm/Transforms/Scalar/GuardWidening.h
   25 class Function;
include/llvm/Transforms/Scalar/JumpThreading.h
   38 class Function;
include/llvm/Transforms/Scalar/LoopDistribute.h
   23 class Function;
include/llvm/Transforms/Scalar/LoopFuse.h
   21 class Function;
include/llvm/Transforms/Scalar/LoopLoadElimination.h
   23 class Function;
include/llvm/Transforms/Scalar/LoopUnrollPass.h
   20 class Function;
include/llvm/Transforms/Scalar/MemCpyOptimizer.h
   29 class Function;
include/llvm/Transforms/Scalar/MergeICmps.h
   16 class Function;
include/llvm/Transforms/Scalar/NaryReassociate.h
   92 class Function;
include/llvm/Transforms/Scalar/NewGVN.h
   21 class Function;
include/llvm/Transforms/Scalar/Reassociate.h
   38 class Function;
include/llvm/Transforms/Scalar/RewriteStatepointsForGC.h
   24 class Function;
include/llvm/Transforms/Scalar/SROA.h
   28 class Function;
include/llvm/Transforms/Scalar/WarnMissedTransforms.h
   19 class Function;
include/llvm/Transforms/Utils/AddDiscriminators.h
   22 class Function;
include/llvm/Transforms/Utils/BasicBlockUtils.h
   32 class Function;
include/llvm/Transforms/Utils/Cloning.h
   41 class Function;
include/llvm/Transforms/Utils/CodeExtractor.h
   33 class Function;
include/llvm/Transforms/Utils/CtorUtils.h
   21 class Function;
include/llvm/Transforms/Utils/EntryExitInstrumenter.h
   22 class Function;
include/llvm/Transforms/Utils/Evaluator.h
   31 class Function;
include/llvm/Transforms/Utils/FunctionComparator.h
   34 class Function;
include/llvm/Transforms/Utils/GlobalStatus.h
   17 class Function;
include/llvm/Transforms/Utils/GuardUtils.h
   18 class Function;
include/llvm/Transforms/Utils/ImportedFunctionsInliningStatistics.h
   23 class Function;
include/llvm/Transforms/Utils/Local.h
   48 class Function;
include/llvm/Transforms/Utils/Mem2Reg.h
   21 class Function;
include/llvm/Transforms/Utils/ModuleUtils.h
   23 class Function;
include/llvm/Transforms/Utils/PredicateInfo.h
   89 class Function;
include/llvm/Transforms/Utils/SimplifyLibCalls.h
   29 class Function;
include/llvm/Transforms/Utils/SizeOpts.h
   32 class Function;
include/llvm/Transforms/Utils/VNCoercion.h
   26 class Function;
include/llvm/Transforms/Utils/ValueMapper.h
   24 class Function;
include/llvm/Transforms/Vectorize/LoopVectorize.h
   69 class Function;
include/llvm/Transforms/Vectorize/SLPVectorizer.h
   36 class Function;
lib/AsmParser/LLParser.h
   31   class Function;
lib/Bitcode/Reader/MetadataLoader.h
   27 class Function;
lib/Bitcode/Writer/ValueEnumerator.h
   32 class Function;
lib/CodeGen/AsmPrinter/CodeViewDebug.h
   44 class Function;
lib/CodeGen/AsmPrinter/WinException.h
   19 class Function;
lib/CodeGen/SafeStackColoring.h
   24 class Function;
lib/Target/AMDGPU/AMDGPUArgumentUsageInfo.h
   19 class Function;
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.h
   29 class Function;
lib/Target/AMDGPU/AMDGPULibFunc.h
   17 class Function;
lib/Target/AMDGPU/MCTargetDesc/AMDGPUTargetStreamer.h
   24 class Function;
lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.h
   31 class Function;
lib/Target/ARM/ARM.h
   29 class Function;
lib/Transforms/ObjCARC/ARCRuntimeEntryPoints.h
   36 class Function;
tools/bugpoint/BugDriver.h
   32 class Function;
tools/clang/include/clang/CodeGen/CodeGenABITypes.h
   33   class Function;
tools/clang/lib/CodeGen/CGBlocks.h
   30 class Function;
tools/clang/lib/CodeGen/CGCUDARuntime.h
   21 class Function;
tools/clang/lib/CodeGen/CGCall.h
   29 class Function;
tools/clang/lib/CodeGen/CGObjCRuntime.h
   26   class Function;
tools/clang/lib/CodeGen/CodeGenModule.h
   43 class Function;
tools/lldb/include/lldb/Expression/IRInterpreter.h
   19 class Function;
tools/lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h
   31 class Function;
tools/llvm-diff/DiffConsumer.h
   27   class Function;
tools/llvm-diff/DifferenceEngine.h
   23   class Function;
tools/polly/include/polly/CodeGen/RuntimeDebugBuilder.h
   21 class Function;
unittests/IR/CFGBuilder.h
   32 class Function;

References

examples/BrainF/BrainF.cpp
   71   Function *memset_func = Intrinsic::getDeclaration(module, Intrinsic::memset,
   85   brainf_func = Function::Create(FunctionType::get(Type::getVoidTy(C), false),
   86                                  Function::ExternalLinkage, "brainf", module);
examples/BrainF/BrainF.h
   81     Function *brainf_func;
examples/BrainF/BrainFDriver.cpp
   80   Function *main_func =
   81       Function::Create(main_func_fty, Function::ExternalLinkage, "main", mod);
   81       Function::Create(main_func_fty, Function::ExternalLinkage, "main", mod);
   84     Function::arg_iterator args = main_func->arg_begin();
  169     Function *brainf_func = M.getFunction("brainf");
examples/Fibonacci/fibonacci.cpp
   51 static Function *CreateFibFunction(Module *M, LLVMContext &Context) {
   56   Function *FibF =
   57       Function::Create(FibFTy, Function::ExternalLinkage, "fib", M);
   57       Function::Create(FibFTy, Function::ExternalLinkage, "fib", M);
  114   Function *FibF = CreateFibFunction(M, Context);
examples/HowToUseJIT/HowToUseJIT.cpp
   71   Function *Add1F =
   72       Function::Create(FunctionType::get(Type::getInt32Ty(Context),
   74                        Function::ExternalLinkage, "add1", M);
  102   Function *FooF =
  103       Function::Create(FunctionType::get(Type::getInt32Ty(Context), {}, false),
  104                        Function::ExternalLinkage, "foo", M);
examples/HowToUseLLJIT/HowToUseLLJIT.cpp
   28   Function *Add1F =
   29       Function::Create(FunctionType::get(Type::getInt32Ty(*Context),
   31                        Function::ExternalLinkage, "add1", M.get());
examples/Kaleidoscope/BuildingAJIT/Chapter1/toy.cpp
  262   Function *codegen();
  286   Function *codegen();
  712 Function *getFunction(std::string Name) {
  714   if (auto *F = TheModule->getFunction(Name))
  729 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
  755   Function *F = getFunction(std::string("unary") + Opcode);
  808   Function *F = getFunction(std::string("binary") + Op);
  817   Function *CalleeF = getFunction(Callee);
  844   Function *TheFunction = Builder->GetInsertBlock()->getParent();
  907   Function *TheFunction = Builder->GetInsertBlock()->getParent();
  990   Function *TheFunction = Builder->GetInsertBlock()->getParent();
 1035 Function *PrototypeAST::codegen() {
 1041   Function *F =
 1042       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1042       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1052 Function *FunctionAST::codegen() {
 1057   Function *TheFunction = getFunction(P.getName());
 1115     if (auto *FnIR = FnAST->codegen()) {
 1130     if (auto *FnIR = ProtoAST->codegen()) {
examples/Kaleidoscope/BuildingAJIT/Chapter2/KaleidoscopeJIT.h
  103       for (auto &F : M)
examples/Kaleidoscope/BuildingAJIT/Chapter2/toy.cpp
  262   Function *codegen();
  286   Function *codegen();
  712 Function *getFunction(std::string Name) {
  714   if (auto *F = TheModule->getFunction(Name))
  729 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
  755   Function *F = getFunction(std::string("unary") + Opcode);
  808   Function *F = getFunction(std::string("binary") + Op);
  817   Function *CalleeF = getFunction(Callee);
  844   Function *TheFunction = Builder->GetInsertBlock()->getParent();
  907   Function *TheFunction = Builder->GetInsertBlock()->getParent();
  990   Function *TheFunction = Builder->GetInsertBlock()->getParent();
 1035 Function *PrototypeAST::codegen() {
 1041   Function *F =
 1042       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1042       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1052 Function *FunctionAST::codegen() {
 1057   Function *TheFunction = getFunction(P.getName());
 1115     if (auto *FnIR = FnAST->codegen()) {
 1130     if (auto *FnIR = ProtoAST->codegen()) {
examples/Kaleidoscope/BuildingAJIT/Chapter3/KaleidoscopeJIT.h
  145     for (auto &F : *M)
examples/Kaleidoscope/BuildingAJIT/Chapter3/toy.cpp
  262   Function *codegen();
  286   Function *codegen();
  711 Function *getFunction(std::string Name) {
  713   if (auto *F = TheModule->getFunction(Name))
  728 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
  754   Function *F = getFunction(std::string("unary") + Opcode);
  807   Function *F = getFunction(std::string("binary") + Op);
  816   Function *CalleeF = getFunction(Callee);
  843   Function *TheFunction = Builder.GetInsertBlock()->getParent();
  906   Function *TheFunction = Builder.GetInsertBlock()->getParent();
  989   Function *TheFunction = Builder.GetInsertBlock()->getParent();
 1034 Function *PrototypeAST::codegen() {
 1040   Function *F =
 1041       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1041       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1051 Function *FunctionAST::codegen() {
 1056   Function *TheFunction = getFunction(P.getName());
 1111     if (auto *FnIR = FnAST->codegen()) {
 1126     if (auto *FnIR = ProtoAST->codegen()) {
examples/Kaleidoscope/BuildingAJIT/Chapter4/KaleidoscopeJIT.h
   60   llvm::Function *codegen();
  221     for (auto &F : *M)
examples/Kaleidoscope/BuildingAJIT/Chapter4/toy.cpp
  262   Function *codegen();
  697 Function *getFunction(std::string Name) {
  699   if (auto *F = TheModule->getFunction(Name))
  714 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
  740   Function *F = getFunction(std::string("unary") + Opcode);
  793   Function *F = getFunction(std::string("binary") + Op);
  802   Function *CalleeF = getFunction(Callee);
  829   Function *TheFunction = Builder.GetInsertBlock()->getParent();
  892   Function *TheFunction = Builder.GetInsertBlock()->getParent();
  975   Function *TheFunction = Builder.GetInsertBlock()->getParent();
 1020 Function *PrototypeAST::codegen() {
 1026   Function *F =
 1027       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1027       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1045 Function *FunctionAST::codegen() {
 1049   Function *TheFunction = getFunction(P.getName());
 1104   if (auto *F = FnAST.codegen()) {
 1127     if (auto *FnIR = ProtoAST->codegen()) {
examples/Kaleidoscope/BuildingAJIT/Chapter5/KaleidoscopeJIT.h
   62   llvm::Function *codegen();
  238     for (auto &F : *M)
examples/Kaleidoscope/BuildingAJIT/Chapter5/toy.cpp
  279   Function *codegen();
  721 Function *getFunction(std::string Name) {
  723   if (auto *F = TheModule->getFunction(Name))
  738 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
  764   Function *F = getFunction(std::string("unary") + Opcode);
  817   Function *F = getFunction(std::string("binary") + Op);
  826   Function *CalleeF = getFunction(Callee);
  853   Function *TheFunction = Builder.GetInsertBlock()->getParent();
  916   Function *TheFunction = Builder.GetInsertBlock()->getParent();
  999   Function *TheFunction = Builder.GetInsertBlock()->getParent();
 1044 Function *PrototypeAST::codegen() {
 1050   Function *F =
 1051       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1051       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1069 Function *FunctionAST::codegen() {
 1073   Function *TheFunction = getFunction(P.getName());
 1128   if (auto *F = FnAST.codegen()) {
 1151     if (auto *FnIR = ProtoAST->codegen()) {
examples/Kaleidoscope/Chapter3/toy.cpp
  166   Function *codegen();
  180   Function *codegen();
  448   Function *CalleeF = TheModule->getFunction(Callee);
  466 Function *PrototypeAST::codegen() {
  472   Function *F =
  473       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
  473       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
  483 Function *FunctionAST::codegen() {
  485   Function *TheFunction = TheModule->getFunction(Proto->getName());
  523     if (auto *FnIR = FnAST->codegen()) {
  536     if (auto *FnIR = ProtoAST->codegen()) {
  550     if (auto *FnIR = FnAST->codegen()) {
examples/Kaleidoscope/Chapter4/toy.cpp
  176   Function *codegen();
  190   Function *codegen();
  425 Function *getFunction(std::string Name) {
  427   if (auto *F = TheModule->getFunction(Name))
  476   Function *CalleeF = getFunction(Callee);
  494 Function *PrototypeAST::codegen() {
  500   Function *F =
  501       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
  501       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
  511 Function *FunctionAST::codegen() {
  516   Function *TheFunction = getFunction(P.getName());
  573     if (auto *FnIR = FnAST->codegen()) {
  588     if (auto *FnIR = ProtoAST->codegen()) {
examples/Kaleidoscope/Chapter5/toy.cpp
  221   Function *codegen();
  235   Function *codegen();
  552 Function *getFunction(std::string Name) {
  554   if (auto *F = TheModule->getFunction(Name))
  603   Function *CalleeF = getFunction(Callee);
  630   Function *TheFunction = Builder.GetInsertBlock()->getParent();
  696   Function *TheFunction = Builder.GetInsertBlock()->getParent();
  768 Function *PrototypeAST::codegen() {
  774   Function *F =
  775       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
  775       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
  785 Function *FunctionAST::codegen() {
  790   Function *TheFunction = getFunction(P.getName());
  847     if (auto *FnIR = FnAST->codegen()) {
  862     if (auto *FnIR = ProtoAST->codegen()) {
examples/Kaleidoscope/Chapter6/toy.cpp
  245   Function *codegen();
  269   Function *codegen();
  644 Function *getFunction(std::string Name) {
  646   if (auto *F = TheModule->getFunction(Name))
  676   Function *F = getFunction(std::string("unary") + Opcode);
  706   Function *F = getFunction(std::string("binary") + Op);
  715   Function *CalleeF = getFunction(Callee);
  742   Function *TheFunction = Builder.GetInsertBlock()->getParent();
  808   Function *TheFunction = Builder.GetInsertBlock()->getParent();
  880 Function *PrototypeAST::codegen() {
  886   Function *F =
  887       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
  887       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
  897 Function *FunctionAST::codegen() {
  902   Function *TheFunction = getFunction(P.getName());
  966     if (auto *FnIR = FnAST->codegen()) {
  981     if (auto *FnIR = ProtoAST->codegen()) {
examples/Kaleidoscope/Chapter7/toy.cpp
  267   Function *codegen();
  291   Function *codegen();
  717 Function *getFunction(std::string Name) {
  719   if (auto *F = TheModule->getFunction(Name))
  734 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
  760   Function *F = getFunction(std::string("unary") + Opcode);
  813   Function *F = getFunction(std::string("binary") + Op);
  822   Function *CalleeF = getFunction(Callee);
  849   Function *TheFunction = Builder.GetInsertBlock()->getParent();
  912   Function *TheFunction = Builder.GetInsertBlock()->getParent();
  995   Function *TheFunction = Builder.GetInsertBlock()->getParent();
 1040 Function *PrototypeAST::codegen() {
 1046   Function *F =
 1047       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1047       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1057 Function *FunctionAST::codegen() {
 1062   Function *TheFunction = getFunction(P.getName());
 1136     if (auto *FnIR = FnAST->codegen()) {
 1151     if (auto *FnIR = ProtoAST->codegen()) {
examples/Kaleidoscope/Chapter8/toy.cpp
  268   Function *codegen();
  292   Function *codegen();
  716 Function *getFunction(std::string Name) {
  718   if (auto *F = TheModule->getFunction(Name))
  733 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
  759   Function *F = getFunction(std::string("unary") + Opcode);
  812   Function *F = getFunction(std::string("binary") + Op);
  821   Function *CalleeF = getFunction(Callee);
  848   Function *TheFunction = Builder.GetInsertBlock()->getParent();
  911   Function *TheFunction = Builder.GetInsertBlock()->getParent();
  994   Function *TheFunction = Builder.GetInsertBlock()->getParent();
 1039 Function *PrototypeAST::codegen() {
 1045   Function *F =
 1046       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1046       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1056 Function *FunctionAST::codegen() {
 1061   Function *TheFunction = getFunction(P.getName());
 1115     if (auto *FnIR = FnAST->codegen()) {
 1128     if (auto *FnIR = ProtoAST->codegen()) {
examples/Kaleidoscope/Chapter9/toy.cpp
  370   Function *codegen();
  394   Function *codegen();
  869 Function *getFunction(std::string Name) {
  871   if (auto *F = TheModule->getFunction(Name))
  886 static AllocaInst *CreateEntryBlockAlloca(Function *TheFunction,
  915   Function *F = getFunction(std::string("unary") + Opcode);
  971   Function *F = getFunction(std::string("binary") + Op);
  982   Function *CalleeF = getFunction(Callee);
 1011   Function *TheFunction = Builder.GetInsertBlock()->getParent();
 1074   Function *TheFunction = Builder.GetInsertBlock()->getParent();
 1159   Function *TheFunction = Builder.GetInsertBlock()->getParent();
 1206 Function *PrototypeAST::codegen() {
 1212   Function *F =
 1213       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1213       Function::Create(FT, Function::ExternalLinkage, Name, TheModule.get());
 1223 Function *FunctionAST::codegen() {
 1228   Function *TheFunction = getFunction(P.getName());
examples/ModuleMaker/ModuleMaker.cpp
   43   Function *F = Function::Create(FT, Function::ExternalLinkage, "main", M);
   43   Function *F = Function::Create(FT, Function::ExternalLinkage, "main", M);
   43   Function *F = Function::Create(FT, Function::ExternalLinkage, "main", M);
examples/ParallelJIT/ParallelJIT.cpp
   49 static Function* createAdd1(Module *M) {
   53   Function *Add1F =
   54       Function::Create(FunctionType::get(Type::getInt32Ty(Context),
   56                        Function::ExternalLinkage, "add1", M);
   80 static Function *CreateFibFunction(Module *M) {
   86   Function *FibF =
   87       Function::Create(FibFTy, Function::ExternalLinkage, "fib", M);
   87       Function::Create(FibFTy, Function::ExternalLinkage, "fib", M);
  132   Function* F;
  265   Function* add1F = createAdd1( M );
  266   Function* fibF = CreateFibFunction( M );
gen/lib/IR/AttributesCompatFunc.inc
  143   static bool isSet(const Function &Fn,
  148   static void set(Function &Fn,
  158   static bool isSet(const Function &Fn,
  164   static void set(Function &Fn,
  524 static inline bool hasCompatibleFnAttrs(const Function &Caller,
  525                                         const Function &Callee) {
  539 static inline void mergeFnAttrs(Function &Caller,
  540                                 const Function &Callee) {
include/llvm/ADT/ArrayRef.h
  108         const ArrayRef<U *> &A,
  110            std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
  118       const SmallVectorTemplateCommon<U *, DummyT> &Vec,
  120           std::is_convertible<U *const *, T const *>::value>::type * = nullptr)
  127     ArrayRef(const std::vector<U *, A> &Vec,
  129                  std::is_convertible<U *const *, T const *>::value>::type* = 0)
include/llvm/ADT/DenseMapInfo.h
   39   static inline T* getEmptyKey() {
   41     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   45   static inline T* getTombstoneKey() {
   47     Val <<= PointerLikeTypeTraits<T*>::NumLowBitsAvailable;
   51   static unsigned getHashValue(const T *PtrVal) {
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
   56   static bool isEqual(const T *LHS, const T *RHS) { return LHS == RHS; }
include/llvm/ADT/Optional.h
   87   template <class... Args> void emplace(Args &&... args) {
  237   template <typename... ArgTypes> void emplace(ArgTypes &&... Args) {
include/llvm/ADT/STLExtras.h
  154 auto adl_begin(ContainerTy &&container)
  162 auto adl_end(ContainerTy &&container)
  178 auto adl_begin(ContainerTy &&container)
  184 auto adl_end(ContainerTy &&container)
  250   static const bool value = sizeof(test<Ty>(nullptr)) == sizeof(yes);
 1014       std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;
 1014       std::is_base_of<T, U>::value && are_base_of<T, Ts...>::value;
 1179 bool none_of(R &&Range, UnaryPredicate P) {
 1193 auto find_if(R &&Range, UnaryPredicate P) -> decltype(adl_begin(Range)) {
include/llvm/ADT/SmallSet.h
  249 class SmallSet<PointeeType*, N> : public SmallPtrSet<PointeeType*, N> {};
include/llvm/ADT/ilist.h
   41   static void deleteNode(NodeTy *V) { delete V; }
   65   void addNodeToList(NodeTy *) {}
   66   void removeNodeFromList(NodeTy *) {}
   82 struct ilist_node_traits : ilist_alloc_traits<NodeTy>,
   83                            ilist_callback_traits<NodeTy> {};
   89 struct ilist_traits : public ilist_node_traits<NodeTy> {};
   96 template <class T> T &make();
  106   static Yes &test(U *I, decltype(I->getNext(&make<NodeT>())) * = 0);
  136   static Yes &test(U *I, decltype(I->createNode(make<NodeT>())) * = 0);
  144   static const bool value = HasGetNext<TraitsT, NodeT>::value ||
  146                             HasCreateNode<TraitsT, NodeT>::value;
  389     : public iplist_impl<simple_ilist<T, Options...>, ilist_traits<T>> {
  389     : public iplist_impl<simple_ilist<T, Options...>, ilist_traits<T>> {
include/llvm/ADT/ilist_node.h
  150           typename ilist_detail::compute_node_options<T, Options...>::type> {
  266   const ParentTy *getNodeParent() const {
  278         getNodeParent()->*(ParentTy::getSublistAccess((NodeTy *)nullptr));
  292         getNodeParent()->*(ParentTy::getSublistAccess((NodeTy *)nullptr));
include/llvm/ADT/ilist_node_options.h
  108   typedef T value_type;
  109   typedef T *pointer;
  110   typedef T &reference;
  111   typedef const T *const_pointer;
  112   typedef const T &const_reference;
  122   typedef node_options<T, extract_sentinel_tracking<Options...>::value,
include/llvm/ADT/simple_ilist.h
   79     : ilist_detail::compute_node_options<T, Options...>::type::list_base_type,
   81           typename ilist_detail::compute_node_options<T, Options...>::type> {
   85       typename ilist_detail::compute_node_options<T, Options...>::type;
include/llvm/Analysis/AliasAnalysis.h
  338   bool invalidate(Function &F, const PreservedAnalyses &PA,
  417   FunctionModRefBehavior getModRefBehavior(const Function *F);
  445   bool doesNotAccessMemory(const Function *F) {
  471   bool onlyReadsMemory(const Function *F) {
  864   virtual FunctionModRefBehavior getModRefBehavior(const Function *F) = 0;
  916   FunctionModRefBehavior getModRefBehavior(const Function *F) override {
  995     FunctionModRefBehavior getModRefBehavior(const Function *F) {
 1050   FunctionModRefBehavior getModRefBehavior(const Function *F) {
 1118   Result run(Function &F, FunctionAnalysisManager &AM) {
 1130   SmallVector<void (*)(Function &F, FunctionAnalysisManager &AM,
 1135   static void getFunctionAAResultImpl(Function &F,
 1143   static void getModuleAAResultImpl(Function &F, FunctionAnalysisManager &AM,
 1168   bool runOnFunction(Function &F) override;
 1176   using CallbackT = std::function<void(Pass &, Function &, AAResults &)>;
 1206     std::function<void(Pass &, Function &, AAResults &)> Callback);
 1215 AAResults createLegacyPMAAResults(Pass &P, Function &F, BasicAAResult &BAR);
include/llvm/Analysis/AliasAnalysisEvaluator.h
   59   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   65   void runInternal(Function &F, AAResults &AA);
include/llvm/Analysis/AssumptionCache.h
   45   Function &F;
   91   AssumptionCache(Function &F) : F(F) {}
   95   bool invalidate(Function &, const PreservedAnalyses &,
  162   AssumptionCache run(Function &F, FunctionAnalysisManager &) {
  174   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  213   AssumptionCache &getAssumptionCache(Function &F);
  217   AssumptionCache *lookupAssumptionCache(Function &F);
include/llvm/Analysis/BasicAliasAnalysis.h
   58   const Function &F;
   66   BasicAAResult(const DataLayout &DL, const Function &F,
   81   bool invalidate(Function &Fn, const PreservedAnalyses &PA,
  105   FunctionModRefBehavior getModRefBehavior(const Function *Fn);
  230   BasicAAResult run(Function &F, FunctionAnalysisManager &AM);
  247   bool runOnFunction(Function &F) override;
  256 BasicAAResult createLegacyPMBasicAAResult(Pass &P, Function &F);
  268   AAResults &operator()(Function &F) {
include/llvm/Analysis/BlockFrequencyInfo.h
   44   BlockFrequencyInfo(const Function &F, const BranchProbabilityInfo &BPI,
   53   bool invalidate(Function &F, const PreservedAnalyses &PA,
   56   const Function *getFunction() const;
   92   void calculate(const Function &F, const BranchProbabilityInfo &BPI,
  120   Result run(Function &F, FunctionAnalysisManager &AM);
  131   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  149   bool runOnFunction(Function &F) override;
include/llvm/Analysis/BlockFrequencyInfoImpl.h
  522   Optional<uint64_t> getBlockProfileCount(const Function &F,
  525   Optional<uint64_t> getProfileCountFromFreq(const Function &F,
  547   using FunctionT = Function;
  972   Optional<uint64_t> getBlockProfileCount(const Function &F,
  979   Optional<uint64_t> getProfileCountFromFreq(const Function &F,
include/llvm/Analysis/BranchProbabilityInfo.h
   56   BranchProbabilityInfo(const Function &F, const LoopInfo &LI,
  133   void calculate(const Function &F, const LoopInfo &LI,
  182   const Function *LastF;
  215   BranchProbabilityInfo run(Function &F, FunctionAnalysisManager &AM);
  226   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  245   bool runOnFunction(Function &F) override;
include/llvm/Analysis/CFG.h
   34     const Function &F,
include/llvm/Analysis/CFGPrinter.h
   32   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   38   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   44   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   50   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   58   static std::string getGraphName(const Function *F) {
   63                                         const Function *) {
   75                                           const Function *) {
  120                            const Function *Graph) {
  151                                 const Function *F) {
include/llvm/Analysis/CFLAliasAnalysisUtils.h
   24   FunctionHandle(Function *Fn, AAResult *Result)
   39     Result->evict(cast<Function>(Val));
   44 static inline const Function *parentFunctionOfValue(const Value *Val) {
include/llvm/Analysis/CFLAndersAliasAnalysis.h
   45       std::function<const TargetLibraryInfo &(Function &F)> GetTLI);
   51   bool invalidate(Function &, const PreservedAnalyses &,
   57   void evict(const Function *Fn);
   61   const cflaa::AliasSummary *getAliasSummary(const Function &);
   70   const Optional<FunctionInfo> &ensureCached(const Function &);
   73   void scan(const Function &);
   76   FunctionInfo buildInfoFrom(const Function &);
   78   std::function<const TargetLibraryInfo &(Function &F)> GetTLI;
   85   DenseMap<const Function *, Optional<FunctionInfo>> Cache;
  102   CFLAndersAAResult run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Analysis/CFLSteensAliasAnalysis.h
   46       std::function<const TargetLibraryInfo &(Function &)> GetTLI);
   53   bool invalidate(Function &, const PreservedAnalyses &,
   59   void scan(Function *Fn);
   61   void evict(Function *Fn);
   65   const Optional<FunctionInfo> &ensureCached(Function *Fn);
   69   const cflaa::AliasSummary *getAliasSummary(Function &Fn);
   94   std::function<const TargetLibraryInfo &(Function &)> GetTLI;
  101   DenseMap<Function *, Optional<FunctionInfo>> Cache;
  104   FunctionInfo buildSetsFrom(Function *F);
  119   CFLSteensAAResult run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Analysis/CGSCCPassManager.h
  409     OuterAnalysisManagerProxy<CGSCCAnalysisManager, Function>;
  481       Function &F = N->getFunction();
  484       if (!PI.runBeforePass<Function>(Pass, F))
  489       PI.runAfterPass<Function>(Pass, F);
  517     PA.preserveSet<AllAnalysesOn<Function>>();
  587       SmallDenseMap<Function *, CallCount> CallCounts;
  642         Function *F = CS.getCalledFunction();
include/llvm/Analysis/CallGraph.h
   77       std::map<const Function *, std::unique_ptr<CallGraphNode>>;
   95   void spliceFunction(const Function *From, const Function *To);
   95   void spliceFunction(const Function *From, const Function *To);
   99   void addToCallGraph(Function *F);
  121   inline const CallGraphNode *operator[](const Function *F) const {
  128   inline CallGraphNode *operator[](const Function *F) {
  153   Function *removeFunctionFromModule(CallGraphNode *CGN);
  157   CallGraphNode *getOrInsertFunction(const Function *F);
  174   inline CallGraphNode(Function *F) : F(F) {}
  187   Function *getFunction() const { return F; }
  272   Function *F;
  350   inline const CallGraphNode *operator[](const Function *F) const {
  355   inline CallGraphNode *operator[](const Function *F) { return (*G)[F]; }
  378   Function *removeFunctionFromModule(CallGraphNode *CGN) {
  384   CallGraphNode *getOrInsertFunction(const Function *F) {
  457       std::pair<const Function *const, std::unique_ptr<CallGraphNode>>;
  484       std::pair<const Function *const, std::unique_ptr<CallGraphNode>>;
include/llvm/Analysis/CodeMetrics.h
   89   static void collectEphemeralValues(const Function *L, AssumptionCache *AC,
include/llvm/Analysis/ConstantFolding.h
  146 bool canConstantFoldCallTo(const CallBase *Call, const Function *F);
  150 Constant *ConstantFoldCall(const CallBase *Call, Function *F,
include/llvm/Analysis/DDG.h
  253   DataDependenceGraph(Function &F, DependenceInfo &DI);
include/llvm/Analysis/DOTGraphTraitsPass.h
   44   virtual bool processFunction(Function &F, AnalysisT &Analysis) {
   48   bool runOnFunction(Function &F) override {
   86   virtual bool processFunction(Function &F, AnalysisT &Analysis) {
   90   bool runOnFunction(Function &F) override {
include/llvm/Analysis/DemandedBits.h
   42   DemandedBits(Function &F, AssumptionCache &AC, DominatorTree &DT) :
   71   Function &F;
   94   bool runOnFunction(Function &F) override;
  117   DemandedBits run(Function &F, FunctionAnalysisManager &AM);
  127   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Analysis/DependenceAnalysis.h
  273     DependenceInfo(Function *F, AliasAnalysis *AA, ScalarEvolution *SE,
  278     bool invalidate(Function &F, const PreservedAnalyses &PA,
  333     Function *getFunction() const { return F; }
  339     Function *F;
  935     Result run(Function &F, FunctionAnalysisManager &FAM);
  947     PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
  962     bool runOnFunction(Function &F) override;
include/llvm/Analysis/DivergenceAnalysis.h
   46   DivergenceAnalysis(const Function &F, const Loop *RegionLoop,
   52   const Function &getFunction() const { return F; }
  148   const Function &F;
  185   GPUDivergenceAnalysis(Function &F, const DominatorTree &DT,
  193   const Function &getFunction() const { return DA.getFunction(); }
include/llvm/Analysis/DomTreeUpdater.h
  149   void recalculate(Function &F);
include/llvm/Analysis/DominanceFrontier.h
  152   bool invalidate(Function &F, const PreservedAnalyses &PA,
  169   bool runOnFunction(Function &) override;
  194   DominanceFrontier run(Function &F, FunctionAnalysisManager &AM);
  205   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Analysis/EHPersonalities.h
  106 bool canSimplifyInvokeNoUnwind(const Function *F);
  114 DenseMap<BasicBlock *, ColorVector> colorEHFunclets(Function &F);
include/llvm/Analysis/GlobalsModRef.h
   37   std::function<const TargetLibraryInfo &(Function &F)> GetTLI;
   51   DenseMap<const Function *, FunctionInfo> FunctionInfos;
   56   DenseMap<const Function *, unsigned> FunctionToSCCMap;
   77       std::function<const TargetLibraryInfo &(Function &F)> GetTLI);
   85                 std::function<const TargetLibraryInfo &(Function &F)> GetTLI,
  101   FunctionModRefBehavior getModRefBehavior(const Function *F);
  109   FunctionInfo *getFunctionInfo(const Function *F);
  114                             SmallPtrSetImpl<Function *> *Readers = nullptr,
  115                             SmallPtrSetImpl<Function *> *Writers = nullptr,
include/llvm/Analysis/IndirectCallVisitor.h
   31 inline std::vector<Instruction *> findIndirectCalls(Function &F) {
include/llvm/Analysis/InlineCost.h
  217     std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
  218     Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
  227 getInlineCost(CallBase &Call, Function *Callee, const InlineParams &Params,
  229               std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
  230               Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
  234 InlineResult isInlineViable(Function &Callee);
include/llvm/Analysis/InstructionSimplify.h
  295 const SimplifyQuery getBestSimplifyQuery(Pass &, Function &);
  297 const SimplifyQuery getBestSimplifyQuery(AnalysisManager<T, TArgs...> &,
  298                                          Function &);
include/llvm/Analysis/IntervalIterator.h
   61 inline BasicBlock *getSourceGraphNode(Function *, BasicBlock *BB) {
   92   OrigContainer_t *OrigContainer;
  101   IntervalIterator(Function *M, bool OwnMemory) : IOwnMem(OwnMemory) {
  244 using function_interval_iterator = IntervalIterator<BasicBlock, Function>;
  248 inline function_interval_iterator intervals_begin(Function *F,
  252 inline function_interval_iterator intervals_end(Function *) {
include/llvm/Analysis/IntervalPartition.h
   58   bool runOnFunction(Function &F) override;
include/llvm/Analysis/LazyBlockFrequencyInfo.h
   41   void setAnalysis(const FunctionT *F, BranchProbabilityInfoPassT *BPIPass,
   72   const FunctionT *F;
  102   LazyBlockFrequencyInfo<Function, LazyBranchProbabilityInfoPass, LoopInfo,
  123   bool runOnFunction(Function &F) override;
include/llvm/Analysis/LazyBranchProbabilityInfo.h
   58     LazyBranchProbabilityInfo(const Function *F, const LoopInfo *LI,
   79     const Function *F;
  103   bool runOnFunction(Function &F) override;
include/llvm/Analysis/LazyCallGraph.h
  165     Function &getFunction() const;
  314     void replaceEdgeKey(Function &OldTarget, Function &NewTarget);
  314     void replaceEdgeKey(Function &OldTarget, Function &NewTarget);
  334     Function &getFunction() const { return *F; }
  385     Function *F;
  397     Node(LazyCallGraph &G, Function &F) : G(&G), F(&F) {}
  407     void replaceFunction(Function &NewF);
  875     void replaceNodeFunction(Node &N, Function &NewF);
  935                 function_ref<TargetLibraryInfo &(Function &)> GetTLI);
  964   Node *lookup(const Function &F) const { return NodeMap.lookup(&F); }
  985   Node &get(Function &F) {
  997   ArrayRef<Function *> getLibFunctions() const {
 1007   bool isLibFunction(Function &F) const { return LibFunctions.count(&F); }
 1024   void insertEdge(Function &Source, Function &Target, Edge::Kind EK) {
 1024   void insertEdge(Function &Source, Function &Target, Edge::Kind EK) {
 1032   void removeEdge(Function &Source, Function &Target) {
 1032   void removeEdge(Function &Source, Function &Target) {
 1056   void removeDeadFunction(Function &F);
 1081       if (Function *F = dyn_cast<Function>(C)) {
 1081       if (Function *F = dyn_cast<Function>(C)) {
 1126   DenseMap<const Function *, Node *> NodeMap;
 1155   SmallSetVector<Function *, 4> LibFunctions;
 1159   Node &insertInto(Function &F, Node *&MappedN);
 1233 inline Function &LazyCallGraph::Edge::getFunction() const {
include/llvm/Analysis/LazyValueInfo.h
  113   void printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS);
  126   bool invalidate(Function &F, const PreservedAnalyses &PA,
  134   Result run(Function &F, FunctionAnalysisManager &FAM);
  158   bool runOnFunction(Function &F) override;
include/llvm/Analysis/LegacyDivergenceAnalysis.h
   36   bool runOnFunction(Function &F) override;
   59   bool shouldUseGPUDivergenceAnalysis(const Function &F) const;
include/llvm/Analysis/Lint.h
   43   const Function &F  ///< The function to be checked
include/llvm/Analysis/LoopAccessAnalysis.h
  731   bool runOnFunction(Function &F) override;
include/llvm/Analysis/LoopAnalysisManager.h
   78 typedef InnerAnalysisManagerProxy<LoopAnalysisManager, Function>
  132   bool invalidate(Function &F, const PreservedAnalyses &PA,
  145 LoopAnalysisManagerFunctionProxy::run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Analysis/LoopInfo.h
 1057   bool invalidate(Function &F, const PreservedAnalyses &PA,
 1190   LoopInfo run(Function &F, FunctionAnalysisManager &AM);
 1199   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 1204   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 1222   bool runOnFunction(Function &F) override;
include/llvm/Analysis/LoopPass.h
  103   bool runOnFunction(Function &F) override;
  169   bool runOnFunction(Function &F) override { return false; }
include/llvm/Analysis/MemoryBuiltins.h
   62                     function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
   75                     function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
  100 bool isReallocLikeFn(const Function *F, const TargetLibraryInfo *TLI);
  121                   function_ref<const TargetLibraryInfo &(Function &)> GetTLI);
  124                   function_ref<const TargetLibraryInfo &(Function &)> GetTLI) {
  168 bool isLibFreeFunction(const Function *F, const LibFunc TLIFn);
include/llvm/Analysis/MemoryDependenceAnalysis.h
  375   bool invalidate(Function &F, const PreservedAnalyses &PA,
  525   MemoryDependenceResults run(Function &F, FunctionAnalysisManager &AM);
  540   bool runOnFunction(Function &) override;
include/llvm/Analysis/MemorySSA.h
  705   MemorySSA(Function &, AliasAnalysis *, DominatorTree *);
  796   void verifyPrevDefInPhis(Function &F) const;
  797   void verifyDefUses(Function &F) const;
  798   void verifyDomination(Function &F) const;
  799   void verifyOrdering(Function &F) const;
  800   void verifyDominationNumbers(const Function &F) const;
  873   Function &F;
  918   bool runOnFunction(Function &) override;
  942     bool invalidate(Function &F, const PreservedAnalyses &PA,
  946   Result run(Function &F, FunctionAnalysisManager &AM);
  956   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  961   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  971   bool runOnFunction(Function &) override;
include/llvm/Analysis/ModuleSummaryAnalysis.h
   37     std::function<BlockFrequencyInfo *(const Function &F)> GetBFICallback,
include/llvm/Analysis/ObjCARCAliasAnalysis.h
   50   bool invalidate(Function &, const PreservedAnalyses &,
   61   FunctionModRefBehavior getModRefBehavior(const Function *F);
   76   ObjCARCAAResult run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Analysis/ObjCARCInstKind.h
   99 ARCInstKind GetFunctionClass(const Function *F);
  108     if (const Function *F = CI->getCalledFunction())
include/llvm/Analysis/OptimizationRemarkEmitter.h
   39   OptimizationRemarkEmitter(const Function *F, BlockFrequencyInfo *BFI)
   53   OptimizationRemarkEmitter(const Function *F);
   65   bool invalidate(Function &F, const PreservedAnalyses &PA,
  100   const Function *F;
  142   bool runOnFunction(Function &F) override;
  164   Result run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Analysis/PhiValues.h
   47   PhiValues(const Function &F) : F(F) {}
   70   bool invalidate(Function &, const PreservedAnalyses &,
  107   const Function &F;
  124   PhiValues run(Function &F, FunctionAnalysisManager &);
  137   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  151   bool runOnFunction(Function &F) override;
include/llvm/Analysis/PostDominators.h
   33   explicit PostDominatorTree(Function &F) { recalculate(F); }
   35   bool invalidate(Function &F, const PreservedAnalyses &PA,
   52   PostDominatorTree run(Function &F, FunctionAnalysisManager &);
   63   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   78   bool runOnFunction(Function &F) override;
include/llvm/Analysis/ProfileSummaryInfo.h
  111   bool isFunctionEntryHot(const Function *F);
  113   bool isFunctionHotInCallGraph(const Function *F, BlockFrequencyInfo &BFI);
  115   bool isFunctionEntryCold(const Function *F);
  117   bool isFunctionColdInCallGraph(const Function *F, BlockFrequencyInfo &BFI);
  121                                              const Function *F,
include/llvm/Analysis/RegionInfo.h
   87   using FuncT = Function;
  883 class RegionNode : public RegionNodeBase<RegionTraits<Function>> {
  893 class Region : public RegionBase<RegionTraits<Function>> {
  904 class RegionInfo : public RegionInfoBase<RegionTraits<Function>> {
  906   using Base = RegionInfoBase<RegionTraits<Function>>;
  923   bool invalidate(Function &F, const PreservedAnalyses &PA,
  929   void recalculate(Function &F, DominatorTree *DT, PostDominatorTree *PDT,
  961   bool runOnFunction(Function &F) override;
  979   RegionInfo run(Function &F, FunctionAnalysisManager &AM);
  989   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  994   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Analysis/RegionPass.h
  102   bool runOnFunction(Function &F) override;
include/llvm/Analysis/RegionPrinter.h
   46   void viewRegion(const llvm::Function *F);
   66   void viewRegionOnly(const llvm::Function *F);
include/llvm/Analysis/ScalarEvolution.h
  474   ScalarEvolution(Function &F, TargetLibraryInfo &TLI, AssumptionCache &AC,
  987   bool invalidate(Function &F, const PreservedAnalyses &PA,
 1108   Function &F;
 1922   ScalarEvolution run(Function &F, FunctionAnalysisManager &AM);
 1933   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
 1947   bool runOnFunction(Function &F) override;
include/llvm/Analysis/ScalarEvolutionAliasAnalysis.h
   48   SCEVAAResult run(Function &F, FunctionAnalysisManager &AM);
   63   bool runOnFunction(Function &F) override;
include/llvm/Analysis/ScopedNoAliasAA.h
   37   bool invalidate(Function &, const PreservedAnalyses &,
   62   ScopedNoAliasAAResult run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Analysis/StackSafetyAnalysis.h
   47   StackSafetyInfo run(Function &F, FunctionAnalysisManager &AM);
   56   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   72   bool runOnFunction(Function &F) override;
include/llvm/Analysis/SyncDependenceAnalysis.h
   73   ReversePostOrderTraversal<const Function *> FuncRPOT;
include/llvm/Analysis/TargetLibraryInfo.h
  114   bool getLibFunc(const Function &FDecl, LibFunc &F) const;
  236   bool getLibFunc(const Function &FDecl, LibFunc &F) const {
  336   bool invalidate(Function &, const PreservedAnalyses &,
  363   TargetLibraryInfo run(Function &F, FunctionAnalysisManager &);
  388   TargetLibraryInfo &getTLI(const Function &F LLVM_ATTRIBUTE_UNUSED) {
  392   getTLI(const Function &F LLVM_ATTRIBUTE_UNUSED) const {
include/llvm/Analysis/TargetTransformInfo.h
  137   bool invalidate(Function &, const PreservedAnalyses &,
  249   int getCallCost(const Function *F, int NumArgs = -1,
  255   int getCallCost(const Function *F, ArrayRef<const Value *> Arguments,
  397   bool isLoweredToCall(const Function *F) const;
  654   bool useColdCCForColdCall(Function &F) const;
 1000   int getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys) const;
 1058   bool areInlineCompatible(const Function *Caller,
 1059                            const Function *Callee) const;
 1065   bool areFunctionArgsABICompatible(const Function *Caller,
 1066                                     const Function *Callee,
 1168   virtual int getCallCost(const Function *F, int NumArgs, const User *U) = 0;
 1169   virtual int getCallCost(const Function *F,
 1191   virtual bool isLoweredToCall(const Function *F) = 0;
 1234   virtual bool useColdCCForColdCall(Function &F) = 0;
 1333   virtual int getCallInstrCost(Function *F, Type *RetTy,
 1350   virtual bool areInlineCompatible(const Function *Caller,
 1351                                    const Function *Callee) const = 0;
 1353   areFunctionArgsABICompatible(const Function *Caller, const Function *Callee,
 1353   areFunctionArgsABICompatible(const Function *Caller, const Function *Callee,
 1404   int getCallCost(const Function *F, int NumArgs, const User *U) override {
 1407   int getCallCost(const Function *F,
 1455   bool isLoweredToCall(const Function *F) override {
 1556   bool useColdCCForColdCall(Function &F) override {
 1754   int getCallInstrCost(Function *F, Type *RetTy,
 1792   bool areInlineCompatible(const Function *Caller,
 1793                            const Function *Callee) const override {
 1797       const Function *Caller, const Function *Callee,
 1797       const Function *Caller, const Function *Callee,
 1884   TargetIRAnalysis(std::function<Result(const Function &)> TTICallback);
 1900   Result run(const Function &F, FunctionAnalysisManager &);
 1916   std::function<Result(const Function &)> TTICallback;
 1919   static Result getDefaultTTI(const Function &F);
 1943   TargetTransformInfo &getTTI(const Function &F);
include/llvm/Analysis/TargetTransformInfoImpl.h
  169   bool isLoweredToCall(const Function *F) {
  300   bool useColdCCForColdCall(Function &F) { return false; }
  485   unsigned getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys) {
  534   bool areInlineCompatible(const Function *Caller,
  535                            const Function *Callee) const {
  542   bool areFunctionArgsABICompatible(const Function *Caller, const Function *Callee,
  542   bool areFunctionArgsABICompatible(const Function *Caller, const Function *Callee,
  699   unsigned getCallCost(const Function *F, int NumArgs, const User *U) {
  721   unsigned getCallCost(const Function *F, ArrayRef<const Value *> Arguments,
  864       const Function *F = CS.getCalledFunction();
  901       const Function *F = CI->getCalledFunction();
include/llvm/Analysis/Trace.h
   50   Function *getFunction () const;
include/llvm/Analysis/TypeBasedAliasAnalysis.h
   38   bool invalidate(Function &, const PreservedAnalyses &,
   48   FunctionModRefBehavior getModRefBehavior(const Function *F);
   68   TypeBasedAAResult run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Analysis/ValueLatticeUtils.h
   25 bool canTrackArgumentsInterprocedurally(Function *F);
   31 bool canTrackReturnsInterprocedurally(Function *F);
include/llvm/CodeGen/Analysis.h
  133 bool attributesPermitTailCall(const Function *F, const Instruction *I,
  141 bool returnTypeIsEligibleForTailCall(const Function *F, const Instruction *I,
include/llvm/CodeGen/AsmPrinter.h
  265     const class Function *Fn;
include/llvm/CodeGen/BasicTTIImpl.h
  481           if (const Function *F = CS.getCalledFunction()) {
 1546   unsigned getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type *> Tys) {
 1731   explicit BasicTTIImpl(const TargetMachine *TM, const Function &F);
include/llvm/CodeGen/CommandFlags.inc
  373   for (auto &F : M) {
  400             if (const auto *F = Call->getCalledFunction())
include/llvm/CodeGen/ExpandReductions.h
   19   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/CodeGen/FunctionLoweringInfo.h
   55   const Function *Fn;
  189   void set(const Function &Fn, MachineFunction &MF, SelectionDAG *DAG);
include/llvm/CodeGen/GCMetadata.h
   84   const Function &F;
  101   GCFunctionInfo(const Function &F, GCStrategy &S);
  105   const Function &getFunction() const { return F; }
  177   using finfo_map_type = DenseMap<const Function *, GCFunctionInfo *>;
  200   GCFunctionInfo &getFunctionInfo(const Function &F);
include/llvm/CodeGen/GlobalISel/CallLowering.h
  185                    const FuncInfoTy &FuncInfo) const;
  292                                     const Function &F,
include/llvm/CodeGen/MachineFunction.h
  204   const Function *FilterOrFinally;
  224   const Function &F;
  424   MachineFunction(const Function &F, const LLVMTargetMachine &Target,
  463   const Function &getFunction() const { return F; }
  891   void addSEHCatchHandler(MachineBasicBlock *LandingPad, const Function *Filter,
  895                             const Function *Cleanup);
include/llvm/CodeGen/MachineFunctionPass.h
   75   bool runOnFunction(Function &F) override;
include/llvm/CodeGen/MachineModuleInfo.h
  100   std::vector<const Function *> Personalities;
  141   DenseMap<const Function*, std::unique_ptr<MachineFunction>> MachineFunctions;
  144   const Function *LastRequest = nullptr; ///< Used for shortcut/cache.
  168   MachineFunction &getOrCreateMachineFunction(const Function &F);
  172   MachineFunction *getMachineFunction(const Function &F) const;
  176   void deleteMachineFunctionFor(Function &F);
  240   void takeDeletedSymbolsForFunction(const Function *F,
  254   void addPersonality(const Function *Personality);
  257   const std::vector<const Function *>& getPersonalities() const {
include/llvm/CodeGen/MachineOptimizationRemarkEmitter.h
   75     const Function &Fn = getFunction();
  101     const Function &Fn = getFunction();
  127     const Function &Fn = getFunction();
include/llvm/CodeGen/RegisterUsageInfo.h
   50   void storeUpdateRegUsageInfo(const Function &FP,
   55   ArrayRef<uint32_t> getRegUsageInfo(const Function &FP);
   63   DenseMap<const Function *, std::vector<uint32_t>> RegMasks;
include/llvm/CodeGen/SelectionDAG.h
 1182                                          Function **TargetFunction = nullptr);
include/llvm/CodeGen/SelectionDAGISel.h
  330   void SelectAllBasicBlocks(const Function &Fn);
  344   void LowerArguments(const Function &F);
include/llvm/CodeGen/StackProtector.h
   50   Function *F;
  116   bool runOnFunction(Function &Fn) override;
include/llvm/CodeGen/SwiftErrorValueTracking.h
   39   const Function *Fn;
include/llvm/CodeGen/TargetFrameLowering.h
  378   static bool isSafeForNoCSROpt(const Function &F);
  381   virtual bool isProfitableForNoCSROpt(const Function &F) const {
include/llvm/CodeGen/TargetLowering.h
 1013   virtual bool areJTsAllowed(const Function *Fn) const {
 1651   virtual Function *getSSPStackGuardCheck(const Module &M) const;
include/llvm/CodeGen/TargetLoweringObjectFileImpl.h
   65   MCSection *getSectionForJumpTable(const Function &F,
   69                                            const Function &F) const override;
  156   MCSection *getSectionForJumpTable(const Function &F,
  198                                            const Function &F) const override;
  219                                            const Function &F) const override;
include/llvm/CodeGen/UnreachableBlockElim.h
   32   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/CodeGen/WasmEHFuncInfo.h
   55 void calculateWasmEHInfo(const Function *F, WasmEHFuncInfo &EHInfo);
include/llvm/CodeGen/WinEHFuncInfo.h
   54   const Function *Filter = nullptr;
  118 void calculateWinCXXEHStateNumbers(const Function *ParentFn,
  121 void calculateSEHStateNumbers(const Function *ParentFn,
  124 void calculateClrEHStateNumbers(const Function *Fn, WinEHFuncInfo &FuncInfo);
include/llvm/ExecutionEngine/ExecutionEngine.h
  213   virtual Function *FindFunctionNamed(StringRef FnName);
  229   virtual GenericValue runFunction(Function *F,
  296   int runFunctionAsMain(Function *Fn, const std::vector<std::string> &argv,
  350   virtual void *getPointerToFunction(Function *F) = 0;
  359   virtual void *getPointerToFunctionOrStub(Function *F) {
include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h
  200       std::set<Function*> StubsToClone;
  224     std::set<Function*>& getStubsToClone(SourceModuleHandle H) {
  258   using PartitioningFtor = std::function<std::set<Function*>(Function&)>;
  258   using PartitioningFtor = std::function<std::set<Function*>(Function&)>;
  397       for (auto &F : SrcM) {
  472         if (auto *F = dyn_cast<Function>(V)) {
  472         if (auto *F = dyn_cast<Function>(V)) {
  582                     Function &F) {
  596       for (auto *SubF : Part) {
  635     for (auto *F : Part) {
  649       if (auto *F = dyn_cast<Function>(V)) {
  649       if (auto *F = dyn_cast<Function>(V)) {
  658         auto *ClonedF = cloneFunctionDecl(*M, *F);
  668           return Function::Create(cast<FunctionType>(Ty),
  682     for (auto *F : Part)
  686     for (auto *F : Part)
include/llvm/ExecutionEngine/Orc/ExecutionUtils.h
   55     Element(unsigned Priority, Function *Func, Value *Data)
   59     Function *Func;
include/llvm/ExecutionEngine/Orc/IndirectionUtils.h
  422 void makeStub(Function &F, Value &ImplPointer);
  449 Function *cloneFunctionDecl(Module &Dst, const Function &F,
  449 Function *cloneFunctionDecl(Module &Dst, const Function &F,
  460 void moveFunctionBody(Function &OrigF, ValueToValueMapTy &VMap,
  462                       Function *NewF = nullptr);
include/llvm/ExecutionEngine/Orc/SpeculateAnalyses.h
   30   bool isStraightLine(const Function &F);
   42   ResultTy operator()(Function &F);
   66   BlockListTy rearrangeBB(const Function &, const BlockListTy &);
   67   BlockListTy queryCFG(Function &, const BlockListTy &);
   78   ResultTy operator()(Function &F);
include/llvm/ExecutionEngine/Orc/Speculation.h
  172   using ResultEval = std::function<IRlikiesStrRef(Function &)>;
include/llvm/FuzzMutate/IRMutator.h
   49   virtual void mutate(Function &F, RandomIRBuilder &IB);
   91   void mutate(Function &F, RandomIRBuilder &IB) override;
  101   void mutate(Function &F, RandomIRBuilder &IB) override;
include/llvm/IR/Argument.h
   30   Function *Parent;
   34   void setParent(Function *parent);
   38   explicit Argument(Type *Ty, const Twine &Name = "", Function *F = nullptr,
   41   inline const Function *getParent() const { return Parent; }
   42   inline       Function *getParent()       { return Parent; }
include/llvm/IR/AssemblyAnnotationWriter.h
   33   virtual void emitFunctionAnnot(const Function *,
include/llvm/IR/Attributes.h
  878 bool areInlineCompatible(const Function &Caller, const Function &Callee);
  878 bool areInlineCompatible(const Function &Caller, const Function &Callee);
  881 void mergeAttributesForInlining(Function &Caller, const Function &Callee);
  881 void mergeAttributesForInlining(Function &Caller, const Function &Callee);
include/llvm/IR/AutoUpgrade.h
   33   bool UpgradeIntrinsicFunction(Function *F, Function *&NewFn);
   33   bool UpgradeIntrinsicFunction(Function *F, Function *&NewFn);
   37   void UpgradeIntrinsicCall(CallInst *CI, Function *NewFn);
   47   void UpgradeCallsToIntrinsic(Function* F);
include/llvm/IR/BasicBlock.h
   58                          public ilist_node_with_parent<BasicBlock, Function> {
   67   Function *Parent;
   69   void setParent(Function *parent);
   77                       Function *Parent = nullptr,
  100                             Function *Parent = nullptr,
  106   const Function *getParent() const { return Parent; }
  107         Function *getParent()       { return Parent; }
  222   void insertInto(Function *Parent, BasicBlock *InsertBefore = nullptr);
include/llvm/IR/CFG.h
  349   static NodeRef getEntryNode(Function *F) { return &F->getEntryBlock(); }
  352   using nodes_iterator = pointer_iterator<Function::iterator>;
  362   static size_t size(Function *F) { return F->size(); }
  366   static NodeRef getEntryNode(const Function *F) { return &F->getEntryBlock(); }
  369   using nodes_iterator = pointer_iterator<Function::const_iterator>;
  379   static size_t size(const Function *F) { return F->size(); }
  389   static NodeRef getEntryNode(Inverse<Function *> G) {
  395   static NodeRef getEntryNode(Inverse<const Function *> G) {
include/llvm/IR/CallSite.h
  111   FunTy *getCalledFunction() const {
  112     return dyn_cast<FunTy>(getCalledValue());
  120     if (isa<FunTy>(V) || isa<Constant>(V))
  142     if (auto *F = getCalledFunction())
  275   FunTy *getCaller() const { return (*this)->getParent()->getParent(); }
  672 class CallSite : public CallSiteBase<Function, BasicBlock, Value, User, Use,
  875   Function *getCalledFunction() const {
  877     return V ? dyn_cast<Function>(V->stripPointerCasts()) : nullptr;
include/llvm/IR/Constants.h
  459   static typename std::enable_if<are_base_of<Constant, Csts...>::value,
  461   get(StructType *T, Csts *... Vs) {
  842   BlockAddress(Function *F, BasicBlock *BB);
  851   static BlockAddress *get(Function *F, BasicBlock *BB);
  865   Function *getFunction() const { return (Function*)Op<0>().get(); }
include/llvm/IR/DIBuilder.h
   46     Function *DeclareFn;     ///< llvm.dbg.declare
   47     Function *ValueFn;       ///< llvm.dbg.value
   48     Function *LabelFn;       ///< llvm.dbg.label
include/llvm/IR/DebugInfo.h
   39 bool stripDebugInfo(Function &F);
include/llvm/IR/DebugInfoMetadata.h
 1833   bool describes(const Function *F) const;
include/llvm/IR/DerivedTypes.h
  175   FunctionCallee(T *Fn)
include/llvm/IR/DiagnosticInfo.h
  179   const Function &Fn;
  193   DiagnosticInfoResourceLimit(const Function &Fn, const char *ResourceName,
  201   const Function &getFunction() const { return Fn; }
  217   DiagnosticInfoStackSize(const Function &Fn, uint64_t StackSize,
  372                                  const Function &Fn,
  392   const Function &getFunction() const { return Fn; }
  397   const Function &Fn;
  449                                  const Function &Fn,
  619                                const Function &Fn,
  653                                const char *PassName, const Function &Fn,
  691                      const Function *Func);
  710   OptimizationRemark(const char *PassName, const Function &Fn,
  751   OptimizationRemarkMissed(const char *PassName, const Function &Fn,
  799                              const Function &Fn, const DiagnosticLocation &Loc,
  818   OptimizationRemarkAnalysis(const char *PassName, const Function &Fn,
  859   OptimizationRemarkAnalysisFPCommute(const char *PassName, const Function &Fn,
  900   OptimizationRemarkAnalysisAliasing(const char *PassName, const Function &Fn,
  928   const Function &Fn;
  931   DiagnosticInfoISelFallback(const Function &Fn,
  935   const Function &getFunction() const { return Fn; }
  956   DiagnosticInfoOptimizationFailure(const Function &Fn,
  992       const Function &Fn, const Twine &Msg,
include/llvm/IR/Dominators.h
  149   explicit DominatorTree(Function &F) { recalculate(F); }
  155   bool invalidate(Function &F, const PreservedAnalyses &PA,
  239   DominatorTree run(Function &F, FunctionAnalysisManager &);
  250   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  255   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  272   bool runOnFunction(Function &F) override;
include/llvm/IR/Function.h
   59 class Function : public GlobalObject, public ilist_node<Function> {
  126   Function(const Function&) = delete;
  127   void operator=(const Function&) = delete;
  133   const Function &getFunction() const { return *this; }
  135   static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
  138     return new Function(Ty, Linkage, AddrSpace, N, M);
  142   static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
  144     return new Function(Ty, Linkage, static_cast<unsigned>(-1), N, M);
  151   static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
  633   void copyAttributesFrom(const Function *Src);
  657   void stealArgumentListFrom(Function &Src);
  666     return &Function::BasicBlocks;
  856 bool NullPointerIsDefined(const Function *F, unsigned AS = 0);
include/llvm/IR/IRBuilder.h
  261     Function *F = BB->getParent();
 2441     Function *FnLaunderInvariantGroup = Intrinsic::getDeclaration(
 2469     Function *FnStripInvariantGroup = Intrinsic::getDeclaration(
 2541     Function *FnPreserveArrayAccessIndex = Intrinsic::getDeclaration(
 2560     Function *FnPreserveUnionAccessIndex = Intrinsic::getDeclaration(
 2584     Function *FnPreserveStructAccessIndex = Intrinsic::getDeclaration(
include/llvm/IR/IRPrintingPasses.h
  107   PreservedAnalyses run(Function &F, AnalysisManager<Function> &);
  107   PreservedAnalyses run(Function &F, AnalysisManager<Function> &);
include/llvm/IR/InstIterator.h
   60   template<class M> InstIterator(M &m)
   68   template<class M> InstIterator(M &m, bool)
  122     InstIterator<SymbolTableList<BasicBlock>, Function::iterator,
  126                  Function::const_iterator, BasicBlock::const_iterator,
include/llvm/IR/InstVisitor.h
  100   void visit(Function &F) {
  111   void visit(Function     *F)  { visit(*F); }
  144   void visitFunction  (Function &F) {}
  303     if (const Function *F = I.getCalledFunction()) {
include/llvm/IR/InstrTypes.h
 1292   Function *getCalledFunction() const {
 1293     return dyn_cast_or_null<Function>(getCalledOperand());
 1308   Function *getCaller();
 1309   const Function *getCaller() const {
 1328   void setCalledFunction(Function *Fn) {
include/llvm/IR/Instruction.h
   84   const Function *getFunction() const;
   85   Function *getFunction() {
include/llvm/IR/Instructions.h
 1599                                    Function *MallocF = nullptr,
 1604                                    Function *MallocF = nullptr,
 1610                                    Function *MallocF = nullptr,
 1616                                    Function *MallocF = nullptr,
include/llvm/IR/IntrinsicInst.h
   56       if (const Function *CF = I->getCalledFunction())
include/llvm/IR/Intrinsics.h
   80   Function *getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys = None);
  195   llvm::Optional<Function*> remangleIntrinsicFunction(Function *F);
  195   llvm::Optional<Function*> remangleIntrinsicFunction(Function *F);
include/llvm/IR/LLVMContext.h
  120   void setGC(const Function &Fn, std::string GCName);
  123   const std::string &getGC(const Function &Fn);
  126   void deleteGC(const Function &Fn);
include/llvm/IR/LegacyPassManager.h
   80   bool run(Function &F);
include/llvm/IR/LegacyPassManagers.h
  338   virtual Pass *getOnTheFlyPass(Pass *P, AnalysisID PI, Function &F);
  424       Function *F = nullptr);
  474   bool runOnFunction(Function &F);
include/llvm/IR/MDBuilder.h
   99   MDNode *createCallees(ArrayRef<Function *> Callees);
include/llvm/IR/Metadata.h
  514   static const bool value = std::is_base_of<Constant, V>::value &&
  563 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
  563 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
  566     return cast<X>(V->getValue());
  576 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
  576 inline typename std::enable_if<detail::IsValidPointer<X, Y>::value, X *>::type
  579     return dyn_cast<X>(V->getValue());
include/llvm/IR/Module.h
   73   using FunctionListType = SymbolTableList<Function>;
  381   Function *getFunction(StringRef Name) const;
include/llvm/IR/ModuleSlotTracker.h
   36   const Function *F = nullptr;
   42                     const Function *F = nullptr);
   61   const Function *getCurrentFunction() const { return F; }
   67   void incorporateFunction(const Function &F);
include/llvm/IR/PassInstrumentation.h
  144   bool runBeforePass(const PassT &Pass, const IRUnitT &IR) const {
  158   void runAfterPass(const PassT &Pass, const IRUnitT &IR) const {
  177   void runBeforeAnalysis(const PassT &Analysis, const IRUnitT &IR) const {
  186   void runAfterAnalysis(const PassT &Analysis, const IRUnitT &IR) const {
  198   bool invalidate(IRUnitT &, const class llvm::PreservedAnalyses &,
include/llvm/IR/PassManager.h
  420 getAnalysisResultUnpackTuple(AnalysisManagerT &AM, IRUnitT &IR,
  435 getAnalysisResult(AnalysisManager<IRUnitT, AnalysisArgTs...> &AM, IRUnitT &IR,
  435 getAnalysisResult(AnalysisManager<IRUnitT, AnalysisArgTs...> &AM, IRUnitT &IR,
  438           PassT, IRUnitT>)(AM, IR, Args,
  466                         PassManager<IRUnitT, AnalysisManagerT, ExtraArgTs...>> {
  489   PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
  502       dbgs() << "Starting " << getTypeName<IRUnitT>() << " pass manager run.\n";
  513       if (!PI.runBeforePass<IRUnitT>(*P, IR))
  520       PI.runAfterPass<IRUnitT>(*P, IR);
  541     PA.preserveSet<AllAnalysesOn<IRUnitT>>();
  544       dbgs() << "Finished " << getTypeName<IRUnitT>() << " pass manager run.\n";
  551         detail::PassModel<IRUnitT, PassT, PreservedAnalyses, AnalysisManagerT,
  559       detail::PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...>;
  575 using FunctionPassManager = PassManager<Function>;
  598   Result run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...) {
  615       detail::AnalysisResultConcept<IRUnitT, PreservedAnalyses, Invalidator>;
  617       detail::AnalysisPassConcept<IRUnitT, PreservedAnalyses, Invalidator,
  630   using AnalysisResultListMapT = DenseMap<IRUnitT *, AnalysisResultListT>;
  636       DenseMap<std::pair<AnalysisKey *, IRUnitT *>,
  667     bool invalidate(IRUnitT &IR, const PreservedAnalyses &PA) {
  669           detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result,
  681     bool invalidate(AnalysisKey *ID, IRUnitT &IR, const PreservedAnalyses &PA) {
  689     bool invalidateImpl(AnalysisKey *ID, IRUnitT &IR,
  747   void clear(IRUnitT &IR, llvm::StringRef Name) {
  777   typename PassT::Result &getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs) {
  784         detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result,
  796   typename PassT::Result *getCachedResult(IRUnitT &IR) const {
  805         detail::AnalysisResultModel<IRUnitT, PassT, typename PassT::Result,
  832         detail::AnalysisPassModel<IRUnitT, PassT, PreservedAnalyses,
  849   template <typename PassT> void invalidate(IRUnitT &IR) {
  859   void invalidate(IRUnitT &IR, const PreservedAnalyses &PA) {
  861     if (PA.allAnalysesInSetPreserved<AllAnalysesOn<IRUnitT>>())
  939   ResultConceptT &getResultImpl(AnalysisKey *ID, IRUnitT &IR,
  977   ResultConceptT *getCachedResultImpl(AnalysisKey *ID, IRUnitT &IR) const {
  984   void invalidateImpl(AnalysisKey *ID, IRUnitT &IR) {
 1026 using FunctionAnalysisManager = AnalysisManager<Function>;
 1047           InnerAnalysisManagerProxy<AnalysisManagerT, IRUnitT>> {
 1108   Result run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
 1108   Result run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
 1163           OuterAnalysisManagerProxy<AnalysisManagerT, IRUnitT, ExtraArgTs...>> {
 1174         IRUnitT &IRUnit, const PreservedAnalyses &PA,
 1175         typename AnalysisManager<IRUnitT, ExtraArgTs...>::Invalidator &Inv) {
 1235   Result run(IRUnitT &, AnalysisManager<IRUnitT, ExtraArgTs...> &,
 1235   Result run(IRUnitT &, AnalysisManager<IRUnitT, ExtraArgTs...> &,
 1257     OuterAnalysisManagerProxy<ModuleAnalysisManager, Function>;
 1299     for (Function &F : M) {
 1306       if (!PI.runBeforePass<Function>(Pass, F))
 1327     PA.preserveSet<AllAnalysesOn<Function>>();
 1357     : PassInfoMixin<RequireAnalysisPass<AnalysisT, IRUnitT, AnalysisManagerT,
 1365   PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM,
 1386   PreservedAnalyses run(IRUnitT &Arg, AnalysisManagerT &AM, ExtraArgTs &&...) {
 1400   PreservedAnalyses run(IRUnitT &, AnalysisManagerT &, ExtraArgTs &&...) {
 1415   PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM, Ts &&... Args) {
 1430       if (!PI.runBeforePass<IRUnitT>(P, IR))
include/llvm/IR/PassManagerInternal.h
   46   virtual PreservedAnalyses run(IRUnitT &IR, AnalysisManagerT &AM,
   60 struct PassModel : PassConcept<IRUnitT, AnalysisManagerT, ExtraArgTs...> {
   77   PreservedAnalysesT run(IRUnitT &IR, AnalysisManagerT &AM,
  110   virtual bool invalidate(IRUnitT &IR, const PreservedAnalysesT &PA,
  128       std::declval<IRUnitT &>(), std::declval<PreservedAnalyses>()))>::Type
  168     : AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT> {
  191   bool invalidate(IRUnitT &, const PreservedAnalysesT &PA,
  195            !PAC.template preservedSet<AllAnalysesOn<IRUnitT>>();
  207     : AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT> {
  226   bool invalidate(IRUnitT &IR, const PreservedAnalysesT &PA,
  247       AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT>>
  248   run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
  248   run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
  262 struct AnalysisPassModel : AnalysisPassConcept<IRUnitT, PreservedAnalysesT,
  282       AnalysisResultModel<IRUnitT, PassT, typename PassT::Result,
  289       AnalysisResultConcept<IRUnitT, PreservedAnalysesT, InvalidatorT>>
  290   run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
  290   run(IRUnitT &IR, AnalysisManager<IRUnitT, ExtraArgTs...> &AM,
include/llvm/IR/PatternMatch.h
 1695       if (const auto *F = CI->getCalledFunction())
include/llvm/IR/SafepointIRVerifier.h
   29 void verifySafepointIR(Function &F);
   42   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/IR/Statepoint.h
  142   FunTy *getCalledFunction() const {
  147   FunTy *getCaller() const { return getCall()->getCaller(); }
  151     Function *F = getCalledFunction();
  192     Function *F = getCalledFunction();
  293     : public StatepointBase<const Function, const Instruction, const Value,
  295   using Base = StatepointBase<const Function, const Instruction, const Value,
  306     : public StatepointBase<Function, Instruction, Value, CallBase> {
  307   using Base = StatepointBase<Function, Instruction, Value, CallBase>;
include/llvm/IR/SymbolTableListTraits.h
   66 class SymbolTableListTraits : public ilist_alloc_traits<ValueSubClass> {
   67   using ListTy = SymbolTableList<ValueSubClass>;
   68   using iterator = typename simple_ilist<ValueSubClass>::iterator;
   70       typename SymbolTableListParentType<ValueSubClass>::type;
   95   void addNodeToList(ValueSubClass *V);
   96   void removeNodeFromList(ValueSubClass *V);
  113     : public iplist_impl<simple_ilist<T>, SymbolTableListTraits<T>> {};
  113     : public iplist_impl<simple_ilist<T>, SymbolTableListTraits<T>> {};
include/llvm/IR/UseListOrder.h
   28   const Function *F = nullptr;
   31   UseListOrder(const Value *V, const Function *F, size_t ShuffleSize)
include/llvm/IR/User.h
  127   template <int Idx, typename U> static Use &OpFrom(const U *that) {
  129       ? OperandTraits<U>::op_end(const_cast<U*>(that))[Idx]
  130       : OperandTraits<U>::op_begin(const_cast<U*>(that))[Idx];
include/llvm/IR/Value.h
  899     return isa<GlobalVariable>(Val) || isa<Function>(Val);
include/llvm/IR/ValueHandle.h
  256   ValueTy *getValPtr() const { return static_cast<ValueTy *>(getRawValPtr()); }
  257   void setValPtr(ValueTy *P) { setRawValPtr(GetAsValue(P)); }
  262   AssertingVH(ValueTy *P) : ValueHandleBase(Assert, GetAsValue(P)) {}
  269   operator ValueTy*() const {
  273   ValueTy *operator=(ValueTy *RHS) {
  273   ValueTy *operator=(ValueTy *RHS) {
  277   ValueTy *operator=(const AssertingVH<ValueTy> &RHS) {
  277   ValueTy *operator=(const AssertingVH<ValueTy> &RHS) {
  282   ValueTy *operator->() const { return getValPtr(); }
  283   ValueTy &operator*() const { return *getValPtr(); }
  289   static inline AssertingVH<T> getEmptyKey() {
  290     AssertingVH<T> Res;
  295   static inline AssertingVH<T> getTombstoneKey() {
  296     AssertingVH<T> Res;
  301   static unsigned getHashValue(const AssertingVH<T> &Val) {
  305   static bool isEqual(const AssertingVH<T> &LHS, const AssertingVH<T> &RHS) {
  305   static bool isEqual(const AssertingVH<T> &LHS, const AssertingVH<T> &RHS) {
include/llvm/IR/Verifier.h
   88 bool verifyFunction(const Function &F, raw_ostream *OS = nullptr);
  118   Result run(Function &F, FunctionAnalysisManager &);
  143   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/LTO/legacy/LTOModule.h
  192   void addDefinedFunctionSymbol(StringRef Name, const Function *F);
include/llvm/LinkAllPasses.h
  232       llvm::Function::Create(nullptr, llvm::GlobalValue::ExternalLinkage)->viewCFGOnly();
include/llvm/Pass.h
  210   AnalysisType &getAnalysis(Function &F); // Defined in PassAnalysisSupport.h
  216   AnalysisType &getAnalysisID(AnalysisID PI, Function &F);
  294   virtual bool runOnFunction(Function &F) = 0;
  305   bool skipFunction(const Function &F) const;
  334   virtual bool doInitialization(Function &);
  342   virtual bool doFinalization(Function &);
include/llvm/PassAnalysisSupport.h
  167   Pass *findImplPass(Pass *P, AnalysisID PI, Function &F);
  248 AnalysisType &Pass::getAnalysis(Function &F) {
  255 AnalysisType &Pass::getAnalysisID(AnalysisID PI, Function &F) {
include/llvm/Passes/PassBuilder.h
  743     PassManager<IRUnitT, AnalysisManagerT, ExtraArgTs...> &PM) {
include/llvm/ProfileData/InstrProf.h
  162 std::string getPGOFuncName(const Function &F, bool InLTO = false,
  183 GlobalVariable *createPGOFuncNameVar(Function &F, StringRef PGOFuncName);
  230 bool canRenameComdatFunc(const Function &F, bool CheckAddressTaken = false);
  262 MDNode *getPGOFuncNameMetadata(const Function &F);
  267 void createPGOFuncNameMetadata(Function &F, StringRef PGOFuncName);
  271 bool needsComdatForCounter(const Function &F, const Module &M);
  419   std::vector<std::pair<uint64_t, Function *>> MD5FuncMap;
  508   inline Function *getFunction(uint64_t FuncMD5Hash);
  568 Function* InstrProfSymtab::getFunction(uint64_t FuncMD5Hash) {
include/llvm/ProfileData/SampleProf.h
  109   GUIDBuf = std::to_string(Function::getGUID(Name));
  476           const Function *Callee =
  499   static StringRef getCanonicalFnName(const Function &F) {
  568                                           : Function::getGUID(Name);
include/llvm/ProfileData/SampleProfReader.h
  353   FunctionSamples *getSamplesFor(const Function &F) {
include/llvm/Support/Casting.h
   58     return To::classof(&Val);
   66   static inline bool doit(const From &) { return true; }
   77     return isa_impl<To, From>::doit(Val);
   92     return isa_impl<To, From>::doit(*Val);
  104   static inline bool doit(const From *Val) {
  106     return isa_impl<To, From>::doit(*Val);
  106     return isa_impl<To, From>::doit(*Val);
  122     return isa_impl_wrap<To, SimpleFrom,
  132     return isa_impl_cl<To,FromTy>::doit(Val);
  142   return isa_impl_wrap<X, const Y,
  165   using ret_type = To &;       // Normal case, return Ty&
  168   using ret_type = const To &; // Normal case, return Ty&
  172   using ret_type = To *;       // Pointer arg case, return Ty*
  176   using ret_type = const To *; // Constant pointer arg case, return const Ty*
  198   using ret_type = typename cast_retty<To, SimpleFrom>::ret_type;
  204   using ret_type = typename cast_retty_impl<To,FromTy>::ret_type;
  210       To, From, typename simplify_type<From>::SimpleType>::ret_type;
  218   static typename cast_retty<To, From>::ret_type doit(From &Val) {
  219     return cast_convert_val<To, SimpleFrom,
  227   static typename cast_retty<To, FromTy>::ret_type doit(const FromTy &Val) {
  228     typename cast_retty<To, FromTy>::ret_type Res2
  248                                typename cast_retty<X, const Y>::ret_type>::type
  256 inline typename cast_retty<X, Y>::ret_type cast(Y &Val) {
  258   return cast_convert_val<X, Y,
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  263 inline typename cast_retty<X, Y *>::ret_type cast(Y *Val) {
  265   return cast_convert_val<X, Y*,
  265   return cast_convert_val<X, Y*,
  266                           typename simplify_type<Y*>::SimpleType>::doit(Val);
  337 LLVM_NODISCARD inline typename cast_retty<X, Y>::ret_type dyn_cast(Y &Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  342 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type dyn_cast(Y *Val) {
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  343   return isa<X>(Val) ? cast<X>(Val) : nullptr;
  366 LLVM_NODISCARD inline typename cast_retty<X, Y *>::ret_type
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
  368   return (Val && isa<X>(Val)) ? cast<X>(Val) : nullptr;
include/llvm/Support/GenericDomTreeConstruction.h
  563     auto *Parent = DT.Parent;
include/llvm/Support/PointerLikeTypeTraits.h
   56   static inline void *getAsVoidPointer(T *P) { return P; }
   57   static inline T *getFromVoidPointer(void *P) { return static_cast<T *>(P); }
   59   enum { NumLowBitsAvailable = detail::ConstantLog2<alignof(T)>::value };
   91   typedef PointerLikeTypeTraits<T *> NonConst;
   93   static inline const void *getAsVoidPointer(const T *P) {
   96   static inline const T *getFromVoidPointer(const void *P) {
include/llvm/Target/TargetIntrinsicInfo.h
   55   virtual unsigned getIntrinsicID(const Function *F) const;
   63   virtual Function *getDeclaration(Module *M, unsigned ID, Type **Tys = nullptr,
include/llvm/Target/TargetLoweringObjectFile.h
  116   virtual MCSection *getSectionForJumpTable(const Function &F,
  120                                                    const Function &F) const;
include/llvm/Target/TargetMachine.h
  117   virtual const TargetSubtargetInfo *getSubtargetImpl(const Function &) const {
  148   template <typename STC> const STC &getSubtarget(const Function &F) const {
  186   void resetTargetOptions(const Function &F) const;
  268   virtual TargetTransformInfo getTargetTransformInfo(const Function &F);
  337   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
include/llvm/Transforms/AggressiveInstCombine/AggressiveInstCombine.h
   29   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/IPO/Attributor.h
  174   static const IRPosition function(const Function &F) {
  179   static const IRPosition returned(const Function &F) {
  270   Function *getAssociatedFunction() {
  276     if (isa<Function>(V))
  277       return &cast<Function>(V);
  284   const Function *getAssociatedFunction() const {
  298     Function *AssociatedFn = getAssociatedFunction();
  324   Function *getAnchorScope() {
  326     if (isa<Function>(V))
  327       return &cast<Function>(V);
  334   const Function *getAnchorScope() const {
  349     if (auto *F = dyn_cast<Function>(&V))
  349     if (auto *F = dyn_cast<Function>(&V))
  564   typename Analysis::Result *getAnalysis(const Function &F) {
  606     DenseMap<const Function *, unsigned> SccSize;
  627   InstructionVectorTy &getReadOrWriteInstsForFunction(const Function &F) {
  637   TargetLibraryInfo *getTargetLibraryInfoForFunction(const Function &F) {
  642   AAResults *getAAResultsForFunction(const Function &F) {
  647   unsigned getSccSize(const Function &F) {
  658   using FuncInstOpcodeMapTy = DenseMap<const Function *, OpcodeInstMapTy>;
  661   using FuncRWInstsMapTy = DenseMap<const Function *, InstructionVectorTy>;
  680   Optional<DenseMap<const Function *, unsigned>> SccSizeOpt;
  810   void identifyDefaultAbstractAttributes(Function &F);
  816   void initializeInformationCache(Function &F);
  822   void markLiveInternalFunction(const Function &F) {
  836   void deleteAfterManifest(Function &F) { ToBeDeletedFunctions.insert(&F); }
  909                             const Function &Fn, bool RequireAllCallSites,
  929     if (const Function *Fn = IRP.getAnchorScope())
 1007   DenseSet<const Function *> VisitedFunctions;
 1012   SmallPtrSet<Function *, 8> ToBeDeletedFunctions;
 1355     const Function *FnScope = IRP.getAnchorScope();
include/llvm/Transforms/IPO/DeadArgumentElimination.h
   45     const Function *F;
   49     RetOrArg(const Function *F, unsigned Idx, bool IsArg)
   82   RetOrArg CreateRet(const Function *F, unsigned Idx) {
   87   RetOrArg CreateArg(const Function *F, unsigned Idx) {
  110   using LiveFuncSet = std::set<const Function *>;
  130   void SurveyFunction(const Function &F);
  134   void MarkLive(const Function &F);
  136   bool RemoveDeadStuffFromFunction(Function *F);
  137   bool DeleteDeadVarargs(Function &Fn);
  138   bool RemoveDeadArgumentsFromCallers(Function &Fn);
include/llvm/Transforms/IPO/FunctionAttrs.h
   39 MemoryAccessKind computeFunctionBodyMemoryAccess(Function &F, AAResults &AAR);
include/llvm/Transforms/IPO/GlobalDCE.h
   63   void ScanVTableLoad(Function *Caller, Metadata *TypeId, uint64_t CallOffset);
include/llvm/Transforms/IPO/HotColdSplitting.h
   36                    function_ref<BlockFrequencyInfo *(Function &)> GBFI,
   37                    function_ref<TargetTransformInfo &(Function &)> GTTI,
   38                    std::function<OptimizationRemarkEmitter &(Function &)> *GORE,
   39                    function_ref<AssumptionCache *(Function &)> LAC)
   44   bool isFunctionCold(const Function &F) const;
   45   bool shouldOutlineFrom(const Function &F) const;
   46   bool outlineColdRegions(Function &F, bool HasProfileSummary);
   47   Function *extractColdRegion(const BlockSequence &Region,
   54   function_ref<BlockFrequencyInfo *(Function &)> GetBFI;
   55   function_ref<TargetTransformInfo &(Function &)> GetTTI;
   56   std::function<OptimizationRemarkEmitter &(Function &)> *GetORE;
   57   function_ref<AssumptionCache *(Function &)> LookupAC;
include/llvm/Transforms/IPO/LowerTypeTests.h
  196 bool isJumpTableCanonical(Function *F);
include/llvm/Transforms/IPO/WholeProgramDevirt.h
  120   VirtualCallTarget(Function *Fn, const TypeMemberInfo *TM);
  127   Function *Fn;
include/llvm/Transforms/InstCombine/InstCombine.h
   35   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   55   bool runOnFunction(Function &F) override;
include/llvm/Transforms/Instrumentation.h
   48 Comdat *GetOrCreateFunctionComdat(Function &F, Triple &T,
  122 Instruction *promoteIndirectCall(Instruction *Inst, Function *F, uint64_t Count,
include/llvm/Transforms/Instrumentation/AddressSanitizer.h
   65   bool invalidate(Function &, const PreservedAnalyses &,
  104   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Instrumentation/BoundsChecking.h
   19   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Instrumentation/CGProfile.h
   26       MapVector<std::pair<Function *, Function *>, uint64_t> &Counts) const;
   26       MapVector<std::pair<Function *, Function *>, uint64_t> &Counts) const;
include/llvm/Transforms/Instrumentation/ControlHeightReduction.h
   26   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
include/llvm/Transforms/Instrumentation/InstrProfiling.h
   43            std::function<const TargetLibraryInfo &(Function &F)> GetTLI);
   49   std::function<const TargetLibraryInfo &(Function &F)> GetTLI;
   80   bool lowerIntrinsics(Function *F);
   83   void promoteCounterLoadStores(Function *F);
include/llvm/Transforms/Instrumentation/MemorySanitizer.h
   42   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
include/llvm/Transforms/Instrumentation/PGOInstrumentation.h
   90   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Instrumentation/PoisonChecking.h
   19   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Instrumentation/ThreadSanitizer.h
   29   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
include/llvm/Transforms/Scalar.h
  260     std::function<bool(const Function &)> Ftor = nullptr);
include/llvm/Transforms/Scalar/ADCE.h
   32   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
include/llvm/Transforms/Scalar/AlignmentFromAssumptions.h
   29   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   32   bool runImpl(Function &F, AssumptionCache &AC, ScalarEvolution *SE_,
include/llvm/Transforms/Scalar/BDCE.h
   26   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/CallSiteSplitting.h
   19   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/ConstantHoisting.h
  126   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  129   bool runImpl(Function &F, TargetTransformInfo &TTI, DominatorTree &DT,
  185   void collectConstantCandidates(Function &Fn);
  201   bool optimizeConstants(Function &Fn);
include/llvm/Transforms/Scalar/CorrelatedValuePropagation.h
   20   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/DCE.h
   24   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/DeadStoreElimination.h
   30   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
include/llvm/Transforms/Scalar/DivRemPairs.h
   25   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
include/llvm/Transforms/Scalar/EarlyCSE.h
   34   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/Float2Int.h
   27   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   30   bool runImpl(Function &F, const DominatorTree &DT);
   33   void findRoots(Function &F, const DominatorTree &DT,
include/llvm/Transforms/Scalar/GVN.h
   73   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  197   bool runImpl(Function &F, AssumptionCache &RunAC, DominatorTree &RunDT,
  275   bool iterateOnFunction(Function &F);
  276   bool performPRE(Function &F);
  292   void assignBlockRPONumber(Function &F);
  303   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  310   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/GuardWidening.h
   28   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/InstSimplifyPass.h
   36   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/JumpThreading.h
   98   bool runImpl(Function &F, TargetLibraryInfo *TLI_, LazyValueInfo *LVI_,
  103   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  110   void FindLoopHeaders(Function &F);
include/llvm/Transforms/Scalar/LoopDataPrefetch.h
   27   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/LoopDistribute.h
   27   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/LoopFuse.h
   25   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/LoopLoadElimination.h
   28   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/LoopPassManager.h
  275   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM) {
  285     if (PI.runBeforePass<Function>(LoopCanonicalizationFPM, F)) {
  287       PI.runAfterPass<Function>(LoopCanonicalizationFPM, F);
include/llvm/Transforms/Scalar/LoopSink.h
   35   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
include/llvm/Transforms/Scalar/LoopUnrollPass.h
  141   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/LowerAtomic.h
   24   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
include/llvm/Transforms/Scalar/LowerConstantIntrinsics.h
   36   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
include/llvm/Transforms/Scalar/LowerExpectIntrinsic.h
   31   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
include/llvm/Transforms/Scalar/LowerGuardIntrinsic.h
   22   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/LowerWidenableCondition.h
   21   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/MakeGuardsExplicit.h
   41   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/MemCpyOptimizer.h
   49   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   52   bool runImpl(Function &F, MemoryDependenceResults *MD_,
   73   bool iterateOnFunction(Function &F);
include/llvm/Transforms/Scalar/MergeICmps.h
   20   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/MergedLoadStoreMotion.h
   50   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/NaryReassociate.h
  104   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  107   bool runImpl(Function &F, AssumptionCache *AC_, DominatorTree *DT_,
  114   bool doOneIteration(Function &F);
include/llvm/Transforms/Scalar/NewGVN.h
   26   PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
   26   PreservedAnalyses run(Function &F, AnalysisManager<Function> &AM);
include/llvm/Transforms/Scalar/PartiallyInlineLibCalls.h
   25   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/Reassociate.h
   97   PreservedAnalyses run(Function &F, FunctionAnalysisManager &);
  100   void BuildRankMap(Function &F, ReversePostOrderTraversal<Function *> &RPOT);
  100   void BuildRankMap(Function &F, ReversePostOrderTraversal<Function *> &RPOT);
  128   void BuildPairMap(ReversePostOrderTraversal<Function *> &RPOT);
include/llvm/Transforms/Scalar/RewriteStatepointsForGC.h
   32   bool runOnFunction(Function &F, DominatorTree &, TargetTransformInfo &,
include/llvm/Transforms/Scalar/SCCP.h
   38   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   49                std::function<const TargetLibraryInfo &(Function &)> GetTLI,
   50                function_ref<AnalysisResultsForFn(Function &)> getAnalysis);
include/llvm/Transforms/Scalar/SROA.h
  115   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  122   PreservedAnalyses runImpl(Function &F, DominatorTree &RunDT,
  132   bool promoteAllocas(Function &F);
include/llvm/Transforms/Scalar/Scalarizer.h
   26   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/SimplifyCFG.h
   49   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/Sink.h
   25   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/SpeculateAroundPHIs.h
  105   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/SpeculativeExecution.h
   74   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   77   bool runImpl(Function &F, TargetTransformInfo *TTI);
include/llvm/Transforms/Scalar/TailRecursionElimination.h
   61   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Scalar/WarnMissedTransforms.h
   29   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Utils/AddDiscriminators.h
   26   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Utils/BasicBlockUtils.h
   68 bool EliminateUnreachableBlocks(Function &F, DomTreeUpdater *DTU = nullptr,
  216 unsigned SplitAllCriticalEdges(Function &F,
  357 bool SplitIndirectBrCriticalEdges(Function &F,
include/llvm/Transforms/Utils/BreakCriticalEdges.h
   25   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Utils/BuildLibCalls.h
   30   bool inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI);
include/llvm/Transforms/Utils/CallPromotionUtils.h
   28 bool isLegalToPromote(CallSite CS, Function *Callee,
   38 Instruction *promoteCall(CallSite CS, Function *Callee,
   48 Instruction *promoteCallWithIfThenElse(CallSite CS, Function *Callee,
include/llvm/Transforms/Utils/Cloning.h
  110                             const Twine &NameSuffix = "", Function *F = nullptr,
  126 Function *CloneFunction(Function *F, ValueToValueMapTy &VMap,
  126 Function *CloneFunction(Function *F, ValueToValueMapTy &VMap,
  138 void CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
  138 void CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
  146 void CloneAndPruneIntoFromInst(Function *NewFunc, const Function *OldFunc,
  146 void CloneAndPruneIntoFromInst(Function *NewFunc, const Function *OldFunc,
  164 void CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
  164 void CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
  176                               std::function<AssumptionCache &(Function &)>
  187   std::function<AssumptionCache &(Function &)> *GetAssumptionCache;
  238                             Function *ForwardVarArgsTo = nullptr);
  272     Function *Callee, int64_t entryDelta,
include/llvm/Transforms/Utils/CodeExtractor.h
   60   CodeExtractorAnalysisCache(Function &F);
  140     Function *extractCodeRegion(const CodeExtractorAnalysisCache &CEAC);
  145     static bool verifyAssumptionCache(const Function& F, AssumptionCache *AC);
  213     Function *constructFunction(const ValueSet &inputs,
  217                                 Function *oldFunction, Module *M);
  219     void moveCodeToFunction(Function *newFunction);
  226     CallInst *emitCallAndSwitchStatement(Function *newFunction,
include/llvm/Transforms/Utils/CtorUtils.h
   27                              function_ref<bool(Function *)> ShouldRemove);
include/llvm/Transforms/Utils/EntryExitInstrumenter.h
   28   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Utils/EscapeEnumerator.h
   28   Function &F;
   31   Function::iterator StateBB, StateE;
   37   EscapeEnumerator(Function &F, const char *N = "cleanup",
include/llvm/Transforms/Utils/Evaluator.h
   57   bool EvaluateFunction(Function *F, Constant *&RetVal,
   77   Function *getCalleeWithFormalArgs(CallSite &CS,
   82   bool getFormalParams(CallSite &CS, Function *F,
  106   SmallVector<Function*, 4> CallStack;
include/llvm/Transforms/Utils/FunctionComparator.h
   95   FunctionComparator(const Function *F1, const Function *F2,
   95   FunctionComparator(const Function *F1, const Function *F2,
  105   static FunctionHash functionHash(Function &);
  328   const Function *FnL, *FnR;
include/llvm/Transforms/Utils/GlobalStatus.h
   64   const Function *AccessingFunction = nullptr;
include/llvm/Transforms/Utils/GuardUtils.h
   25 void makeGuardControlFlowExplicit(Function *DeoptIntrinsic, CallInst *Guard);
include/llvm/Transforms/Utils/ImportedFunctionsInliningStatistics.h
   71   void recordInline(const Function &Caller, const Function &Callee);
   71   void recordInline(const Function &Caller, const Function &Callee);
   79   InlineGraphNode &createInlineGraphNode(const Function &);
include/llvm/Transforms/Utils/LCSSA.h
   39   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Utils/LibCallsShrinkWrap.h
   22   PreservedAnalyses run(Function &F, FunctionAnalysisManager &FAM);
include/llvm/Transforms/Utils/Local.h
  304 bool LowerDbgDeclare(Function &F);
  415 bool removeUnreachableBlocks(Function &F, DomTreeUpdater *DTU = nullptr,
include/llvm/Transforms/Utils/LoopSimplify.h
   53   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Utils/LowerInvoke.h
   24   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Utils/Mem2Reg.h
   25   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Utils/ModuleUtils.h
   36 void appendToGlobalCtors(Module &M, Function *F, int Priority,
   40 void appendToGlobalDtors(Module &M, Function *F, int Priority,
   50 std::pair<Function *, FunctionCallee> createSanitizerCtorAndInitFunctions(
   62 std::pair<Function *, FunctionCallee> getOrCreateSanitizerCtorAndInitFunctions(
   65     function_ref<void(Function *, FunctionCallee)> FunctionsCreatedCallback,
   71 Function *getOrCreateInitFunction(Module &M, StringRef Name);
   97     Module &M, SmallVectorImpl<Function *> &DeadComdatFunctions);
include/llvm/Transforms/Utils/PredicateInfo.h
  213   PredicateInfo(Function &, DominatorTree &, AssumptionCache &);
  246   Function &F;
  266   SmallSet<AssertingVH<Function>, 20> CreatedDeclarations;
  277   bool runOnFunction(Function &) override;
  288   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  293   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Utils/SimplifyLibCalls.h
  230   void classifyArgUse(Value *Val, Function *F, bool IsFloat,
include/llvm/Transforms/Utils/SizeOpts.h
   36 bool shouldFuncOptimizeForSizeImpl(const FuncT *F, ProfileSummaryInfo *PSI,
   75 bool shouldOptimizeForSize(const Function *F, ProfileSummaryInfo *PSI,
include/llvm/Transforms/Utils/UnifyFunctionExitNodes.h
   46   bool runOnFunction(Function &F) override;
include/llvm/Transforms/Utils/ValueMapper.h
  175   void remapFunction(Function &F);
  186   void scheduleRemapFunction(Function &F, unsigned MappingContextID = 0);
  264 inline void RemapFunction(Function &F, ValueToValueMapTy &VM,
include/llvm/Transforms/Vectorize/LoadStoreVectorizer.h
   18   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
include/llvm/Transforms/Vectorize/LoopVectorizationLegality.h
   95   bool allowVectorization(Function *F, Loop *L,
  174   bool doesNotMeet(Function *F, Loop *L, const LoopVectorizeHints &Hints);
  202       Function *F, std::function<const LoopAccessInfo &(Loop &)> *GetLAA,
include/llvm/Transforms/Vectorize/LoopVectorize.h
  145   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
  148   bool runImpl(Function &F, ScalarEvolution &SE_, LoopInfo &LI_,
include/llvm/Transforms/Vectorize/SLPVectorizer.h
   76   PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
   79   bool runImpl(Function &F, ScalarEvolution *SE_, TargetTransformInfo *TTI_,
lib/Analysis/AliasAnalysis.cpp
   80 bool AAResults::invalidate(Function &F, const PreservedAnalyses &PA,
  396 FunctionModRefBehavior AAResults::getModRefBehavior(const Function *F) {
  779 bool AAResultsWrapperPass::runOnFunction(Function &F) {
  841 AAResults llvm::createLegacyPMAAResults(Pass &P, Function &F,
lib/Analysis/AliasAnalysisEvaluator.cpp
   88 PreservedAnalyses AAEvaluator::run(Function &F, FunctionAnalysisManager &AM) {
   93 void AAEvaluator::runInternal(Function &F, AAResults &AA) {
  118       if (!isa<Function>(Callee) && isInterestingPointer(Callee))
  414   bool runOnFunction(Function &F) override {
lib/Analysis/AliasSetTracker.cpp
  756     bool runOnFunction(Function &F) override {
lib/Analysis/Analysis.cpp
  121       *unwrap<Function>(Fn), Action != LLVMReturnStatusAction ? &errs()
  131   Function *F = unwrap<Function>(Fn);
  131   Function *F = unwrap<Function>(Fn);
  136   Function *F = unwrap<Function>(Fn);
  136   Function *F = unwrap<Function>(Fn);
lib/Analysis/AssumptionCache.cpp
  228 PreservedAnalyses AssumptionPrinterPass::run(Function &F,
  241   auto I = ACT->AssumptionCaches.find_as(cast<Function>(getValPtr()));
  247 AssumptionCache &AssumptionCacheTracker::getAssumptionCache(Function &F) {
  264 AssumptionCache *AssumptionCacheTracker::lookupAssumptionCache(Function &F) {
  285     for (const BasicBlock &B : cast<Function>(*I.first))
lib/Analysis/BasicAliasAnalysis.cpp
   97 bool BasicAAResult::invalidate(Function &Fn, const PreservedAnalyses &PA,
  738     if (const Function *F = Call->getCalledFunction())
  747 FunctionModRefBehavior BasicAAResult::getModRefBehavior(const Function *F) {
  817 static const Function *getParent(const Value *V) {
  832   const Function *F1 = getParent(O1);
  833   const Function *F2 = getParent(O2);
 2041 BasicAAResult BasicAA::run(Function &F, FunctionAnalysisManager &AM) {
 2071 bool BasicAAWrapperPass::runOnFunction(Function &F) {
 2095 BasicAAResult llvm::createLegacyPMBasicAAResult(Pass &P, Function &F) {
lib/Analysis/BlockFrequencyInfo.cpp
  101   using nodes_iterator = pointer_iterator<Function::const_iterator>;
  153 BlockFrequencyInfo::BlockFrequencyInfo(const Function &F,
  174 bool BlockFrequencyInfo::invalidate(Function &F, const PreservedAnalyses &PA,
  179   return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>() ||
  183 void BlockFrequencyInfo::calculate(const Function &F,
  259 const Function *BlockFrequencyInfo::getFunction() const {
  318 bool BlockFrequencyInfoWrapperPass::runOnFunction(Function &F) {
  327 BlockFrequencyInfo BlockFrequencyAnalysis::run(Function &F,
  336 BlockFrequencyPrinterPass::run(Function &F, FunctionAnalysisManager &AM) {
lib/Analysis/BlockFrequencyInfoImpl.cpp
  559 BlockFrequencyInfoImplBase::getBlockProfileCount(const Function &F,
  567 BlockFrequencyInfoImplBase::getProfileCountFromFreq(const Function &F,
lib/Analysis/BranchProbabilityInfo.cpp
  693       if (Function *CalledFn = Call->getCalledFunction())
  949 void BranchProbabilityInfo::calculate(const Function &F, const LoopInfo &LI,
  962   for (scc_iterator<const Function *> It = scc_begin(&F); !It.isAtEnd();
 1027 bool BranchProbabilityInfoWrapperPass::runOnFunction(Function &F) {
 1044 BranchProbabilityAnalysis::run(Function &F, FunctionAnalysisManager &AM) {
 1051 BranchProbabilityPrinterPass::run(Function &F, FunctionAnalysisManager &AM) {
lib/Analysis/CFG.cpp
   27 void llvm::FindFunctionBackedges(const Function &F,
lib/Analysis/CFGPrinter.cpp
   41     bool runOnFunction(Function &F) override {
   57 PreservedAnalyses CFGViewerPass::run(Function &F,
   71     bool runOnFunction(Function &F) override {
   88 PreservedAnalyses CFGOnlyViewerPass::run(Function &F,
   94 static void writeCFGToDotFile(Function &F, bool CFGOnly = false) {
  118     bool runOnFunction(Function &F) override {
  135 PreservedAnalyses CFGPrinterPass::run(Function &F,
  148     bool runOnFunction(Function &F) override {
  165 PreservedAnalyses CFGOnlyPrinterPass::run(Function &F,
lib/Analysis/CFLAndersAliasAnalysis.cpp
   92     std::function<const TargetLibraryInfo &(Function &F)> GetTLI)
  338   FunctionInfo(const Function &, const SmallVectorImpl<Value *> &,
  404     SmallVectorImpl<ExternalRelation> &ExtRelations, const Function &Fn,
  489     SmallVectorImpl<ExternalAttribute> &ExtAttributes, const Function &Fn,
  501     const Function &Fn, const SmallVectorImpl<Value *> &RetVals,
  782 CFLAndersAAResult::buildInfoFrom(const Function &Fn) {
  811 void CFLAndersAAResult::scan(const Function &Fn) {
  825 void CFLAndersAAResult::evict(const Function *Fn) { Cache.erase(Fn); }
  828 CFLAndersAAResult::ensureCached(const Function &Fn) {
  839 const AliasSummary *CFLAndersAAResult::getAliasSummary(const Function &Fn) {
  902 CFLAndersAAResult CFLAndersAA::run(Function &F, FunctionAnalysisManager &AM) {
lib/Analysis/CFLGraph.h
  192                                    SmallVectorImpl<Function *> &Output) {
  193       if (auto *Fn = Call.getCalledFunction()) {
  371     static bool isFunctionExternal(Function *Fn) {
  376                                     const SmallVectorImpl<Function *> &Fns) {
  383       for (auto *Fn : Fns) {
  392       for (auto *Fn : Fns) {
  435       SmallVector<Function *, 4> Targets;
  457         auto *Fn = Call.getCalledFunction();
  634   void buildGraphFrom(Function &Fn) {
  646   CFLGraphBuilder(CFLAA &Analysis, const TargetLibraryInfo &TLI, Function &Fn)
lib/Analysis/CFLSteensAliasAnalysis.cpp
   64     std::function<const TargetLibraryInfo &(Function &F)> GetTLI)
   76   FunctionInfo(Function &Fn, const SmallVectorImpl<Value *> &RetVals,
  116     Function &Fn, const SmallVectorImpl<Value *> &RetVals,
  184 CFLSteensAAResult::FunctionInfo CFLSteensAAResult::buildSetsFrom(Function *Fn) {
  226 void CFLSteensAAResult::scan(Function *Fn) {
  241 void CFLSteensAAResult::evict(Function *Fn) { Cache.erase(Fn); }
  246 CFLSteensAAResult::ensureCached(Function *Fn) {
  257 const AliasSummary *CFLSteensAAResult::getAliasSummary(Function &Fn) {
  273   Function *Fn = nullptr;
  274   Function *MaybeFnA = const_cast<Function *>(parentFunctionOfValue(ValA));
  275   Function *MaybeFnB = const_cast<Function *>(parentFunctionOfValue(ValB));
  334 CFLSteensAAResult CFLSteensAA::run(Function &F, FunctionAnalysisManager &AM) {
lib/Analysis/CGSCCPassManager.cpp
  265       PA.allAnalysesInSetPreserved<AllAnalysesOn<Function>>();
  270     Function &F = N.getFunction();
  331     Function &F = N.getFunction();
  437   Function &F = N.getFunction();
  452       if (Function *Callee = CS.getCalledFunction())
  495   for (auto *F : G.getLibFunctions())
  645             auto PA = PreservedAnalyses::allInSet<AllAnalysesOn<Function>>();
  666       auto PA = PreservedAnalyses::allInSet<AllAnalysesOn<Function>>();
lib/Analysis/CallGraph.cpp
   34   for (Function &F : M)
   59 void CallGraph::addToCallGraph(Function *F) {
   76         const Function *Callee = Call->getCalledFunction();
   99     if (Function *LF = LHS->getFunction())
  100       if (Function *RF = RHS->getFunction())
  120 Function *CallGraph::removeFunctionFromModule(CallGraphNode *CGN) {
  123   Function *F = CGN->getFunction(); // Get the function for the call graph node
  134 void CallGraph::spliceFunction(const Function *From, const Function *To) {
  134 void CallGraph::spliceFunction(const Function *From, const Function *To) {
  147 CallGraphNode *CallGraph::getOrInsertFunction(const Function *F) {
  162   if (Function *F = getFunction())
  171     if (Function *FI = I.second->getFunction())
lib/Analysis/CallGraphSCCPass.cpp
  172     if (Function *F = CGN->getFunction()) {
  218     Function *F = CGN->getFunction();
  274         Function *Callee = Call->getCalledFunction();
  291         Function *Callee = Call->getCalledFunction();
  324           if (Function *Callee = Call->getCalledFunction()) {
  348         if (Function *Callee = Call->getCalledFunction()) {
  651         if (Function *F = CGN->getFunction()) {
  692     Function *F = CGN->getFunction();
lib/Analysis/CallPrinter.cpp
   30     if (Function *Func = Node->getFunction())
lib/Analysis/CodeMetrics.cpp
   95     const Function *F, AssumptionCache *AC,
  128       if (const Function *F = Call->getCalledFunction()) {
lib/Analysis/ConstantFolding.cpp
 1047     if (auto *F = dyn_cast<Function>(Ops.back())) {
 1047     if (auto *F = dyn_cast<Function>(Ops.back())) {
 1400 bool llvm::canConstantFoldCallTo(const CallBase *Call, const Function *F) {
 1720       const Function *Caller =
 2468 Constant *llvm::ConstantFoldCall(const CallBase *Call, Function *F,
 2493   Function *F = Call->getCalledFunction();
lib/Analysis/CostModel.cpp
   62     bool runOnFunction(Function &F) override;
   66     Function *F;
   88 CostModelAnalysis::runOnFunction(Function &F) {
lib/Analysis/DDG.cpp
  135 DataDependenceGraph::DataDependenceGraph(Function &F, DependenceInfo &D)
  191   Function *F = L.getHeader()->getParent();
lib/Analysis/Delinearization.cpp
   41   Function *F;
   51   bool runOnFunction(Function &F) override;
   64 bool Delinearization::runOnFunction(Function &F) {
lib/Analysis/DemandedBits.cpp
  295 bool DemandedBitsWrapperPass::runOnFunction(Function &F) {
  477 DemandedBits DemandedBitsAnalysis::run(Function &F,
  484 PreservedAnalyses DemandedBitsPrinterPass::run(Function &F,
lib/Analysis/DependenceAnalysis.cpp
  125 DependenceAnalysis::run(Function &F, FunctionAnalysisManager &FAM) {
  148 bool DependenceAnalysisWrapperPass::runOnFunction(Function &F) {
  173   auto *F = DA->getFunction();
  205 DependenceAnalysisPrinterPass::run(Function &F, FunctionAnalysisManager &FAM) {
 3380 bool DependenceInfo::invalidate(Function &F, const PreservedAnalyses &PA,
 3384   if (!PAC.preserved() && !PAC.preservedSet<AllAnalysesOn<Function>>())
lib/Analysis/DivergenceAnalysis.cpp
   95     const Function &F, const Loop *RegionLoop, const DominatorTree &DT,
  432 GPUDivergenceAnalysis::GPUDivergenceAnalysis(Function &F,
lib/Analysis/DomPrinter.cpp
   42       return DOTGraphTraits<const Function*>
   45       return DOTGraphTraits<const Function*>
lib/Analysis/DomTreeUpdater.cpp
  121 void DomTreeUpdater::recalculate(Function &F) {
lib/Analysis/DominanceFrontier.cpp
   47 bool DominanceFrontierWrapperPass::runOnFunction(Function &) {
   69 bool DominanceFrontier::invalidate(Function &F, const PreservedAnalyses &PA,
   74   return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>() ||
   80 DominanceFrontier DominanceFrontierAnalysis::run(Function &F,
   91 DominanceFrontierPrinterPass::run(Function &F, FunctionAnalysisManager &AM) {
lib/Analysis/EHPersonalities.cpp
   22   const Function *F =
   23       Pers ? dyn_cast<Function>(Pers->stripPointerCasts()) : nullptr;
   69 bool llvm::canSimplifyInvokeNoUnwind(const Function *F) {
   77 DenseMap<BasicBlock *, ColorVector> llvm::colorEHFunclets(Function &F) {
lib/Analysis/GlobalsModRef.cpp
  211   if (auto *F = dyn_cast<Function>(V))
  211   if (auto *F = dyn_cast<Function>(V))
  243 FunctionModRefBehavior GlobalsAAResult::getModRefBehavior(const Function *F) {
  261     if (const Function *F = Call->getCalledFunction())
  275 GlobalsAAResult::getFunctionInfo(const Function *F) {
  287   SmallPtrSet<Function *, 32> TrackedFunctions;
  288   for (Function &F : M)
  299   SmallPtrSet<Function *, 16> Readers, Writers;
  309         for (Function *Reader : Readers) {
  318           for (Function *Writer : Writers) {
  344                                            SmallPtrSetImpl<Function *> *Readers,
  345                                            SmallPtrSetImpl<Function *> *Writers,
  476       if (Function *F = CGN->getFunction())
  493     Function *F = SCC[0]->getFunction();
  538         if (Function *Callee = CI->second->getFunction()) {
  585           } else if (Function *Callee = Call->getCalledFunction()) {
  931       if (const Function *F = Call->getCalledFunction())
  944     std::function<const TargetLibraryInfo &(Function &F)> GetTLI)
  964     Module &M, std::function<const TargetLibraryInfo &(Function &F)> GetTLI,
lib/Analysis/IVDescriptors.cpp
  617   Function &F = *Header->getParent();
lib/Analysis/InlineCost.cpp
  104   std::function<AssumptionCache &(Function &)> &GetAssumptionCache;
  107   Optional<function_ref<BlockFrequencyInfo &(Function &)>> &GetBFI;
  113   Function &F;
  210   bool simplifyCallSite(Function *F, CallBase &Call);
  230   void updateThreshold(CallBase &Call, Function &Callee);
  256   void visit(Function *);
  257   void visit(Function &);
  294                std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
  295                Optional<function_ref<BlockFrequencyInfo &(Function &)>> &GetBFI,
  297                Function &Callee, CallBase &Call, const InlineParams &Params)
  860 void CallAnalyzer::updateThreshold(CallBase &Call, Function &Callee) {
  867   Function *Caller = Call.getCaller();
 1203 bool CallAnalyzer::simplifyCallSite(Function *F, CallBase &Call) {
 1241   if (Function *F = Call.getCalledFunction()) {
 1309   Function *F = dyn_cast_or_null<Function>(SimplifiedValues.lookup(Callee));
 1309   Function *F = dyn_cast_or_null<Function>(SimplifiedValues.lookup(Callee));
 1775   Function *Caller = Call.getFunction();
 1788   for (Function::arg_iterator FAI = F.arg_begin(), FAE = F.arg_end();
 1963 static bool functionsHaveCompatibleAttributes(Function *Caller,
 1964                                               Function *Callee,
 2005     std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
 2006     Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
 2013     CallBase &Call, Function *Callee, const InlineParams &Params,
 2015     std::function<AssumptionCache &(Function &)> &GetAssumptionCache,
 2016     Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI,
 2048   Function *Caller = Call.getCaller();
 2091 InlineResult llvm::isInlineViable(Function &F) {
 2093   for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI) {
lib/Analysis/InstCount.cpp
   38     void visitFunction  (Function &F) { ++TotalFuncs; }
   56     bool runOnFunction(Function &F) override;
   75 bool InstCount::runOnFunction(Function &F) {
lib/Analysis/InstructionSimplify.cpp
 4929 static Value *simplifyUnaryIntrinsic(Function *F, Value *Op0,
 5002 static Value *simplifyBinaryIntrinsic(Function *F, Value *Op0, Value *Op1,
 5147   Function *F = cast<Function>(Call->getCalledFunction());
 5147   Function *F = cast<Function>(Call->getCalledFunction());
 5211   Function *F = dyn_cast<Function>(Callee);
 5211   Function *F = dyn_cast<Function>(Callee);
 5493 const SimplifyQuery getBestSimplifyQuery(Pass &P, Function &F) {
 5509 const SimplifyQuery getBestSimplifyQuery(AnalysisManager<T, TArgs...> &AM,
 5510                                          Function &F) {
lib/Analysis/IntervalPartition.cpp
   70 bool IntervalPartition::runOnFunction(Function &F) {
lib/Analysis/LazyBlockFrequencyInfo.cpp
   54 bool LazyBlockFrequencyInfoPass::runOnFunction(Function &F) {
lib/Analysis/LazyBranchProbabilityInfo.cpp
   56 bool LazyBranchProbabilityInfoPass::runOnFunction(Function &F) {
lib/Analysis/LazyCallGraph.cpp
   81   SmallPtrSet<Function *, 4> Callees;
  103         if (Function *Callee = CS.getCalledFunction())
  127   for (auto *F : G->LibFunctions)
  135 void LazyCallGraph::Node::replaceFunction(Function &NewF) {
  146 static bool isKnownLibFunction(Function &F, TargetLibraryInfo &TLI) {
  154     Module &M, function_ref<TargetLibraryInfo &(Function &)> GetTLI) {
  157   for (Function &F : M) {
  181     if (Function* F = dyn_cast<Function>(A.getAliasee())) {
  181     if (Function* F = dyn_cast<Function>(A.getAliasee())) {
 1445 void LazyCallGraph::RefSCC::replaceNodeFunction(Node &N, Function &NewF) {
 1446   Function &OldF = N.getFunction();
 1492 void LazyCallGraph::removeDeadFunction(Function &F) {
 1556 LazyCallGraph::Node &LazyCallGraph::insertInto(Function &F, Node *&MappedN) {
 1777   for (Function &F : M)
 1810   for (Function &F : M)
lib/Analysis/LazyValueInfo.cpp
  470     void printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS) {
  839   auto *GuardDecl = BBI->getModule()->getFunction(
 1623 bool LazyValueInfoWrapperPass::runOnFunction(Function &F) {
 1657 bool LazyValueInfo::invalidate(Function &F, const PreservedAnalyses &PA,
 1662   if (!(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>()) ||
 1671 LazyValueInfo LazyValueAnalysis::run(Function &F,
 1966 void LazyValueInfo::printLVI(Function &F, DominatorTree &DTree, raw_ostream &OS) {
 2052   bool runOnFunction(Function &F) override {
lib/Analysis/LegacyDivergenceAnalysis.cpp
   95   DivergencePropagator(Function &F, TargetTransformInfo &TTI, DominatorTree &DT,
  116   Function &F;
  305     const Function &F) const {
  311   using RPOTraversal = ReversePostOrderTraversal<const Function *>;
  317 bool LegacyDivergenceAnalysis::runOnFunction(Function &F) {
  372   const Function *F = nullptr;
lib/Analysis/Lint.cpp
   93     void visitFunction(Function &F);
  143     bool runOnFunction(Function &F) override;
  202 bool Lint::runOnFunction(Function &F) {
  215 void Lint::visitFunction(Function &F) {
  231   if (Function *F = dyn_cast<Function>(findValue(Callee,
  231   if (Function *F = dyn_cast<Function>(findValue(Callee,
  253     Function::arg_iterator PI = F->arg_begin(), PE = F->arg_end();
  402   Function *F = I.getParent()->getParent();
  739 void llvm::lintFunction(const Function &f) {
  740   Function &F = const_cast<Function&>(f);
lib/Analysis/LoopAccessAnalysis.cpp
 2420 bool LoopAccessLegacyAnalysis::runOnFunction(Function &F) {
lib/Analysis/LoopAnalysisManager.cpp
   30     Function &F, const PreservedAnalyses &PA,
   51   if (!(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>()) ||
  132 LoopAnalysisManagerFunctionProxy::run(Function &F,
lib/Analysis/LoopCacheAnalysis.cpp
  618   Function *F = L.getHeader()->getParent();
lib/Analysis/LoopInfo.cpp
  848 bool LoopInfo::invalidate(Function &F, const PreservedAnalyses &PA,
  853   return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>() ||
  918 LoopInfo LoopAnalysis::run(Function &F, FunctionAnalysisManager &AM) {
  930 PreservedAnalyses LoopPrinterPass::run(Function &F,
 1061 bool LoopInfoWrapperPass::runOnFunction(Function &) {
 1088 PreservedAnalyses LoopVerifierPass::run(Function &F,
lib/Analysis/LoopPass.cpp
  161 bool LPPassManager::runOnFunction(Function &F) {
  394   const Function *F = L->getHeader()->getParent();
lib/Analysis/MemDepPrinter.cpp
   23     const Function *F;
   45     bool runOnFunction(Function &F) override;
   91 bool MemDepPrinter::runOnFunction(Function &F) {
lib/Analysis/MemDerefPrinter.cpp
   32     bool runOnFunction(Function &F) override;
   51 bool MemDerefPrinter::runOnFunction(Function &F) {
lib/Analysis/MemoryBuiltins.cpp
  111 static const Function *getCalledFunction(const Value *V, bool LookThroughBitCast,
  126   if (const Function *Callee = CS.getCalledFunction())
  135 getAllocationDataForFunction(const Function *Callee, AllocType AllocTy,
  176   if (const Function *Callee =
  185                   function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
  188   if (const Function *Callee =
  199   const Function *Callee =
  240     const Value *V, function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
  262     const Value *V, function_ref<const TargetLibraryInfo &(Function &)> GetTLI,
  299 bool llvm::isReallocLikeFn(const Function *F, const TargetLibraryInfo *TLI) {
  322     function_ref<const TargetLibraryInfo &(Function &)> GetTLI) {
  414 bool llvm::isLibFreeFunction(const Function *F, const LibFunc TLIFn) {
  464   const Function *Callee =
lib/Analysis/MemoryDependenceAnalysis.cpp
 1753 MemoryDependenceAnalysis::run(Function &F, FunctionAnalysisManager &AM) {
 1793 bool MemoryDependenceResults::invalidate(Function &F, const PreservedAnalyses &PA,
 1797   if (!PAC.preserved() && !PAC.preservedSet<AllAnalysesOn<Function>>())
 1816 bool MemoryDependenceWrapperPass::runOnFunction(Function &F) {
lib/Analysis/MemorySSA.cpp
 1224 MemorySSA::MemorySSA(Function &Func, AliasAnalysis *AA, DominatorTree *DT)
 1888 void MemorySSA::verifyPrevDefInPhis(Function &F) const {
 1924 void MemorySSA::verifyDominationNumbers(const Function &F) const {
 1962 void MemorySSA::verifyOrdering(Function &F) const {
 2027 void MemorySSA::verifyDomination(Function &F) const {
 2064 void MemorySSA::verifyDefUses(Function &F) const {
 2258 bool MemorySSAPrinterLegacyPass::runOnFunction(Function &F) {
 2268 MemorySSAAnalysis::Result MemorySSAAnalysis::run(Function &F,
 2276     Function &F, const PreservedAnalyses &PA,
 2279   return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>()) ||
 2284 PreservedAnalyses MemorySSAPrinterPass::run(Function &F,
 2292 PreservedAnalyses MemorySSAVerifierPass::run(Function &F,
 2313 bool MemorySSAWrapperPass::runOnFunction(Function &F) {
lib/Analysis/ModuleSummaryAnalysis.cpp
  183       Function *F = AssumeCI->getCalledFunction();
  242                                    const Function &F, BlockFrequencyInfo *BFI,
  324         CalledFunction = dyn_cast<Function>(CalledValue);
  330         CalledFunction = dyn_cast<Function>(GA->getBaseObject());
  377             Function *Callee = mdconst::extract_or_null<Function>(Op);
  377             Function *Callee = mdconst::extract_or_null<Function>(Op);
  491     auto Fn = dyn_cast<Function>(I->stripPointerCasts());
  640     std::function<BlockFrequencyInfo *(const Function &F)> GetBFICallback,
  697           if (Function *F = dyn_cast<Function>(GV)) {
  697           if (Function *F = dyn_cast<Function>(GV)) {
lib/Analysis/MustExecute.cpp
  104   Function *Fn = CurLoop->getHeader()->getParent();
  312     bool runOnFunction(Function &F) override;
  357   for (Function &F : M) {
  386   MustExecuteAnnotatedWriter(const Function &F,
  436 bool MustExecutePrinter::runOnFunction(Function &F) {
lib/Analysis/ObjCARCAliasAnalysis.cpp
   96 FunctionModRefBehavior ObjCARCAAResult::getModRefBehavior(const Function *F) {
  136 ObjCARCAAResult ObjCARCAA::run(Function &F, FunctionAnalysisManager &AM) {
lib/Analysis/ObjCARCInstKind.cpp
   86 ARCInstKind llvm::objcarc::GetFunctionClass(const Function *F) {
  225       if (const Function *F = CI->getCalledFunction()) {
lib/Analysis/OptimizationRemarkEmitter.cpp
   24 OptimizationRemarkEmitter::OptimizationRemarkEmitter(const Function *F)
   47     Function &F, const PreservedAnalyses &PA,
   92 bool OptimizationRemarkEmitterWrapperPass::runOnFunction(Function &Fn) {
  113 OptimizationRemarkEmitterAnalysis::run(Function &F,
lib/Analysis/PhiValues.cpp
   26 bool PhiValues::invalidate(Function &, const PreservedAnalyses &PA,
   30   return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>());
  177 PhiValues PhiValuesAnalysis::run(Function &F, FunctionAnalysisManager &) {
  181 PreservedAnalyses PhiValuesPrinterPass::run(Function &F,
  196 bool PhiValuesWrapperPass::runOnFunction(Function &F) {
lib/Analysis/PostDominators.cpp
   38 bool PostDominatorTree::invalidate(Function &F, const PreservedAnalyses &PA,
   43   return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>() ||
   47 bool PostDominatorTreeWrapperPass::runOnFunction(Function &F) {
   69 PostDominatorTree PostDominatorTreeAnalysis::run(Function &F,
   79 PostDominatorTreePrinterPass::run(Function &F, FunctionAnalysisManager &AM) {
lib/Analysis/ProfileSummaryInfo.cpp
  128 bool ProfileSummaryInfo::isFunctionEntryHot(const Function *F) {
  143 bool ProfileSummaryInfo::isFunctionHotInCallGraph(const Function *F,
  172 bool ProfileSummaryInfo::isFunctionColdInCallGraph(const Function *F,
  198     int PercentileCutoff, const Function *F, BlockFrequencyInfo &BFI) {
  224 bool ProfileSummaryInfo::isFunctionEntryCold(const Function *F) {
  381   for (auto &F : M) {
lib/Analysis/RegionInfo.cpp
   45   cl::location(RegionInfoBase<RegionTraits<Function>>::VerifyRegionInfo),
   80 bool RegionInfo::invalidate(Function &F, const PreservedAnalyses &PA,
   85   return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>() ||
   97 void RegionInfo::recalculate(Function &F, DominatorTree *DT_,
  125 bool RegionInfoPass::runOnFunction(Function &F) {
  189 RegionInfo RegionInfoAnalysis::run(Function &F, FunctionAnalysisManager &AM) {
  202 PreservedAnalyses RegionInfoPrinterPass::run(Function &F,
  210 PreservedAnalyses RegionInfoVerifierPass::run(Function &F,
lib/Analysis/RegionPass.cpp
   54 bool RGPassManager::runOnFunction(Function &F) {
  286   Function &F = *R.getEntry()->getParent();
lib/Analysis/RegionPrinter.cpp
   49         return DOTGraphTraits<const Function*>
   52         return DOTGraphTraits<const Function*>
  233   llvm::Function *F = RI->getTopLevelRegion()->getEntry()->getParent();
  240 static void invokeFunctionPass(const Function *F, FunctionPass *ViewerPass) {
  257 void llvm::viewRegion(const Function *F) {
  263 void llvm::viewRegionOnly(const Function *F) {
lib/Analysis/ScalarEvolution.cpp
 7718     if (const Function *F = CI->getCalledFunction())
11400 ScalarEvolution::ScalarEvolution(Function &F, TargetLibraryInfo &TLI,
11416   auto *GuardDecl = F.getParent()->getFunction(
11992     Function &F, const PreservedAnalyses &PA,
11997   return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>()) ||
12005 ScalarEvolution ScalarEvolutionAnalysis::run(Function &F,
12014 ScalarEvolutionPrinterPass::run(Function &F, FunctionAnalysisManager &AM) {
12034 bool ScalarEvolutionWrapperPass::runOnFunction(Function &F) {
lib/Analysis/ScalarEvolutionAliasAnalysis.cpp
  119 SCEVAAResult SCEVAA::run(Function &F, FunctionAnalysisManager &AM) {
  138 bool SCEVAAWrapperPass::runOnFunction(Function &F) {
lib/Analysis/ScalarEvolutionExpander.cpp
 2283   auto *MulF = Intrinsic::getDeclaration(Loc->getModule(),
lib/Analysis/ScopedNoAliasAA.cpp
  180 ScopedNoAliasAAResult ScopedNoAliasAA::run(Function &F,
lib/Analysis/StackSafetyAnalysis.cpp
  159   explicit FunctionInfo(const Function *F) : GV(F){};
  203   const Function &F;
  223   StackSafetyLocalAnalysis(const Function &F, ScalarEvolution &SE)
  424       Module &M, std::function<const StackSafetyInfo &(Function &)> FI);
  429     Module &M, std::function<const StackSafetyInfo &(Function &)> FI)
  434   for (auto &F : M.functions())
  438     if (isa<Function>(A.getBaseObject()))
  580 StackSafetyInfo StackSafetyAnalysis::run(Function &F,
  586 PreservedAnalyses StackSafetyPrinterPass::run(Function &F,
  608 bool StackSafetyInfoWrapperPass::runOnFunction(Function &F) {
lib/Analysis/SyncDependenceAnalysis.cpp
  127 using FunctionRPOT = ReversePostOrderTraversal<const Function *>;
lib/Analysis/TargetLibraryInfo.cpp
 1478 bool TargetLibraryInfoImpl::getLibFunc(const Function &FDecl,
 1590 TargetLibraryInfo TargetLibraryAnalysis::run(Function &F,
lib/Analysis/TargetTransformInfo.cpp
  162 int TargetTransformInfo::getCallCost(const Function *F,
  235 bool TargetTransformInfo::isLoweredToCall(const Function *F) const {
  375 bool TargetTransformInfo::useColdCCForColdCall(Function &F) const {
  698 int TargetTransformInfo::getCallInstrCost(Function *F, Type *RetTy,
  773 bool TargetTransformInfo::areInlineCompatible(const Function *Caller,
  774                                               const Function *Callee) const {
  779     const Function *Caller, const Function *Callee,
  779     const Function *Caller, const Function *Callee,
 1343     std::function<Result(const Function &)> TTICallback)
 1346 TargetIRAnalysis::Result TargetIRAnalysis::run(const Function &F,
 1353 TargetIRAnalysis::Result TargetIRAnalysis::getDefaultTTI(const Function &F) {
 1377 TargetTransformInfo &TargetTransformInfoWrapperPass::getTTI(const Function &F) {
lib/Analysis/Trace.cpp
   27 Function *Trace::getFunction() const {
   37   Function *F = getFunction();
lib/Analysis/TypeBasedAliasAnalysis.cpp
  419 FunctionModRefBehavior TypeBasedAAResult::getModRefBehavior(const Function *F) {
  712 TypeBasedAAResult TypeBasedAA::run(Function &F, FunctionAnalysisManager &AM) {
lib/Analysis/TypeMetadataUtils.cpp
   84       Function *F = AssumeCI->getCalledFunction();
lib/Analysis/ValueLatticeUtils.cpp
   19 bool llvm::canTrackArgumentsInterprocedurally(Function *F) {
   23 bool llvm::canTrackReturnsInterprocedurally(Function *F) {
lib/Analysis/ValueTracking.cpp
  503     if (Function *F = CI->getCalledFunction())
 1843   const Function *F = nullptr;
 2784   const Function *F = ICS.getCalledFunction();
 3885   const Function &F = *LI.getFunction();
 3947     const Function *Callee = CI->getCalledFunction();
lib/AsmParser/LLParser.cpp
  133     if (Function *Fn = dyn_cast<Function>(V)) {
  133     if (Function *Fn = dyn_cast<Function>(V)) {
  242     Function *F = &*FI++;
  494   Function *F;
  508   Function *F;
 1367     return Function::Create(FT, GlobalValue::ExternalWeakLinkage,
 2065 bool LLParser::ParseOptionalFunctionMetadata(Function &F) {
 2829 LLParser::PerFunctionState::PerFunctionState(LLParser &p, Function &f,
 3255     Function *F = nullptr;
 3258       if (!isa<Function>(GV))
 3260       F = cast<Function>(GV);
 5304 bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
 5468       Fn = cast<Function>(I->second.first);
 5479     Fn = Function::Create(FT, GlobalValue::ExternalLinkage, AddrSpace,
 5507   Function::arg_iterator ArgIt = Fn->arg_begin();
 5577 bool LLParser::ParseFunctionBody(Function &Fn) {
 7431   auto *F = dyn_cast<Function>(GV);
 7431   auto *F = dyn_cast<Function>(GV);
lib/AsmParser/LLParser.h
  415       Function &F;
  424       PerFunctionState(LLParser &p, Function &f, int functionNumber);
  427       Function &getFunction() const { return F; }
  527     bool ParseOptionalFunctionMetadata(Function &F);
  552     bool ParseFunctionHeader(Function *&Fn, bool isDefine);
  553     bool ParseFunctionBody(Function &Fn);
lib/Bitcode/Reader/BitcodeReader.cpp
  163   for (auto &F : *M) {
  497   DenseMap<Function *, FunctionType *> FunctionTypes;
  505   std::vector<std::pair<Function *, unsigned>> FunctionPrefixes;
  506   std::vector<std::pair<Function *, unsigned>> FunctionPrologues;
  507   std::vector<std::pair<Function *, unsigned>> FunctionPersonalityFns;
  522   std::vector<Function*> FunctionsWithBodies;
  526   using UpdatedIntrinsicMap = DenseMap<Function *, Function *>;
  526   using UpdatedIntrinsicMap = DenseMap<Function *, Function *>;
  538   DenseMap<Function*, uint64_t> DeferredFunctionInfo;
  548   DenseMap<Function *, std::vector<BasicBlock *>> BasicBlockFwdRefs;
  549   std::deque<Function *> BasicBlockFwdRefQueue;
  744   void setDeferredFunctionInfo(unsigned FuncBitcodeOffsetDelta, Function *F,
  754   Error parseFunctionBody(Function *F);
  759       Function *F,
  760       DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator);
  873     Function *F = BasicBlockFwdRefQueue.front();
 2053                                             Function *F,
 2100                               cast<Function>(ValueList[Record[0]]), Record);
 2198       if (auto *F = dyn_cast<Function>(V))
 2198       if (auto *F = dyn_cast<Function>(V))
 2233   std::vector<std::pair<Function *, unsigned>> FunctionPrefixWorklist;
 2234   std::vector<std::pair<Function *, unsigned>> FunctionPrologueWorklist;
 2235   std::vector<std::pair<Function *, unsigned>> FunctionPersonalityFnWorklist;
 2785       Function *Fn =
 2786         dyn_cast_or_null<Function>(ValueList.getConstantFwdRef(Record[1],FnTy));
 2798         Function::iterator BBI = Fn->begin(), BBE = Fn->end();
 2944   Function *Fn = FunctionsWithBodies.back();
 2968   for (Function &F : *TheModule) {
 2970     Function *NewFn;
 3219   Function *Func =
 3220       Function::Create(cast<FunctionType>(FTy), GlobalValue::ExternalLinkage,
 3694 Error BitcodeReader::parseFunctionBody(Function *F) {
 5193     Function *F,
 5194     DenseMap<Function *, uint64_t>::iterator DeferredFunctionInfoIterator) {
 5222   Function *F = dyn_cast<Function>(GV);
 5222   Function *F = dyn_cast<Function>(GV);
 5227   DenseMap<Function*, uint64_t>::iterator DFII = DeferredFunctionInfo.find(F);
 5296   for (Function &F : *TheModule) {
lib/Bitcode/Reader/MetadataLoader.cpp
  459   SmallDenseMap<Function *, DISubprogram *, 16> FunctionsWithSPs;
  529   void upgradeDeclareExpressions(Function &F) {
  664   DISubprogram *lookupSubprogramForFunction(Function *F) {
  671       Function &F, const SmallVectorImpl<Instruction *> &InstructionList);
  680   void upgradeDebugIntrinsics(Function &F) { upgradeDeclareExpressions(F); }
 1576         if (auto *F = dyn_cast<Function>(CMD->getValue())) {
 1576         if (auto *F = dyn_cast<Function>(CMD->getValue())) {
 1978     Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
 2151 DISubprogram *MetadataLoader::lookupSubprogramForFunction(Function *F) {
 2156     Function &F, const SmallVectorImpl<Instruction *> &InstructionList) {
 2173 void MetadataLoader::upgradeDebugIntrinsics(Function &F) {
lib/Bitcode/Reader/MetadataLoader.h
   68   DISubprogram *lookupSubprogramForFunction(Function *F);
   72       Function &F, const SmallVectorImpl<Instruction *> &InstructionList);
   81   void upgradeDebugIntrinsics(Function &F);
lib/Bitcode/Writer/BitcodeWriter.cpp
  214                                            const Function &F);
  364   void writeFunctionMetadata(const Function &F);
  365   void writeFunctionMetadataAttachment(const Function &F);
  385       DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex);
  387   void writeUseListBlock(const Function *F);
  389   writeFunction(const Function &F,
  390                 DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex);
 1182   for (const Function &F : M) {
 1308   for (const Function &F : M) {
 2121   for (const Function &F : M)
 2133 void ModuleBitcodeWriter::writeFunctionMetadata(const Function &F) {
 2155 void ModuleBitcodeWriter::writeFunctionMetadataAttachment(const Function &F) {
 3045   DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex) {
 3065   for (const Function &F : M) {
 3146 void ModuleBitcodeWriter::writeUseListBlock(const Function *F) {
 3167     const Function &F,
 3168     DenseMap<const Function *, uint64_t> &FunctionToBitcodeIndex) {
 3199   for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
 3640     const Function &F) {
 3834   for (const Function &F : M) {
 4265   DenseMap<const Function *, uint64_t> FunctionToBitcodeIndex;
 4584   for (const Function &F : M) {
lib/Bitcode/Writer/ValueEnumerator.cpp
  122   for (const Function &F : M) {
  137   for (const Function &F : M)
  147   for (const Function &F : M) {
  170 static void predictValueUseListOrderImpl(const Value *V, const Function *F,
  239 static void predictValueUseListOrder(const Value *V, const Function *F,
  274     const Function &F = *I;
  295   for (const Function &F : M)
  308   for (const Function &F : M) {
  331   for (const Function & F : M) {
  364   for (const Function &F : M)
  391   for (const Function &F : M) {
  566 unsigned ValueEnumerator::getMetadataFunctionID(const Function *F) const {
  570 void ValueEnumerator::EnumerateMetadata(const Function *F, const Metadata *MD) {
  575     const Function &F, const LocalAsMetadata *Local) {
  795 void ValueEnumerator::incorporateFunctionMetadata(const Function &F) {
  943 void ValueEnumerator::incorporateFunction(const Function &F) {
 1020 static void IncorporateFunctionInfoGlobalBBIDs(const Function *F,
lib/Bitcode/Writer/ValueEnumerator.h
  235   void incorporateFunction(const Function &F);
  256   void incorporateFunctionMetadata(const Function &F);
  267   unsigned getMetadataFunctionID(const Function *F) const;
  284   void EnumerateMetadata(const Function *F, const Metadata *MD);
  288   void EnumerateFunctionLocalMetadata(const Function &F,
lib/CodeGen/Analysis.cpp
  552   const Function *F = ExitBB->getParent();
  557 bool llvm::attributesPermitTailCall(const Function *F, const Instruction *I,
  614 bool llvm::returnTypeIsEligibleForTailCall(const Function *F,
  638   if (Function *F = Call->getCalledFunction()) {
lib/CodeGen/AsmPrinter/ARMException.cpp
   62   const Function &F = MF->getFunction();
   63   const Function *Per = nullptr;
   65     Per = dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
lib/CodeGen/AsmPrinter/AsmPrinter.cpp
  333     for (auto &F: M.getFunctionList()) {
  651   const Function &F = MF->getFunction();
 1165   const Function &F = MF->getFunction();
 1403   for (const Function &F : M) {
 1556   Function *InitTrampolineIntrinsic = M.getFunction("llvm.init.trampoline");
 1668     const Function &F = MF.getFunction();
 1797   const Function &F = MF->getFunction();
 3125   const Function &F = MF->getFunction();
 3181   const Function &F = MI.getMF()->getFunction();
lib/CodeGen/AsmPrinter/CodeViewDebug.cpp
  943 void CodeViewDebug::emitDebugInfoForThunk(const Function *GV,
  982 void CodeViewDebug::emitDebugInfoForFunction(const Function *GV,
 1332   const Function &GV = MF->getFunction();
 2831   const Function &GV = MF->getFunction();
lib/CodeGen/AsmPrinter/CodeViewDebug.h
  236   MapVector<const Function *, std::unique_ptr<FunctionInfo>> FnDebugInfo;
  305   void emitDebugInfoForThunk(const Function *GV,
  309   void emitDebugInfoForFunction(const Function *GV, FunctionInfo &FI);
lib/CodeGen/AsmPrinter/DwarfCFIException.cpp
   75   for (const Function *Personality : MMI->getPersonalities()) {
   89   const Function &F = MF->getFunction();
  101   const Function *Per = nullptr;
  103     Per = dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
  146   auto *P = dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
  146   auto *P = dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
lib/CodeGen/AsmPrinter/DwarfDebug.cpp
  728       const Function *CalleeDecl = nullptr;
  734         CalleeDecl = dyn_cast<Function>(CalleeOp.getGlobal());
lib/CodeGen/AsmPrinter/EHStreamer.cpp
  179     const Function *F = dyn_cast<Function>(MO.getGlobal());
  179     const Function *F = dyn_cast<Function>(MO.getGlobal());
lib/CodeGen/AsmPrinter/WinCFGuard.cpp
   46   std::vector<const Function *> Functions;
   47   for (const Function &F : *M)
   54   for (const Function *F : Functions)
lib/CodeGen/AsmPrinter/WinException.cpp
   54   for (const Function &F : *M)
   66   const Function &F = MF->getFunction();
   74   const Function *PerFn = nullptr;
   76     PerFn = dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
  124   const Function &F = MF->getFunction();
  179   const Function &F = MF->getFunction();
  192   const Function &F = Asm->MF->getFunction();
  221     const Function *PerFn = nullptr;
  225       PerFn = dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
  255     const Function &F = MF->getFunction();
  659   const Function &F = MF->getFunction();
  968   const Function &F = MF->getFunction();
  985   const auto *Per = cast<Function>(F.getPersonalityFn()->stripPointerCasts());
  985   const auto *Per = cast<Function>(F.getPersonalityFn()->stripPointerCasts());
lib/CodeGen/AtomicExpandPass.cpp
   68     bool runOnFunction(Function &F) override;
  197 bool AtomicExpand::runOnFunction(Function &F) {
  644   Function *F = BB->getParent();
  850   Function *F = BB->getParent();
 1008   Function *F = BB->getParent();
 1096   Function *F = BB->getParent();
 1351   Function *F = BB->getParent();
lib/CodeGen/BasicTargetTransformInfo.cpp
   32 BasicTTIImpl::BasicTTIImpl(const TargetMachine *TM, const Function &F)
lib/CodeGen/CFGuardLongjmp.cpp
   86         auto *F = dyn_cast<Function>(MO.getGlobal());
lib/CodeGen/CodeGenPrepare.cpp
  313     bool runOnFunction(Function &F) override;
  345     DominatorTree &getDT(Function &F) {
  351     bool eliminateFallThrough(Function &F);
  352     bool eliminateMostlyEmptyBlocks(Function &F);
  373     bool placeDbgValues(Function &F);
  380     bool mergeSExts(Function &F);
  387     bool splitBranchCondition(Function &F, bool &ModifiedDT);
  410 bool CodeGenPrepare::runOnFunction(Function &F) {
  475     for (Function::iterator I = F.begin(); I != F.end(); ) {
  562 bool CodeGenPrepare::eliminateFallThrough(Function &F) {
  630 bool CodeGenPrepare::eliminateMostlyEmptyBlocks(Function &F) {
 2013   const Function *F = BB->getParent();
 4390   const Function *F = CI->getFunction();
 5207 bool CodeGenPrepare::mergeSExts(Function &F) {
 7116 bool CodeGenPrepare::placeDbgValues(Function &F) {
 7184 bool CodeGenPrepare::splitBranchCondition(Function &F, bool &ModifiedDT) {
lib/CodeGen/DwarfEHPrepare.cpp
   53     bool InsertUnwindResumeCalls(Function &Fn);
   56     pruneUnreachableResumes(Function &Fn,
   65     bool runOnFunction(Function &Fn) override;
  142     Function &Fn, SmallVectorImpl<ResumeInst *> &Resumes,
  183 bool DwarfEHPrepare::InsertUnwindResumeCalls(Function &Fn) {
  258 bool DwarfEHPrepare::runOnFunction(Function &Fn) {
lib/CodeGen/ExpandMemCmp.cpp
  460     Function *Bswap = Intrinsic::getDeclaration(CI->getModule(),
  581     Function *Bswap = Intrinsic::getDeclaration(CI->getModule(),
  787   bool runOnFunction(Function &F) override {
  812   PreservedAnalyses runImpl(Function &F, const TargetLibraryInfo *TLI,
  842     Function &F, const TargetLibraryInfo *TLI, const TargetTransformInfo *TTI,
lib/CodeGen/ExpandReductions.cpp
   78 bool expandReductions(Function &F, const TargetTransformInfo *TTI) {
  144   bool runOnFunction(Function &F) override {
  167 PreservedAnalyses ExpandReductionsPass::run(Function &F,
lib/CodeGen/GCMetadata.cpp
   42   bool runOnFunction(Function &F) override;
   53 GCFunctionInfo::GCFunctionInfo(const Function &F, GCStrategy &S)
   66 GCFunctionInfo &GCModuleInfo::getFunctionInfo(const Function &F) {
  105 bool Printer::runOnFunction(Function &F) {
lib/CodeGen/GCRootLowering.cpp
   40   bool DoLowering(Function &F, GCStrategy &S);
   50   bool runOnFunction(Function &F) override;
  135     if (Function *F = CI->getCalledFunction())
  143 static bool InsertRootInitializers(Function &F, ArrayRef<AllocaInst *> Roots) {
  174 bool LowerIntrinsics::runOnFunction(Function &F) {
  192 bool LowerIntrinsics::DoLowering(Function &F, GCStrategy &S) {
  202       Function *F = CI->getCalledFunction();
lib/CodeGen/GlobalISel/CallLowering.cpp
   53   if (const Function *F = CS.getCalledFunction())
   76                                const FuncInfoTy &FuncInfo) const {
  171   const Function &F = MF.getFunction();
  183   const Function &F = MF.getFunction();
  403   const Function &F = MF.getFunction();
lib/CodeGen/GlobalISel/IRTranslator.cpp
 1587   const Function *F = CI.getCalledFunction();
 1678   const Function *Fn = dyn_cast<Function>(Callee);
 1678   const Function *Fn = dyn_cast<Function>(Callee);
 2215   const Function &F = MF->getFunction();
 2323     ReversePostOrderTraversal<const Function *> RPOT(&F);
lib/CodeGen/GlobalISel/LegalizerHelper.cpp
  333   const Function &F = MI.getParent()->getParent()->getFunction();
lib/CodeGen/GlobalISel/RegBankSelect.cpp
  658   const Function &F = MF.getFunction();
lib/CodeGen/GlobalMerge.cpp
  201     bool runOnFunction(Function &F) override;
  283   DenseMap<Function *, size_t /*UsedGlobalSetIdx*/> GlobalUsesByFunction;
  330         Function *ParentFn = I->getParent()->getParent();
  581   for (Function &F : M) {
  666 bool GlobalMerge::runOnFunction(Function &F) {
lib/CodeGen/HardwareLoops.cpp
   90     bool runOnFunction(Function &F) override;
  174 bool HardwareLoops::runOnFunction(Function &F) {
  375   Function *LoopIter = Intrinsic::getDeclaration(M, ID, Ty);
  395   Function *DecFunc =
  417   Function *DecFunc =
lib/CodeGen/IndirectBrExpandPass.cpp
   61   bool runOnFunction(Function &F) override;
   75 bool IndirectBrExpandPass::runOnFunction(Function &F) {
lib/CodeGen/InterleavedAccessPass.cpp
   92   bool runOnFunction(Function &F) override;
  444 bool InterleavedAccess::runOnFunction(Function &F) {
lib/CodeGen/InterleavedLoadCombinePass.cpp
   65   InterleavedLoadCombineImpl(Function &F, DominatorTree &DT, MemorySSA &MSSA,
   77   Function &F;
 1314   bool runOnFunction(Function &F) override {
lib/CodeGen/IntrinsicLowering.cpp
  238   const Function *Callee = CI->getCalledFunction();
  501   Function *Int = Intrinsic::getDeclaration(M, Intrinsic::bswap, Ty);
lib/CodeGen/LLVMTargetMachine.cpp
   92 LLVMTargetMachine::getTargetTransformInfo(const Function &F) {
lib/CodeGen/MIRParser/MIParser.cpp
  450   bool parseIRBlock(BasicBlock *&BB, const Function &F);
  509   const BasicBlock *getIRBlock(unsigned Slot, const Function &F);
 2148 bool MIParser::parseIRBlock(BasicBlock *&BB, const Function &F) {
 2184   auto *F = dyn_cast<Function>(GV);
 2184   auto *F = dyn_cast<Function>(GV);
 2222   Intrinsic::ID ID = Function::lookupIntrinsicID(Name);
 2960     const Function &F,
 2989 const BasicBlock *MIParser::getIRBlock(unsigned Slot, const Function &F) {
 3006 static void initSlots2Values(const Function &F,
lib/CodeGen/MIRParser/MIRParser.cpp
  260 static Function *createDummyFunction(StringRef Name, Module &M) {
  262   Function *F =
  263       Function::Create(FunctionType::get(Type::getVoidTy(Context), false),
  264                        Function::ExternalLinkage, Name, M);
  285   Function *F = M.getFunction(FunctionName);
  631   const Function &F = MF.getFunction();
lib/CodeGen/MachineBasicBlock.cpp
  283   const Function &F = MF->getFunction();
lib/CodeGen/MachineBlockFrequencyInfo.cpp
  233   const Function &F = MBFI->getFunction()->getFunction();
  239   const Function &F = MBFI->getFunction()->getFunction();
lib/CodeGen/MachineFunction.cpp
  128                                            const Function &F) {
  134 MachineFunction::MachineFunction(const Function &F,
  659     if (const auto *PF =
  660             dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts()))
  767                                          const Function *Filter,
  777                                            const Function *Cleanup) {
lib/CodeGen/MachineFunctionPass.cpp
   38 bool MachineFunctionPass::runOnFunction(Function &F) {
lib/CodeGen/MachineInstr.cpp
 1458   const Function *F = nullptr;
lib/CodeGen/MachineModuleInfo.cpp
   67     Function *Fn;   // The containing function of the BasicBlock.
   80   DenseMap<AssertingVH<Function>, std::vector<MCSymbol*>>
   93   void takeDeletedSymbolsForFunction(Function *F,
  125 takeDeletedSymbolsForFunction(Function *F, std::vector<MCSymbol*> &Result) {
  126   DenseMap<AssertingVH<Function>, std::vector<MCSymbol*>>::iterator I =
  244 takeDeletedSymbolsForFunction(const Function *F,
  255 void MachineModuleInfo::addPersonality(const Function *Personality) {
  265 MachineModuleInfo::getMachineFunction(const Function &F) const {
  271 MachineModuleInfo::getOrCreateMachineFunction(const Function &F) {
  295 void MachineModuleInfo::deleteMachineFunctionFor(Function &F) {
  315   bool runOnFunction(Function &F) override {
lib/CodeGen/MachineOperand.cpp
  446   if (const Function *F = BB.getParent()) {
lib/CodeGen/MachineOutliner.cpp
 1100   Function *F = Function::Create(FunctionType::get(Type::getVoidTy(C), false),
 1100   Function *F = Function::Create(FunctionType::get(Type::getVoidTy(C), false),
 1101                                  Function::ExternalLinkage, FunctionName, M);
 1121   const Function &ParentFn = FirstCand.getMF()->getFunction();
 1295   for (Function &F : M) {
 1356   for (const Function &F : M) {
 1373   for (const Function &F : M) {
lib/CodeGen/MachineRegisterInfo.cpp
  557 static const Function *getCalledFunction(const MachineInstr &MI) {
  561     const Function *Func = dyn_cast<Function>(MO.getGlobal());
  561     const Function *Func = dyn_cast<Function>(MO.getGlobal());
  581   const Function *Called = getCalledFunction(MI);
lib/CodeGen/MachineVerifier.cpp
  663   const Function &F = MF->getFunction();
lib/CodeGen/PreISelIntrinsicLowering.cpp
   28 static bool lowerLoadRelative(Function &F) {
   59 static bool lowerObjCCall(Function &F, const char *NewFn,
   69   if (Function *Fn = dyn_cast<Function>(FCache.getCallee())) {
   69   if (Function *Fn = dyn_cast<Function>(FCache.getCallee())) {
   98   for (Function &F : M) {
lib/CodeGen/PrologEpilogInserter.cpp
  216   const Function &F = MF.getFunction();
  598   const Function &F = MF.getFunction();
lib/CodeGen/RegAllocPBQP.cpp
  818   const Function &F = MF.getFunction();
lib/CodeGen/RegUsageInfoCollector.cpp
  131   const Function &F = MF.getFunction();
lib/CodeGen/RegUsageInfoPropagate.cpp
   88 static const Function *findCalledFunction(const Module &M,
   92       return dyn_cast<const Function>(MO.getGlobal());
  132       if (const Function *F = findCalledFunction(M, MI)) {
lib/CodeGen/RegisterUsageInfo.cpp
   60     const Function &FP, ArrayRef<uint32_t> RegMask) {
   65 PhysicalRegisterUsageInfo::getRegUsageInfo(const Function &FP) {
   73   using FuncPtrRegMaskPair = std::pair<const Function *, std::vector<uint32_t>>;
lib/CodeGen/ResetMachineFunctionPass.cpp
   69           const Function &F = MF.getFunction();
lib/CodeGen/SafeStack.cpp
  125   Function &F;
  146   Value *getStackGuard(IRBuilder<> &IRB, Function &F);
  149   void checkStackGuard(IRBuilder<> &IRB, Function &F, ReturnInst &RI,
  155   void findInsts(Function &F, SmallVectorImpl<AllocaInst *> &StaticAllocas,
  171   Value *moveStaticAllocasToUnsafeStack(IRBuilder<> &IRB, Function &F,
  184   createStackRestorePoints(IRBuilder<> &IRB, Function &F,
  191   void moveDynamicAllocasToUnsafeStack(Function &F, Value *UnsafeStackPtr,
  206   SafeStack(Function &F, const TargetLoweringBase &TL, const DataLayout &DL,
  369 Value *SafeStack::getStackGuard(IRBuilder<> &IRB, Function &F) {
  377 void SafeStack::findInsts(Function &F,
  427 SafeStack::createStackRestorePoints(IRBuilder<> &IRB, Function &F,
  463 void SafeStack::checkStackGuard(IRBuilder<> &IRB, Function &F, ReturnInst &RI,
  487     IRBuilder<> &IRB, Function &F, ArrayRef<AllocaInst *> StaticAllocas,
  639     Function &F, Value *UnsafeStackPtr, AllocaInst *DynamicTop,
  709   Function *Callee = CS.getCalledFunction();
  726   Function *Callee = CS.getCalledFunction();
  853   bool runOnFunction(Function &F) override {
lib/CodeGen/SafeStackColoring.h
   72   Function &F;
  118   StackColoring(Function &F, ArrayRef<AllocaInst *> Allocas)
lib/CodeGen/ScalarizeMaskedMemIntrin.cpp
   53   bool runOnFunction(Function &F) override;
  809 bool ScalarizeMaskedMemIntrin::runOnFunction(Function &F) {
  817     for (Function::iterator I = F.begin(); I != F.end();) {
lib/CodeGen/SelectionDAG/DAGCombiner.cpp
12793   const Function &F = DAG.getMachineFunction().getFunction();
20441         const Function &F = DAG.getMachineFunction().getFunction();
lib/CodeGen/SelectionDAG/FastISel.cpp
  156   for (Function::const_arg_iterator I = FuncInfo.Fn->arg_begin(),
 1616     const Function *F = Call->getCalledFunction();
lib/CodeGen/SelectionDAG/FunctionLoweringInfo.cpp
   81 void FunctionLoweringInfo::set(const Function &fn, MachineFunction &mf,
lib/CodeGen/SelectionDAG/LegalizeDAG.cpp
 2050   const Function &F = DAG.getMachineFunction().getFunction();
lib/CodeGen/SelectionDAG/SelectionDAG.cpp
 8641                                                      Function **OutFunction) {
 8646   auto *Function = Module->getFunction(Symbol);
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
 1785     const Function *F = I.getParent()->getParent();
 1829       const Function *F = I.getParent()->getParent();
 1897   const Function *F = I.getParent()->getParent();
 2529   if (const Function *GuardCheckFn = TLI.getSSPStackGuardCheck(M)) {
 2755   const Function *Fn = dyn_cast<Function>(Callee);
 2755   const Function *Fn = dyn_cast<Function>(Callee);
 4765   const Function *F = I.getCalledFunction();
 5351     const Function &F = DAG.getMachineFunction().getFunction();
 6445     const Function *F = cast<Function>(I.getArgOperand(1)->stripPointerCasts());
 6445     const Function *F = cast<Function>(I.getArgOperand(1)->stripPointerCasts());
 6671     auto *Fn = cast<Function>(I.getArgOperand(0)->stripPointerCasts());
 6671     auto *Fn = cast<Function>(I.getArgOperand(0)->stripPointerCasts());
 7541   if (Function *F = I.getCalledFunction()) {
 9580 void SelectionDAGISel::LowerArguments(const Function &F) {
lib/CodeGen/SelectionDAG/SelectionDAGISel.cpp
  354 static void SplitCriticalSideEffectEdges(Function &Fn, DominatorTree *DT,
  387 static void computeUsesMSVCFloatingPoint(const Triple &TT, const Function &F,
  420   const Function &Fn = mf.getFunction();
 1336 void SelectionDAGISel::SelectAllBasicBlocks(const Function &Fn) {
 1345   ReversePostOrderTraversal<const Function*> RPOT(&Fn);
lib/CodeGen/SelectionDAG/TargetLowering.cpp
   53   const Function &F = DAG.getMachineFunction().getFunction();
 4543     if (isa<BasicBlock>(v) || isa<ConstantInt>(v) || isa<Function>(v)) {
lib/CodeGen/ShadowStackGCLowering.cpp
   69   bool runOnFunction(Function &F) override;
   73   Constant *GetFrameMap(Function &F);
   74   Type *GetConcreteStackEntryType(Function &F);
   75   void CollectRoots(Function &F);
  101 Constant *ShadowStackGCLowering::GetFrameMap(Function &F) {
  155 Type *ShadowStackGCLowering::GetConcreteStackEntryType(Function &F) {
  169   for (Function &F : M) {
  227 void ShadowStackGCLowering::CollectRoots(Function &F) {
  236   for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
  239         if (Function *F = CI->getCalledFunction())
  283 bool ShadowStackGCLowering::runOnFunction(Function &F) {
lib/CodeGen/SjLjEHPrepare.cpp
   44   Function *BuiltinSetupDispatchFn;
   45   Function *FrameAddrFn;
   46   Function *StackAddrFn;
   47   Function *StackRestoreFn;
   48   Function *LSDAAddrFn;
   49   Function *CallSiteFn;
   50   Function *FuncCtxFn;
   57   bool runOnFunction(Function &F) override;
   65   bool setupEntryBlockAndCallSites(Function &F);
   67   Value *setupFunctionContext(Function &F, ArrayRef<LandingPadInst *> LPads);
   68   void lowerIncomingArguments(Function &F);
   69   void lowerAcrossUnwindEdges(Function &F, ArrayRef<InvokeInst *> Invokes);
  170 Value *SjLjEHPrepare::setupFunctionContext(Function &F,
  228 void SjLjEHPrepare::lowerIncomingArguments(Function &F) {
  259 void SjLjEHPrepare::lowerAcrossUnwindEdges(Function &F,
  353 bool SjLjEHPrepare::setupEntryBlockAndCallSites(Function &F) {
  361       if (Function *Callee = II->getCalledFunction())
  472 bool SjLjEHPrepare::runOnFunction(Function &F) {
lib/CodeGen/StackProtector.cpp
   77 bool StackProtector::runOnFunction(Function &Fn) {
  223 static const CallInst *findStackProtectorIntrinsic(Function &F) {
  382 static bool CreatePrologue(Function *F, Module *M, ReturnInst *RI,
  411   for (Function::iterator I = F->begin(), E = F->end(); I != E;) {
  444     if (Function *GuardCheck = TLI->getSSPStackGuardCheck(*M)) {
lib/CodeGen/SwiftErrorValueTracking.cpp
   96   for (Function::const_arg_iterator AI = Fn->arg_begin(), AE = Fn->arg_end();
  306       const Function *F = R->getParent()->getParent();
lib/CodeGen/TargetFrameLoweringImpl.cpp
  137 bool TargetFrameLowering::isSafeForNoCSROpt(const Function &F) {
lib/CodeGen/TargetLoweringBase.cpp
 1793 Function *TargetLoweringBase::getSSPStackGuardCheck(const Module &M) const {
 1824   const Function &F = MF.getFunction();
lib/CodeGen/TargetLoweringObjectFileImpl.cpp
  333     const Function *F = cast<Function>(V->getValue());
  333     const Function *F = cast<Function>(V->getValue());
  577   const Function *F = dyn_cast<Function>(GO);
  577   const Function *F = dyn_cast<Function>(GO);
  661   if (const auto *F = dyn_cast<Function>(GO)) {
  661   if (const auto *F = dyn_cast<Function>(GO)) {
  713     const Function &F, const TargetMachine &TM) const {
  728     bool UsesLabelDifference, const Function &F) const {
 1410       ((isa<Function>(GV) && TM.getFunctionSections()) ||
 1418     const Function &F, const TargetMachine &TM) const {
 1708   if (isa<Function>(GO)) {
 1739   if (const auto *F = dyn_cast<Function>(GO)) {
 1739   if (const auto *F = dyn_cast<Function>(GO)) {
 1778     bool UsesLabelDifference, const Function &F) const {
 1862     bool UsesLabelDifference, const Function &F) const {
lib/CodeGen/TargetOptionsImpl.cpp
   29   const Function &F = MF.getFunction();
lib/CodeGen/TargetRegisterInfo.cpp
  450   const Function &F = MF.getFunction();
lib/CodeGen/UnreachableBlockElim.cpp
   45   bool runOnFunction(Function &F) override {
   69 PreservedAnalyses UnreachableBlockElimPass::run(Function &F,
lib/CodeGen/WasmEHPrepare.cpp
  107   Function *ThrowF = nullptr;       // wasm.throw() intrinsic
  108   Function *LPadIndexF = nullptr;   // wasm.landingpad.index() intrinsic
  109   Function *LSDAF = nullptr;        // wasm.lsda() intrinsic
  110   Function *GetExnF = nullptr;      // wasm.get.exception() intrinsic
  111   Function *ExtractExnF = nullptr;  // wasm.extract.exception() intrinsic
  112   Function *GetSelectorF = nullptr; // wasm.get.ehselector() intrinsic
  116   bool prepareEHPads(Function &F);
  117   bool prepareThrows(Function &F);
  128   bool runOnFunction(Function &F) override;
  165 bool WasmEHPrepare::runOnFunction(Function &F) {
  172 bool WasmEHPrepare::prepareThrows(Function &F) {
  201 bool WasmEHPrepare::prepareEHPads(Function &F) {
  251   if (Function *F = dyn_cast<Function>(CallPersonalityF.getCallee()))
  251   if (Function *F = dyn_cast<Function>(CallPersonalityF.getCallee()))
  350 void llvm::calculateWasmEHInfo(const Function *F, WasmEHFuncInfo &EHInfo) {
lib/CodeGen/WinEHPrepare.cpp
   63   bool runOnFunction(Function &Fn) override;
   78   AllocaInst *insertPHILoads(PHINode *PN, Function &F);
   80                           DenseMap<BasicBlock *, Value *> &Loads, Function &F);
   81   bool prepareExplicitEH(Function &F);
   82   void colorFunclets(Function &F);
   84   void demotePHIsOnFunclets(Function &F, bool DemoteCatchSwitchPHIOnly);
   85   void cloneCommonBlocks(Function &F);
   86   void removeImplausibleInstructions(Function &F);
   87   void cleanupPreparedFunclets(Function &F);
   88   void verifyPreparedFunclets(Function &F);
  110 bool WinEHPrepare::runOnFunction(Function &Fn) {
  172 static void calculateStateNumbersForInvokes(const Function *Fn,
  174   auto *F = const_cast<Function *>(Fn);
  316                         const Function *Filter, const BasicBlock *Handler) {
  356     const Function *Filter = dyn_cast<Function>(FilterOrNull);
  356     const Function *Filter = dyn_cast<Function>(FilterOrNull);
  427 void llvm::calculateSEHStateNumbers(const Function *Fn,
  445 void llvm::calculateWinCXXEHStateNumbers(const Function *Fn,
  476 void llvm::calculateClrEHStateNumbers(const Function *Fn,
  678 void WinEHPrepare::colorFunclets(Function &F) {
  689 void WinEHPrepare::demotePHIsOnFunclets(Function &F,
  693   for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE;) {
  722 void WinEHPrepare::cloneCommonBlocks(Function &F) {
  931 void WinEHPrepare::removeImplausibleInstructions(Function &F) {
  955         auto *CalledFn =
  956             dyn_cast<Function>(CS.getCalledValue()->stripPointerCasts());
 1005 void WinEHPrepare::cleanupPreparedFunclets(Function &F) {
 1008   for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE;) {
 1021 void WinEHPrepare::verifyPreparedFunclets(Function &F) {
 1035 bool WinEHPrepare::prepareExplicitEH(Function &F) {
 1071 AllocaInst *WinEHPrepare::insertPHILoads(PHINode *PN, Function &F) {
 1163                                       Function &F) {
lib/ExecutionEngine/ExecutionEngine.cpp
  156 Function *ExecutionEngine::FindFunctionNamed(StringRef FnName) {
  158     Function *F = Modules[i]->getFunction(FnName);
  400     if (Function *F = dyn_cast<Function>(FP))
  400     if (Function *F = dyn_cast<Function>(FP))
  426 int ExecutionEngine::runFunctionAsMain(Function *Fn,
  575   if (Function *F = const_cast<Function*>(dyn_cast<Function>(GV)))
  575   if (Function *F = const_cast<Function*>(dyn_cast<Function>(GV)))
  910     else if (const Function *F = dyn_cast<Function>(C))
  910     else if (const Function *F = dyn_cast<Function>(C))
lib/ExecutionEngine/ExecutionEngineBindings.cpp
  188     for (auto &F : *Mod) {
  236   return unwrap(EE)->runFunctionAsMain(unwrap<Function>(F), ArgVec, EnvP);
  250   *Result = unwrap(EE)->runFunction(unwrap<Function>(F), ArgVec);
  271   if (Function *F = unwrap(EE)->FindFunctionNamed(Name)) {
lib/ExecutionEngine/Interpreter/Execution.cpp
 1120   Function *F = CS.getCalledFunction();
 2123 void Interpreter::callFunction(Function *F, ArrayRef<GenericValue> ArgVals) {
 2151   for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end();
lib/ExecutionEngine/Interpreter/ExternalFunctions.cpp
   63 static ManagedStatic<std::map<const Function *, ExFunc> > ExportedFunctions;
  100 static ExFunc lookupFunction(const Function *F) {
  257 GenericValue Interpreter::callExternalFunction(Function *F,
  265   std::map<const Function *, ExFunc>::iterator FI = ExportedFunctions->find(F);
lib/ExecutionEngine/Interpreter/Interpreter.cpp
   80 GenericValue Interpreter::runFunction(Function *F,
lib/ExecutionEngine/Interpreter/Interpreter.h
   61   Function             *CurFunction;// The currently executing function
   85   std::vector<Function*> AtExitHandlers;
  107   GenericValue runFunction(Function *F,
  118   void callFunction(Function *F, ArrayRef<GenericValue> ArgVals);
  175   GenericValue callExternalFunction(Function *F,
  179   void addAtExitHandler(Function *F) {
  197   void *getPointerToFunction(Function *F) override { return (void*)F; }
lib/ExecutionEngine/MCJIT/MCJIT.cpp
  302     Function *F = M->getFunction(DemangledName);
  407 void *MCJIT::getPointerToFunction(Function *F) {
  459 Function *MCJIT::FindFunctionNamedInModulePtrSet(StringRef FnName,
  463     Function *F = (*I)->getFunction(FnName);
  483 Function *MCJIT::FindFunctionNamed(StringRef FnName) {
  484   Function *F = FindFunctionNamedInModulePtrSet(
  507 GenericValue MCJIT::runFunction(Function *F, ArrayRef<GenericValue> ArgValues) {
lib/ExecutionEngine/MCJIT/MCJIT.h
  197   Function *FindFunctionNamedInModulePtrSet(StringRef FnName,
  224   Function *FindFunctionNamed(StringRef FnName) override;
  260   void *getPointerToFunction(Function *F) override;
  262   GenericValue runFunction(Function *F,
lib/ExecutionEngine/Orc/CompileOnDemandLayer.cpp
   25     if (isa<Function>(GV)) {
   26       auto &F = cast<Function>(GV);
   26       auto &F = cast<Function>(GV);
   40       if (isa<Function>(Aliasee)) {
   41         auto *F = cloneFunctionDecl(*A.getParent(), *cast<Function>(Aliasee));
   41         auto *F = cloneFunctionDecl(*A.getParent(), *cast<Function>(Aliasee));
  194   for (auto &F : M.functions()) {
lib/ExecutionEngine/Orc/ExecutionUtils.cpp
   53   Function *Func = nullptr;
   57     if (Function *F = dyn_cast_or_null<Function>(FuncC)) {
   57     if (Function *F = dyn_cast_or_null<Function>(FuncC)) {
lib/ExecutionEngine/Orc/IndirectionUtils.cpp
  237 void makeStub(Function &F, Value &ImplPointer) {
  286 Function* cloneFunctionDecl(Module &Dst, const Function &F,
  286 Function* cloneFunctionDecl(Module &Dst, const Function &F,
  288   Function *NewF =
  289     Function::Create(cast<FunctionType>(F.getValueType()),
  304 void moveFunctionBody(Function &OrigF, ValueToValueMapTy &VMap,
  306                       Function *NewF) {
  309     NewF = cast<Function>(VMap[&OrigF]);
lib/ExecutionEngine/Orc/OrcMCJITReplacement.cpp
   26 OrcMCJITReplacement::runFunction(Function *F,
lib/ExecutionEngine/Orc/OrcMCJITReplacement.h
  353   void *getPointerToFunction(Function *F) override {
  366   GenericValue runFunction(Function *F,
lib/ExecutionEngine/Orc/SpeculateAnalyses.cpp
   58     if (auto DirectCall = dyn_cast<Function>(CalledValue))
   69 bool SpeculateQuery::isStraightLine(const Function &F) {
   88 BlockFreqQuery::ResultTy BlockFreqQuery::operator()(Function &F) {
  283 SpeculateQuery::ResultTy SequenceBBQuery::operator()(Function &F) {
lib/ExecutionEngine/Orc/Speculation.cpp
   76         Function::Create(RuntimeCallTy, Function::LinkageTypes::ExternalLinkage,
   76         Function::Create(RuntimeCallTy, Function::LinkageTypes::ExternalLinkage,
   86     for (auto &Fn : M.getFunctionList()) {
lib/ExecutionEngine/RuntimeDyld/JITSymbol.cpp
   30   if (isa<Function>(GV))
   33            isa<Function>(cast<GlobalAlias>(GV).getAliasee()))
lib/FuzzMutate/IRMutator.cpp
   28   Function *F = Function::Create(FunctionType::get(Type::getVoidTy(Context), {},
   28   Function *F = Function::Create(FunctionType::get(Type::getVoidTy(Context), {},
   39   auto RS = makeSampler<Function *>(IB.Rand);
   40   for (Function &F : M)
   46 void IRMutationStrategy::mutate(Function &F, RandomIRBuilder &IB) {
   70 static void eliminateDeadCode(Function &F) {
   79 void InjectorIRStrategy::mutate(Function &F, RandomIRBuilder &IB) {
  153 void InstDeleterIRStrategy::mutate(Function &F, RandomIRBuilder &IB) {
lib/IR/AbstractCallSite.cpp
   67   Function *Callee = CS.getCalledFunction();
lib/IR/AsmWriter.cpp
  155   for (const Function &F : *M) {
  181 static void predictValueUseListOrderImpl(const Value *V, const Function *F,
  197       !isa<GlobalVariable>(V) && !isa<Function>(V) && !isa<BasicBlock>(V);
  244 static void predictValueUseListOrder(const Value *V, const Function *F,
  278   for (const Function &F : make_range(M->rbegin(), M->rend())) {
  298   for (const Function &F : *M)
  311   for (const Function &F : *M)
  326     const Function *M = I->getParent() ? I->getParent()->getParent() : nullptr;
  680   const Function* TheFunction = nullptr;
  729   explicit SlotTracker(const Function *F,
  750   void incorporateFunction(const Function *F) {
  755   const Function *getFunction() const { return TheFunction; }
  815   void processFunctionMetadata(const Function &F);
  824                                      const Function *F)
  845 void ModuleSlotTracker::incorporateFunction(const Function &F) {
  884   if (const Function *Func = dyn_cast<Function>(V))
  884   if (const Function *Func = dyn_cast<Function>(V))
  903 SlotTracker::SlotTracker(const Function *F, bool ShouldInitializeAllMetadata)
  958   for (const Function &F : *TheModule) {
  986   for(Function::const_arg_iterator AI = TheFunction->arg_begin(),
 1058 void SlotTracker::processFunctionMetadata(const Function &F) {
 1069     if (Function *F = CI->getCalledFunction())
 2405   void printFunction(const Function *F);
 2412   void printUseLists(const Function *F);
 2647   for (const Function &F : *M)
 3398 void AssemblyWriter::printFunction(const Function *F) {
 4168 void AssemblyWriter::printUseLists(const Function *F) {
 4271     if (Function *F = CI->getCalledFunction())
 4284   else if (isa<Function>(this) || isa<MetadataAsValue>(this))
 4314     else if (const Function *F = dyn_cast<Function>(GV))
 4314     else if (const Function *F = dyn_cast<Function>(GV))
lib/IR/Attributes.cpp
 1723 static bool isEqual(const Function &Caller, const Function &Callee) {
 1723 static bool isEqual(const Function &Caller, const Function &Callee) {
 1734 static void setAND(Function &Caller, const Function &Callee) {
 1734 static void setAND(Function &Caller, const Function &Callee) {
 1746 static void setOR(Function &Caller, const Function &Callee) {
 1746 static void setOR(Function &Caller, const Function &Callee) {
 1754 static void adjustCallerSSPLevel(Function &Caller, const Function &Callee) {
 1754 static void adjustCallerSSPLevel(Function &Caller, const Function &Callee) {
 1778 static void adjustCallerStackProbes(Function &Caller, const Function &Callee) {
 1778 static void adjustCallerStackProbes(Function &Caller, const Function &Callee) {
 1789 adjustCallerStackProbeSize(Function &Caller, const Function &Callee) {
 1789 adjustCallerStackProbeSize(Function &Caller, const Function &Callee) {
 1819 adjustMinLegalVectorWidth(Function &Caller, const Function &Callee) {
 1819 adjustMinLegalVectorWidth(Function &Caller, const Function &Callee) {
 1843 adjustNullPointerValidAttr(Function &Caller, const Function &Callee) {
 1843 adjustNullPointerValidAttr(Function &Caller, const Function &Callee) {
 1852 bool AttributeFuncs::areInlineCompatible(const Function &Caller,
 1853                                          const Function &Callee) {
 1857 void AttributeFuncs::mergeAttributesForInlining(Function &Caller,
 1858                                                 const Function &Callee) {
lib/IR/AutoUpgrade.cpp
   37 static bool UpgradePTESTIntrinsic(Function* F, Intrinsic::ID IID,
   38                                   Function *&NewFn) {
   53 static bool UpgradeX86IntrinsicsWith8BitMask(Function *F, Intrinsic::ID IID,
   54                                              Function *&NewFn) {
   67 static bool ShouldUpgradeX86Intrinsic(Function *F, StringRef Name) {
  394 static bool UpgradeX86IntrinsicFunction(Function *F, StringRef Name,
  395                                         Function *&NewFn) {
  490 static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) {
  490 static bool UpgradeIntrinsicFunction1(Function *F, Function *&NewFn) {
  516       NewFn = Function::Create(fType, F->getLinkage(), F->getAddressSpace(),
  532       NewFn = Function::Create(fType, F->getLinkage(), F->getAddressSpace(),
  824 bool llvm::UpgradeIntrinsicFunction(Function *F, Function *&NewFn) {
  824 bool llvm::UpgradeIntrinsicFunction(Function *F, Function *&NewFn) {
 1101   Function *Intrin = Intrinsic::getDeclaration(CI.getModule(), IID, Ty);
 1128   Function *Intrin = Intrinsic::getDeclaration(CI.getModule(), IID, Ty);
 1198   Function *Intrin = Intrinsic::getDeclaration(CI.getModule(), IID, Ty);
 1363   Function *Intrin = Intrinsic::getDeclaration(CI.getModule(), IID);
 1646 void llvm::UpgradeIntrinsicCall(CallInst *CI, Function *NewFn) {
 1647   Function *F = CI->getCalledFunction();
 1794       Function *Intr = Intrinsic::getDeclaration(F->getParent(),
 2104         Function *F = Intrinsic::getDeclaration(CI->getModule(), IID,
 2134       Function *ELd = Intrinsic::getDeclaration(F->getParent(),
 2149       Function *CSt = Intrinsic::getDeclaration(F->getParent(),
 2163       Function *Intr = Intrinsic::getDeclaration(F->getParent(), IID, ResultTy);
 2227       Function *CRC32 = Intrinsic::getDeclaration(F->getParent(),
 3119         Function *FMA = Intrinsic::getDeclaration(CI->getModule(), IID);
 3122         Function *FMA = Intrinsic::getDeclaration(CI->getModule(),
 3179         Function *FMA = Intrinsic::getDeclaration(CI->getModule(),
 3198       Function *FMA = Intrinsic::getDeclaration(CI->getModule(), Intrinsic::fma,
 3245         Function *FMA = Intrinsic::getDeclaration(CI->getModule(), Intrinsic::fma,
 3725 void llvm::UpgradeCallsToIntrinsic(Function *F) {
 3730   Function *NewFn;
 3864     Function *Fn = M.getFunction(OldFunc);
 3869     Function *NewFn = llvm::Intrinsic::getDeclaration(&M, IntrinsicFunc);
lib/IR/BasicBlock.cpp
   27   if (Function *F = getParent())
   40 BasicBlock::BasicBlock(LLVMContext &C, const Twine &Name, Function *NewParent,
   53 void BasicBlock::insertInto(Function *NewParent, BasicBlock *InsertBefore) {
   87 void BasicBlock::setParent(Function *parent) {
  189     if (Function *F = CI->getCalledFunction())
lib/IR/ConstantFold.cpp
 1162             if (!GVAlign && isa<Function>(GV))
 1164           } else if (isa<Function>(GV)) {
lib/IR/Constants.cpp
 1465 BlockAddress *BlockAddress::get(Function *F, BasicBlock *BB) {
 1475 BlockAddress::BlockAddress(Function *F, BasicBlock *BB)
 1487   const Function *F = BB->getParent();
 1505   Function *NewF = getFunction();
 1509     NewF = cast<Function>(To->stripPointerCasts());
lib/IR/Core.cpp
 1231   } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) {
 1231   } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) {
 1255   } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) {
 1255   } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) {
 1278   } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) {
 1278   } else if (const auto *F = dyn_cast<Function>(unwrap(Val))) {
 1815   return wrap(BlockAddress::get(unwrap<Function>(F), unwrap(BB)));
 2256   return wrap(Function::Create(unwrap<FunctionType>(FunctionTy),
 2281   Function *Func = unwrap<Function>(Fn);
 2281   Function *Func = unwrap<Function>(Fn);
 2289   Function *Func = unwrap<Function>(Fn);
 2289   Function *Func = unwrap<Function>(Fn);
 2297   unwrap<Function>(Fn)->eraseFromParent();
 2301   return unwrap<Function>(Fn)->hasPersonalityFn();
 2305   return wrap(unwrap<Function>(Fn)->getPersonalityFn());
 2309   unwrap<Function>(Fn)->setPersonalityFn(unwrap<Constant>(PersonalityFn));
 2313   if (Function *F = dyn_cast<Function>(unwrap(Fn)))
 2313   if (Function *F = dyn_cast<Function>(unwrap(Fn)))
 2358   return Function::lookupIntrinsicID({Name, NameLen});
 2367   return unwrap<Function>(Fn)->getCallingConv();
 2371   return unwrap<Function>(Fn)->setCallingConv(
 2376   Function *F = unwrap<Function>(Fn);
 2376   Function *F = unwrap<Function>(Fn);
 2381   Function *F = unwrap<Function>(Fn);
 2381   Function *F = unwrap<Function>(Fn);
 2390   unwrap<Function>(F)->addAttribute(Idx, unwrap(A));
 2394   auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
 2400   auto AS = unwrap<Function>(F)->getAttributes().getAttributes(Idx);
 2408   return wrap(unwrap<Function>(F)->getAttribute(Idx,
 2415   return wrap(unwrap<Function>(F)->getAttribute(Idx, StringRef(K, KLen)));
 2420   unwrap<Function>(F)->removeAttribute(Idx, (Attribute::AttrKind)KindID);
 2425   unwrap<Function>(F)->removeAttribute(Idx, StringRef(K, KLen));
 2430   Function *Func = unwrap<Function>(Fn);
 2430   Function *Func = unwrap<Function>(Fn);
 2440   return unwrap<Function>(FnRef)->arg_size();
 2444   Function *Fn = unwrap<Function>(FnRef);
 2444   Function *Fn = unwrap<Function>(FnRef);
 2445   for (Function::arg_iterator I = Fn->arg_begin(),
 2451   Function *Fn = unwrap<Function>(FnRef);
 2451   Function *Fn = unwrap<Function>(FnRef);
 2460   Function *Func = unwrap<Function>(Fn);
 2460   Function *Func = unwrap<Function>(Fn);
 2461   Function::arg_iterator I = Func->arg_begin();
 2468   Function *Func = unwrap<Function>(Fn);
 2468   Function *Func = unwrap<Function>(Fn);
 2469   Function::arg_iterator I = Func->arg_end();
 2477   Function *Fn = A->getParent();
 2587   return unwrap<Function>(FnRef)->size();
 2591   Function *Fn = unwrap<Function>(FnRef);
 2591   Function *Fn = unwrap<Function>(FnRef);
 2597   return wrap(&unwrap<Function>(Fn)->getEntryBlock());
 2601   Function *Func = unwrap<Function>(Fn);
 2601   Function *Func = unwrap<Function>(Fn);
 2602   Function::iterator I = Func->begin();
 2609   Function *Func = unwrap<Function>(Fn);
 2609   Function *Func = unwrap<Function>(Fn);
 2610   Function::iterator I = Func->end();
 2618   Function::iterator I(Block);
 2626   Function::iterator I(Block);
 2648   unwrap<Function>(Fn)->getBasicBlockList().push_back(unwrap(BB));
 2654   return wrap(BasicBlock::Create(*unwrap(C), Name, unwrap<Function>(FnRef)));
 3138         cast<Function>(unwrap(PersFn)));
 4085   return unwrap<legacy::FunctionPassManager>(FPM)->run(*unwrap<Function>(F));
lib/IR/DIBuilder.cpp
  914 static Function *getDeclareIntrin(Module &M) {
lib/IR/DebugInfo.cpp
  313 bool llvm::stripDebugInfo(Function &F) {
  367   for (Function &F : M)
  594     if (auto *DbgVal = M.getFunction(Name)) {
  631   for (auto &F : M) {
 1422   return wrap(unwrap<Function>(Func)->getSubprogram());
 1426   unwrap<Function>(Func)->setSubprogram(unwrap<DISubprogram>(SP));
lib/IR/DebugInfoMetadata.cpp
  658 bool DISubprogram::describes(const Function *F) const {
lib/IR/DiagnosticInfo.cpp
  165   if (auto *F = dyn_cast<Function>(V)) {
  248 static const BasicBlock &getFirstFunctionBlock(const Function *Func) {
  255                                        const Function *Func)
  261   const Function &Fn = getFunction();
  282   const Function &Fn = getFunction();
  310   const Function &Fn = getFunction();
lib/IR/Dominators.cpp
  103 bool DominatorTree::invalidate(Function &F, const PreservedAnalyses &PA,
  108   return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>() ||
  323 DominatorTree DominatorTreeAnalysis::run(Function &F,
  334 PreservedAnalyses DominatorTreePrinterPass::run(Function &F,
  342 PreservedAnalyses DominatorTreeVerifierPass::run(Function &F,
  363 bool DominatorTreeWrapperPass::runOnFunction(Function &F) {
lib/IR/Function.cpp
   56 using ProfileCount = Function::ProfileCount;
   66 Argument::Argument(Type *Ty, const Twine &Name, Function *Par, unsigned ArgNo)
   71 void Argument::setParent(Function *parent) {
  217 Function *Function::Create(FunctionType *Ty, LinkageTypes Linkage,
  245                    OperandTraits<Function>::op_begin(this), 0, Linkage, name,
  314 void Function::stealArgumentListFrom(Function &Src) {
  497 void Function::copyAttributesFrom(const Function *Src) {
 1093 Function *Intrinsic::getDeclaration(Module *M, ID id, ArrayRef<Type*> Tys) {
 1096   return cast<Function>(
 1389 Optional<Function*> Intrinsic::remangleIntrinsicFunction(Function *F) {
 1389 Optional<Function*> Intrinsic::remangleIntrinsicFunction(Function *F) {
 1542 void Function::setEntryCount(uint64_t Count, Function::ProfileCountType Type,
 1604 bool llvm::NullPointerIsDefined(const Function *F, unsigned AS) {
lib/IR/Globals.cpp
   45   if (const Function *F = dyn_cast<Function>(this))
   45   if (const Function *F = dyn_cast<Function>(this))
  237   if (const Function *F = dyn_cast<Function>(this))
  237   if (const Function *F = dyn_cast<Function>(this))
lib/IR/IRBuilder.cpp
   74 static CallInst *createCallHelper(Function *Callee, ArrayRef<Value *> Ops,
   86 static InvokeInst *createInvokeHelper(Function *Invokee, BasicBlock *NormalDest,
  107   Function *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memset, Tys);
  137   Function *TheFn = Intrinsic::getDeclaration(
  169   Function *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memcpy, Tys);
  210   Function *TheFn = Intrinsic::getDeclaration(
  249   Function *TheFn = Intrinsic::getDeclaration(M, Intrinsic::memmove, Tys);
  286   Function *TheFn = Intrinsic::getDeclaration(
  411   Function *TheFn =
  427   Function *TheFn =
  447   Function *TheFn =
  458   Function *FnAssume = Intrinsic::getDeclaration(M, Intrinsic::assume);
  510   Function *TheFn = Intrinsic::getDeclaration(M, Id, OverloadedTypes);
  614   Function *FnStatepoint =
  664   Function *FnStatepoint = Intrinsic::getDeclaration(
  711  Function *FnGCResult = Intrinsic::getDeclaration(M, ID, Types);
  724  Function *FnGCRelocate =
  737   Function *Fn = Intrinsic::getDeclaration(M, ID, {V->getType()});
  746   Function *Fn = Intrinsic::getDeclaration(M, ID, { LHS->getType() });
  756   Function *Fn = Intrinsic::getDeclaration(M, ID, Types);
lib/IR/IRPrintingPasses.cpp
   36     for(const auto &F : M.functions()) {
   53 PreservedAnalyses PrintFunctionPass::run(Function &F,
   99   bool runOnFunction(Function &F) override {
lib/IR/Instruction.cpp
   59 const Function *Instruction::getFunction() const {
lib/IR/Instructions.cpp
  259 Function *CallBase::getCaller() { return getParent()->getParent(); }
  268   if (isa<Function>(V) || isa<Constant>(V))
  292   if (auto *F = getCalledFunction())
  314   if (const Function *F = getCalledFunction())
  327   if (const Function *F = getCalledFunction())
  338   if (const Function *F = getCalledFunction())
  344   if (const Function *F = getCalledFunction())
  350   if (const Function *F = getCalledFunction())
  527                                  Function *MallocF, const Twine &Name) {
  594   if (Function *F = dyn_cast<Function>(MallocFunc.getCallee())) {
  594   if (Function *F = dyn_cast<Function>(MallocFunc.getCallee())) {
  613                                     Function *MallocF,
  622                                     Function *MallocF,
  639                                     Function *MallocF, const Twine &Name) {
  647                                     Function *MallocF, const Twine &Name) {
  680   if (Function *F = dyn_cast<Function>(FreeFunc.getCallee()))
  680   if (Function *F = dyn_cast<Function>(FreeFunc.getCallee()))
lib/IR/LLVMContext.cpp
  280 void LLVMContext::setGC(const Function &Fn, std::string GCName) {
  290 const std::string &LLVMContext::getGC(const Function &Fn) {
  294 void LLVMContext::deleteGC(const Function &Fn) {
lib/IR/LLVMContextImpl.h
 1308   DenseMap<std::pair<const Function *, const BasicBlock *>, BlockAddress *>
 1399   DenseMap<const Function*, std::string> GCNames;
lib/IR/LegacyPassManager.cpp
  150   for (Function &F : M) {
  168     Function *F) {
  305   if (isa<Function>(V))
  334   bool runOnFunction(Function &F) override;
  342   bool doInitialization(Function &F);
  344   bool doFinalization(Function &F);
  410   bool run(Function &F);
  492   Pass* getOnTheFlyPass(Pass *MP, AnalysisID PI, Function &F) override;
 1348 Pass *PMDataManager::getOnTheFlyPass(Pass *P, AnalysisID PI, Function &F) {
 1366                                      Function &F) {
 1376 bool BBPassManager::runOnFunction(Function &F) {
 1458 bool BBPassManager::doInitialization(Function &F) {
 1469 bool BBPassManager::doFinalization(Function &F) {
 1506 bool FunctionPassManager::run(Function &F) {
 1580 bool FunctionPassManagerImpl::run(Function &F) {
 1614 bool FPPassManager::runOnFunction(Function &F) {
 1683   for (Function &F : M)
 1835 Pass* MPPassManager::getOnTheFlyPass(Pass *MP, AnalysisID PI, Function &F){
lib/IR/MDBuilder.cpp
  100 MDNode *MDBuilder::createCallees(ArrayRef<Function *> Callees) {
  102   for (Function *F : Callees)
lib/IR/Mangler.cpp
   93 static void addByteCountSuffix(raw_ostream &OS, const Function *F,
   97   for (Function::const_arg_iterator AI = F->arg_begin(), AE = F->arg_end();
  139   const Function *MSFunc = dyn_cast<Function>(GV);
  139   const Function *MSFunc = dyn_cast<Function>(GV);
lib/IR/Metadata.cpp
  334     if (auto *Fn = A->getParent())
  340     if (auto *Fn = BB->getParent())
lib/IR/Module.cpp
  149     Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage,
  149     Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage,
  174 Function *Module::getFunction(StringRef Name) const {
  175   return dyn_cast_or_null<Function>(getNamedValue(Name));
  440   for (Function &F : *this)
  477   for (Function &F : FunctionList)
lib/IR/Pass.cpp
  162 static std::string getDescription(const Function &F) {
  166 bool FunctionPass::skipFunction(const Function &F) const {
  188 bool BasicBlockPass::doInitialization(Function &) {
  193 bool BasicBlockPass::doFinalization(Function &) {
  204   const Function *F = BB.getParent();
lib/IR/PassManager.cpp
   51       PA.allAnalysesInSetPreserved<AllAnalysesOn<Function>>();
   55   for (Function &F : M) {
lib/IR/SafepointIRVerifier.cpp
  125   void processFunction(const Function &F, const DominatorTree &DT) {
  134     ReversePostOrderTraversal<const Function *> RPOT(&F);
  197 static void Verify(const Function &F, const DominatorTree &DT,
  201 PreservedAnalyses SafepointIRVerifierPass::run(Function &F,
  219   bool runOnFunction(Function &F) override {
  236 void llvm::verifySafepointIR(Function &F) {
  444   const Function &F;
  456   GCPtrTracker(const Function &F, const DominatorTree &DT,
  536 GCPtrTracker::GCPtrTracker(const Function &F, const DominatorTree &DT,
  581   ReversePostOrderTraversal<const Function *> RPOT(&Tracker.F);
  883 static void Verify(const Function &F, const DominatorTree &DT,
lib/IR/Statepoint.cpp
   21   if (auto *F = Call->getCalledFunction())
lib/IR/SymbolTableListTraitsImpl.h
   95       ValueSubClass &V = *first;
lib/IR/TypeFinder.cpp
   50   for (const Function &FI : M) {
lib/IR/Value.cpp
  168       if (Function *PP = P->getParent())
  171     if (Function *P = BB->getParent())
  177     if (Function *P = A->getParent())
  287   if (Function *F = dyn_cast<Function>(this))
  287   if (Function *F = dyn_cast<Function>(this))
  677     if (isa<Function>(GO)) {
lib/IR/Verifier.cpp
  268   DenseMap<const DISubprogram *, const Function *> DISubprogramAttachments;
  288   DenseMap<Function *, std::pair<unsigned, unsigned>> FrameEscapeInfo;
  298   SmallVector<const Function *, 4> DeoptimizeDeclarations;
  323   bool verify(const Function &F) {
  367     for (const Function &F : M)
  407   void visitMetadataAsValue(const MetadataAsValue &MD, Function *F);
  408   void visitValueAsMetadata(const ValueAsMetadata &MD, Function *F);
  417   void visitFunction(const Function &F);
  499   bool performTypeCheck(Intrinsic::ID ID, Function *F, Type *Ty, int VT,
  610     } else if (const Function *F = dyn_cast<Function>(V)) {
  610     } else if (const Function *F = dyn_cast<Function>(V)) {
  826 void Verifier::visitValueAsMetadata(const ValueAsMetadata &MD, Function *F) {
  839   Function *ActualF = nullptr;
  852 void Verifier::visitMetadataAsValue(const MetadataAsValue &MDV, Function *F) {
 2068     Function *F = Counts.first;
 2134 void Verifier::visitFunction(const Function &F) {
 2237     auto *Per = dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
 2237     auto *Per = dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
 2293         const Function *&AttachedTo = DISubprogramAttachments[SP];
 2449   Function *F = RI.getParent()->getParent();
 2853   Function *Callee
 2854     = dyn_cast<Function>(Call.getCalledValue()->stripPointerCasts());
 2974   if (Function *F = Call.getCalledFunction())
 3055   Function *F = CI.getParent()->getParent();
 3590   Function *F = BB->getParent();
 3675   Function *F = LPI.getParent()->getParent();
 3718   Function *F = BB->getParent();
 3746   Function *F = BB->getParent();
 3926   Function *F = BB->getParent();
 4113     if (Function *F = dyn_cast<Function>(I.getOperand(i))) {
 4113     if (Function *F = dyn_cast<Function>(I.getOperand(i))) {
 4233   Function *IF = Call.getCalledFunction();
 4454     Function *Fn = dyn_cast<Function>(FnArg);
 4454     Function *Fn = dyn_cast<Function>(FnArg);
 4480     const Function *StatepointFn =
 4934   Function *F = BB ? BB->getParent() : nullptr;
 4969   Function *F = BB ? BB->getParent() : nullptr;
 5088   const Function *First = DeoptimizeDeclarations[0];
 5109 bool llvm::verifyFunction(const Function &f, raw_ostream *OS) {
 5110   Function &F = const_cast<Function &>(f);
 5126   for (const Function &F : M)
 5160   bool runOnFunction(Function &F) override {
 5170     for (Function &F : M)
 5548 VerifierAnalysis::Result VerifierAnalysis::run(Function &F,
 5561 PreservedAnalyses VerifierPass::run(Function &F, FunctionAnalysisManager &AM) {
lib/LTO/LTO.cpp
  864   Function *TypeTestFunc = RegularLTO.CombinedModule->getFunction(
  866   Function *TypeCheckedLoadFunc = RegularLTO.CombinedModule->getFunction(
lib/LTO/LTOCodeGenerator.cpp
  402   for (auto &GV : TheModule)
  452     for (auto &GV : *MergedModule)
lib/LTO/LTOModule.cpp
  405   const Function *F = cast<Function>(Sym.get<GlobalValue *>());
  405   const Function *F = cast<Function>(Sym.get<GlobalValue *>());
  409 void LTOModule::addDefinedFunctionSymbol(StringRef Name, const Function *F) {
  507     addDefinedFunctionSymbol(info.name, cast<Function>(info.symbol));
  593     auto *F = dyn_cast<Function>(GV);
  593     auto *F = dyn_cast<Function>(GV);
lib/LTO/UpdateCompilerUsed.cpp
   35     for (Function &F : TheModule)
   73     for (const Function &F : TheModule) {
  106       FuncAliasee = dyn_cast<Function>(A->getAliasee());
  108     if ((isa<Function>(GV) || FuncAliasee) && Libcalls.count(GV.getName())) {
lib/Linker/IRMover.cpp
  489   Error linkFunctionBody(Function &Dst, Function &Src);
  489   Error linkFunctionBody(Function &Dst, Function &Src);
  501   Function *copyFunctionProto(const Function *SF);
  501   Function *copyFunctionProto(const Function *SF);
  591   if (auto *F = dyn_cast<Function>(New)) {
  591   if (auto *F = dyn_cast<Function>(New)) {
  654 Function *IRLinker::copyFunctionProto(const Function *SF) {
  654 Function *IRLinker::copyFunctionProto(const Function *SF) {
  657   auto *F =
  658       Function::Create(TypeMap.get(SF->getFunctionType()),
  690   } else if (auto *SF = dyn_cast<Function>(SGV)) {
  697           Function::Create(cast<FunctionType>(TypeMap.get(SGV->getValueType())),
  722   if (auto *NewF = dyn_cast<Function>(NewGV)) {
  722   if (auto *NewF = dyn_cast<Function>(NewGV)) {
 1006   if (Function *F = dyn_cast<Function>(NewGV))
 1006   if (Function *F = dyn_cast<Function>(NewGV))
 1056 Error IRLinker::linkFunctionBody(Function &Dst, Function &Src) {
 1056 Error IRLinker::linkFunctionBody(Function &Dst, Function &Src) {
 1090   if (auto *F = dyn_cast<Function>(&Src))
 1090   if (auto *F = dyn_cast<Function>(&Src))
 1091     return linkFunctionBody(cast<Function>(Dst), *F);
lib/Linker/LinkModules.cpp
  434   if (auto *F = dyn_cast<Function>(&GV)) {
  434   if (auto *F = dyn_cast<Function>(&GV)) {
  444       Declaration = Function::Create(FTy, GlobalValue::ExternalLinkage, "", &M);
  497     Function &GV = *I++;
  506   for (Function &SF : *SrcM)
  522   for (Function &SF : *SrcM)
lib/Object/ModuleSymbolTable.cpp
  199   if (dyn_cast_or_null<Function>(GV->getBaseObject()))
lib/Passes/PassBuilder.cpp
  298   PreservedAnalyses run(Function &F, FunctionAnalysisManager &) {
  311   Result run(Function &, FunctionAnalysisManager &) { return Result(); }
lib/Passes/StandardInstrumentations.cpp
   38   if (any_isa<const Function *>(IR)) {
   39     const Function *F = any_cast<const Function *>(IR);
   39     const Function *F = any_cast<const Function *>(IR);
   49       const Function &F = N.getFunction();
   60     const Function *F = L->getHeader()->getParent();
   77 void printIR(const Function *F, StringRef Banner,
   87     const Function &F = N.getFunction();
   98   const Function *F = L->getHeader()->getParent();
  120   if (any_isa<const Function *>(IR)) {
  121     const Function *F = any_cast<const Function *>(IR);
  121     const Function *F = any_cast<const Function *>(IR);
lib/ProfileData/InstrProf.cpp
  253 std::string getPGOFuncName(const Function &F, bool InLTO, uint64_t Version) {
  332 GlobalVariable *createPGOFuncNameVar(Function &F, StringRef PGOFuncName) {
  337   for (Function &F : M) {
  345     MD5FuncMap.emplace_back(Function::getGUID(PGOFuncName), &F);
  355         MD5FuncMap.emplace_back(Function::getGUID(OtherFuncName), &F);
 1028 MDNode *getPGOFuncNameMetadata(const Function &F) {
 1032 void createPGOFuncNameMetadata(Function &F, StringRef PGOFuncName) {
 1044 bool needsComdatForCounter(const Function &F, const Module &M) {
 1088 bool canRenameComdatFunc(const Function &F, bool CheckAddressTaken) {
lib/Target/AArch64/AArch64AsmPrinter.cpp
  693   const Function &F = MF->getFunction();
lib/Target/AArch64/AArch64BranchTargets.cpp
   60   const Function &F = MF.getFunction();
lib/Target/AArch64/AArch64CallLowering.cpp
  267     const Function &F = MF.getFunction();
  386   const Function &F = MF.getFunction();
  417     MachineIRBuilder &MIRBuilder, const Function &F,
  524   const Function &CallerF = MF.getFunction();
  568   const Function &CallerF = MF.getFunction();
  671   const Function &CallerF = MF.getFunction();
  762 static unsigned getCallOpcode(const Function &CallerF, bool IsIndirect,
  782   const Function &F = MF.getFunction();
  924   const Function &F = MF.getFunction();
lib/Target/AArch64/AArch64CallLowering.h
   40   bool lowerFormalArguments(MachineIRBuilder &MIRBuilder, const Function &F,
lib/Target/AArch64/AArch64FalkorHWPFFix.cpp
  100   bool runOnFunction(Function &F) override;
  119 bool FalkorMarkStridedAccessesLegacy::runOnFunction(Function &F) {
lib/Target/AArch64/AArch64FastISel.cpp
 2955   const Function *F = FuncInfo.Fn;
 3393   const Function *Callee = II->getCalledFunction();
 3684     const Function *Callee = II->getCalledFunction();
 3836   const Function &F = *I->getParent()->getParent();
lib/Target/AArch64/AArch64FrameLowering.cpp
  324   const Function &F = MF.getFunction();
  431   const Function &F = MF.getFunction();
  817   const Function &F = MF.getFunction();
  828   const Function &F = MF.getFunction();
  841   const Function &F = MF.getFunction();
lib/Target/AArch64/AArch64ISelLowering.cpp
 2883     auto *Fn = dyn_cast_or_null<Function>(GSD ? GSD->getGlobal() : nullptr);
 3155   Function::const_arg_iterator CurOrigArg = MF.getFunction().arg_begin();
 3567   const Function &CallerF = MF.getFunction();
 3574   for (Function::const_arg_iterator i = CallerF.arg_begin(),
 8835   Function *LdNFunc =
 8977   Function *StNFunc =
12181     Function *Ldxr = Intrinsic::getDeclaration(M, Int);
12197   Function *Ldxr = Intrinsic::getDeclaration(M, Int, Tys);
12226     Function *Stxr = Intrinsic::getDeclaration(M, Int);
12238   Function *Stxr = Intrinsic::getDeclaration(M, Int, Tys);
12262   Function *ThreadPointerFunc =
12296     if (Function *F = dyn_cast<Function>(SecurityCheckCookie.getCallee())) {
12296     if (Function *F = dyn_cast<Function>(SecurityCheckCookie.getCallee())) {
12312 Function *AArch64TargetLowering::getSSPStackGuardCheck(const Module &M) const {
lib/Target/AArch64/AArch64ISelLowering.h
  443   Function *getSSPStackGuardCheck(const Module &M) const override;
lib/Target/AArch64/AArch64InstrInfo.cpp
 5281   const Function &F = MF.getFunction();
 5437     const Function *Callee = nullptr;
 5440         Callee = dyn_cast<Function>(MOP.getGlobal());
lib/Target/AArch64/AArch64PreLegalizerCombiner.cpp
  148   const Function &F = MF.getFunction();
lib/Target/AArch64/AArch64PromoteConstant.cpp
  126     for (auto &MF : M) {
  136   bool runOnFunction(Function &F, PromotionCacheTy &PromotionCache);
  196   void insertDefinitions(Function &F, GlobalVariable &GV,
  201   void promoteConstants(Function &F, SmallVectorImpl<UpdateRecord> &Updates,
  468 static void ensurePromotedGV(Function &F, Constant &C,
  484 void AArch64PromoteConstant::insertDefinitions(Function &F,
  522     Function &F, SmallVectorImpl<UpdateRecord> &Updates,
  540 bool AArch64PromoteConstant::runOnFunction(Function &F,
lib/Target/AArch64/AArch64RegisterInfo.cpp
  234   const Function &F = MF.getFunction();
lib/Target/AArch64/AArch64StackTagging.cpp
   74   Function *SetTagFn;
   75   Function *SetTagZeroFn;
   76   Function *StgpFn;
   90                      Function *SetTagFn, Function *SetTagZeroFn,
   90                      Function *SetTagFn, Function *SetTagZeroFn,
   91                      Function *StgpFn)
  302   bool runOnFunction(Function &F) override;
  307   Function *F;
  308   Function *SetTagFunc;
  453   Function *IRG_SP =
  514 bool AArch64StackTagging::runOnFunction(Function &Fn) {
  621     Function *TagP = Intrinsic::getDeclaration(
lib/Target/AArch64/AArch64Subtarget.cpp
  255   auto *F = dyn_cast<Function>(GV);
lib/Target/AArch64/AArch64TargetMachine.cpp
  306 AArch64TargetMachine::getSubtargetImpl(const Function &F) const {
  406 AArch64TargetMachine::getTargetTransformInfo(const Function &F) {
lib/Target/AArch64/AArch64TargetMachine.h
   37   const AArch64Subtarget *getSubtargetImpl(const Function &F) const override;
   46   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
lib/Target/AArch64/AArch64TargetTransformInfo.cpp
   27 bool AArch64TTIImpl::areInlineCompatible(const Function *Caller,
   28                                          const Function *Callee) const {
lib/Target/AArch64/AArch64TargetTransformInfo.h
   63   explicit AArch64TTIImpl(const AArch64TargetMachine *TM, const Function &F)
   67   bool areInlineCompatible(const Function *Caller,
   68                            const Function *Callee) const;
lib/Target/AMDGPU/AMDGPUAliasAnalysis.cpp
  105     const Function *F = Arg->getParent();
lib/Target/AMDGPU/AMDGPUAliasAnalysis.h
   45   bool invalidate(Function &, const PreservedAnalyses &) { return false; }
   66   AMDGPUAAResult run(Function &F, AnalysisManager<Function> &AM) {
   66   AMDGPUAAResult run(Function &F, AnalysisManager<Function> &AM) {
lib/Target/AMDGPU/AMDGPUAlwaysInlinePass.cpp
   36                              SmallPtrSetImpl<Function *> &FuncsToAlwaysInline);
   58   SmallPtrSetImpl<Function *> &FuncsToAlwaysInline) {
   72       Function *F = I->getParent()->getParent();
   90   SmallPtrSet<Function *, 8> FuncsToAlwaysInline;
   91   SmallPtrSet<Function *, 8> FuncsToNoInline;
   94     if (Function* F = dyn_cast<Function>(A.getAliasee())) {
   94     if (Function* F = dyn_cast<Function>(A.getAliasee())) {
  132     for (Function &F : M) {
  144   for (Function *F : FuncsToAlwaysInline)
  147   for (Function *F : FuncsToNoInline)
lib/Target/AMDGPU/AMDGPUAnnotateKernelFeatures.cpp
   50   bool addFeatureAttributes(Function &F);
   52   bool propagateUniformWorkGroupAttribute(Function &Caller, Function &Callee);
   52   bool propagateUniformWorkGroupAttribute(Function &Caller, Function &Callee);
  188 static bool handleAttr(Function &Parent, const Function &Callee,
  188 static bool handleAttr(Function &Parent, const Function &Callee,
  197 static void copyFeaturesToFunction(Function &Parent, const Function &Callee,
  197 static void copyFeaturesToFunction(Function &Parent, const Function &Callee,
  218     Function *Caller = Node->getFunction();
  221       Function *Callee = std::get<1>(I)->getFunction();
  231        Function &Caller, Function &Callee) {
  231        Function &Caller, Function &Callee) {
  264 bool AMDGPUAnnotateKernelFeatures::addFeatureAttributes(Function &F) {
  279         Function *Callee = CS.getCalledFunction();
  355     Function *F = I->getFunction();
lib/Target/AMDGPU/AMDGPUAnnotateUniformValues.cpp
   44   bool runOnFunction(Function &F) override;
  142         Function *F = I.getParent()->getParent();
  165 bool AMDGPUAnnotateUniformValues::runOnFunction(Function &F) {
lib/Target/AMDGPU/AMDGPUArgumentUsageInfo.h
  158   DenseMap<const Function *, AMDGPUFunctionArgInfo> ArgInfoMap;
  174   void setFuncArgInfo(const Function &F, const AMDGPUFunctionArgInfo &ArgInfo) {
  178   const AMDGPUFunctionArgInfo &lookupFuncArgInfo(const Function &F) const {
lib/Target/AMDGPU/AMDGPUAsmPrinter.cpp
  198   const Function &F = MF->getFunction();
  859         const Function *Callee = cast<Function>(CalleeOp->getGlobal());
  859         const Function *Callee = cast<Function>(CalleeOp->getGlobal());
 1217   const Function &F = MF.getFunction();
lib/Target/AMDGPU/AMDGPUAsmPrinter.h
   59   DenseMap<const Function *, SIFunctionResourceInfo> CallGraphResourceInfo;
lib/Target/AMDGPU/AMDGPUAtomicOptimizer.cpp
   60   bool runOnFunction(Function &F) override;
   78 bool AMDGPUAtomicOptimizer::runOnFunction(Function &F) {
  286   Function *UpdateDPP =
  288   Function *PermLaneX16 =
  290   Function *ReadLane =
  345   Function *UpdateDPP =
  347   Function *ReadLane =
  349   Function *WriteLane =
lib/Target/AMDGPU/AMDGPUCallLowering.cpp
  268   const auto &F = MF.getFunction();
  347   const Function &F = MF.getFunction();
  369   const Function &F = MF.getFunction();
  438     MachineIRBuilder &B, const Function &F,
  551     MachineIRBuilder &B, const Function &F,
lib/Target/AMDGPU/AMDGPUCallLowering.h
   50   bool lowerFormalArgumentsKernel(MachineIRBuilder &B, const Function &F,
   53   bool lowerFormalArguments(MachineIRBuilder &B, const Function &F,
lib/Target/AMDGPU/AMDGPUCodeGenPrepare.cpp
  189   bool runOnFunction(Function &F) override;
  397   Function *I32 =
  570   Function *Decl = Intrinsic::getDeclaration(Mod, Intrinsic::amdgcn_fdiv_fast);
  610 static bool hasUnsafeFPMath(const Function &F) {
 1023 bool AMDGPUCodeGenPrepare::runOnFunction(Function &F) {
lib/Target/AMDGPU/AMDGPUFixFunctionBitcasts.cpp
   37     auto Callee = dyn_cast<Function>(CS.getCalledValue()->stripPointerCasts());
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.cpp
  216   const Function &F = MF.getFunction();
  265 void MetadataStreamerV2::emitKernelLanguage(const Function &Func) {
  283 void MetadataStreamerV2::emitKernelAttrs(const Function &Func) {
  301 void MetadataStreamerV2::emitKernelArgs(const Function &Func) {
  399 void MetadataStreamerV2::emitHiddenKernelArgs(const Function &Func) {
  672 void MetadataStreamerV3::emitKernelLanguage(const Function &Func,
  691 void MetadataStreamerV3::emitKernelAttrs(const Function &Func,
  712 void MetadataStreamerV3::emitKernelArgs(const Function &Func,
  830 void MetadataStreamerV3::emitHiddenKernelArgs(const Function &Func,
  883   const Function &F = MF.getFunction();
lib/Target/AMDGPU/AMDGPUHSAMetadataStreamer.h
   81   void emitKernelLanguage(const Function &Func, msgpack::MapDocNode Kern);
   83   void emitKernelAttrs(const Function &Func, msgpack::MapDocNode Kern);
   85   void emitKernelArgs(const Function &Func, msgpack::MapDocNode Kern);
   96   void emitHiddenKernelArgs(const Function &Func, unsigned &Offset,
  153   void emitKernelLanguage(const Function &Func);
  155   void emitKernelAttrs(const Function &Func);
  157   void emitKernelArgs(const Function &Func);
  167   void emitHiddenKernelArgs(const Function &Func);
lib/Target/AMDGPU/AMDGPUISelLowering.cpp
  912   const Function &Fn = MF.getFunction();
 1088   const Function &Fn = DAG.getMachineFunction().getFunction();
 1116   const Function &Fn = DAG.getMachineFunction().getFunction();
 1202       const Function &Fn = DAG.getMachineFunction().getFunction();
 1219   const Function &Fn = DAG.getMachineFunction().getFunction();
lib/Target/AMDGPU/AMDGPUInline.cpp
  112   Function *Caller = CS.getCaller();
  115   Function *Callee = CS.getCalledFunction();
  160   Function *Callee = CS.getCalledFunction();
  178   Function *Callee = CS.getCalledFunction();
  179   Function *Caller = CS.getCaller();
  212   std::function<AssumptionCache &(Function &)> GetAssumptionCache =
lib/Target/AMDGPU/AMDGPULegalizerInfo.cpp
 1648       const Function &Fn = MF.getFunction();
 1661     const Function &Fn = MF.getFunction();
lib/Target/AMDGPU/AMDGPULibCalls.cpp
  189     bool runOnFunction(Function &M) override;
  204     bool runOnFunction(Function &F) override;
  226   if (Function *F = dyn_cast<Function>(Callee.getCallee()))
  226   if (Function *F = dyn_cast<Function>(Callee.getCallee()))
  235   if (Function *F = dyn_cast<Function>(Callee.getCallee()))
  235   if (Function *F = dyn_cast<Function>(Callee.getCallee()))
  495   const Function *F = CI->getParent()->getParent();
  547   Function *Callee = aCI->getCalledFunction();
  580   auto *Callee = CI->getCalledFunction();
  641   Function *Callee = CI->getCalledFunction();
 1320     Function *UCallee = XI->getCalledFunction();
 1392   Function *F = CI->getParent()->getParent();
 1406   Function * Func = UI->getParent()->getParent();
 1417   Function *UCallee = UI->getCalledFunction();
 1722 static bool setFastFlags(Function &F, const TargetOptions &Options) {
 1742 bool AMDGPUSimplifyLibCalls::runOnFunction(Function &F) {
 1763       Function *Callee = CI->getCalledFunction();
 1775 bool AMDGPUUseNativeCalls::runOnFunction(Function &F) {
 1788       Function *Callee = CI->getCalledFunction();
lib/Target/AMDGPU/AMDGPULibFunc.cpp
  942 Function *AMDGPULibFunc::getFunction(Module *M, const AMDGPULibFunc &fInfo) {
  944   Function *F = dyn_cast_or_null<Function>(
  944   Function *F = dyn_cast_or_null<Function>(
  959   Function *F = dyn_cast_or_null<Function>(
  959   Function *F = dyn_cast_or_null<Function>(
lib/Target/AMDGPU/AMDGPULibFunc.h
  394   static Function *getFunction(llvm::Module *M, const AMDGPULibFunc &fInfo);
lib/Target/AMDGPU/AMDGPULowerIntrinsics.cpp
   29   bool makeLIDRangeMetadata(Function &F) const;
   37   bool expandMemIntrinsicUses(Function &F);
   63 bool AMDGPULowerIntrinsics::expandMemIntrinsicUses(Function &F) {
   75         Function *ParentFunc = Memcpy->getParent()->getParent();
  113 bool AMDGPULowerIntrinsics::makeLIDRangeMetadata(Function &F) const {
  134   for (Function &F : M) {
lib/Target/AMDGPU/AMDGPULowerKernelArguments.cpp
   51   bool runOnFunction(Function &F) override;
   61 bool AMDGPULowerKernelArguments::runOnFunction(Function &F) {
lib/Target/AMDGPU/AMDGPULowerKernelAttributes.cpp
   73   Function *F = CI->getParent()->getParent();
  242   Function *DispatchPtr = Mod->getFunction(DispatchPtrName);
lib/Target/AMDGPU/AMDGPUMachineFunction.cpp
   29   const Function &F = MF.getFunction();
lib/Target/AMDGPU/AMDGPUOpenCLEnqueuedBlockLowering.cpp
   80 static void collectCallers(Function *F, DenseSet<Function *> &Callers) {
   80 static void collectCallers(Function *F, DenseSet<Function *> &Callers) {
   83       auto *Caller = CI->getParent()->getParent();
   92 static void collectFunctionUsers(User *U, DenseSet<Function *> &Funcs) {
   94     auto *F = I->getParent()->getParent();
  106   DenseSet<Function *> Callers;
  109   for (auto &F : M.functions()) {
lib/Target/AMDGPU/AMDGPUPerfHintAnalysis.cpp
   75   bool runOnFunction(Function &F);
  104   AMDGPUPerfHintAnalysis::FuncInfo *visit(const Function &F);
  206 AMDGPUPerfHintAnalysis::FuncInfo *AMDGPUPerfHint::visit(const Function &F) {
  225         Function *Callee = CS.getCalledFunction();
  260 bool AMDGPUPerfHint::runOnFunction(Function &F) {
  376     Function *F = I->getFunction();
  390 bool AMDGPUPerfHintAnalysis::isMemoryBound(const Function *F) const {
  398 bool AMDGPUPerfHintAnalysis::needsWaveLimiter(const Function *F) const {
lib/Target/AMDGPU/AMDGPUPerfHintAnalysis.h
   36   bool isMemoryBound(const Function *F) const;
   38   bool needsWaveLimiter(const Function *F) const;
   49   typedef ValueMap<const Function*, FuncInfo> FuncInfoMap;
lib/Target/AMDGPU/AMDGPUPrintfRuntimeBinding.cpp
   62                     function_ref<const TargetLibraryInfo &(Function &)> GetTLI);
  149     Module &M, function_ref<const TargetLibraryInfo &(Function &)> GetTLI) {
lib/Target/AMDGPU/AMDGPUPromoteAlloca.cpp
  109   bool hasSufficientLocalMem(const Function &F);
  117   bool runOnFunction(Function &F) override;
  145 bool AMDGPUPromoteAlloca::runOnFunction(Function &F) {
  182   const Function &F = *Builder.GetInsertBlock()->getParent();
  186     Function *LocalSizeYFn
  188     Function *LocalSizeZFn
  234   Function *DispatchPtrFn
  291   Function *WorkitemIdFn = Intrinsic::getDeclaration(Mod, IntrID);
  624 bool AMDGPUPromoteAlloca::hasSufficientLocalMem(const Function &F) {
  736   const Function &ContainingFunction = *I.getParent()->getParent();
  793   Function *F = I.getParent()->getParent();
  919       Function *ObjectSize = Intrinsic::getDeclaration(Mod,
lib/Target/AMDGPU/AMDGPUPropagateAttributes.cpp
   60     Clone(FeatureBitset FeatureMask, Function *OrigF, Function *NewF) :
   60     Clone(FeatureBitset FeatureMask, Function *OrigF, Function *NewF) :
   64     Function *OrigF;
   65     Function *NewF;
   74   SmallSet<Function *, 32> Roots;
   80   Function *findFunction(const FeatureBitset &FeaturesNeeded,
   81                          Function *OrigF);
   85   Function *cloneWithFeatures(Function &F,
   85   Function *cloneWithFeatures(Function &F,
   89   void setFeatures(Function &F, const FeatureBitset &NewFeatures);
  101   bool process(Function &F);
  123   bool runOnFunction(Function &F) override;
  157 Function *
  159                                         Function *OrigF) {
  169   for (auto &F : M.functions())
  176 bool AMDGPUPropagateAttributes::process(Function &F) {
  183   SmallSet<Function *, 32> NewRoots;
  184   SmallSet<Function *, 32> Replaced;
  194     for (auto &F : M.functions()) {
  200       SmallVector<std::pair<CallBase *, Function *>, 32> ToReplace;
  209         Function *Caller = CI->getCaller();
  223         Function *NewF = findFunction(CallerBits, &F);
  256   for (Function *F : Replaced) {
  264 Function *
  265 AMDGPUPropagateAttributes::cloneWithFeatures(Function &F,
  270   Function *NewF = CloneFunction(&F, dummy);
  288 void AMDGPUPropagateAttributes::setFeatures(Function &F,
  314 bool AMDGPUPropagateAttributesEarly::runOnFunction(Function &F) {
lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp
  122   bool runOnFunction(Function &F) override;
  224 bool AMDGPURewriteOutArguments::runOnFunction(Function &F) {
  363   Function *NewFunc = Function::Create(NewFuncTy, Function::PrivateLinkage,
  363   Function *NewFunc = Function::Create(NewFuncTy, Function::PrivateLinkage,
  363   Function *NewFunc = Function::Create(NewFuncTy, Function::PrivateLinkage,
lib/Target/AMDGPU/AMDGPUSubtarget.cpp
  312   const Function &F) const {
  324   const Function &F) const {
  364   const Function &F) const {
  388   const Function &F) const {
  433   Function *Kernel = I->getParent()->getParent();
  440     const Function *F = CI->getCalledFunction();
  494 uint64_t AMDGPUSubtarget::getExplicitKernArgSize(const Function &F,
  515 unsigned AMDGPUSubtarget::getKernArgSegmentSize(const Function &F,
  637   const Function &F = MF.getFunction();
  687   const Function &F = MF.getFunction();
  901 const AMDGPUSubtarget &AMDGPUSubtarget::get(const TargetMachine &TM, const Function &F) {
lib/Target/AMDGPU/AMDGPUSubtarget.h
   87                                     const Function &F);
   99   std::pair<unsigned, unsigned> getFlatWorkGroupSizes(const Function &F) const;
  110   std::pair<unsigned, unsigned> getWavesPerEU(const Function &F) const;
  115                                            const Function &) const;
  119   unsigned getOccupancyWithLocalMemSize(uint32_t Bytes, const Function &) const;
  135   bool isMesaKernel(const Function &F) const {
  139   bool isAmdHsaOrMesa(const Function &F) const {
  205   unsigned getExplicitKernelArgOffset(const Function &F) const {
  236   unsigned getImplicitArgNumBytes(const Function &F) const {
  241   uint64_t getExplicitKernArgSize(const Function &F, Align &MaxAlign) const;
  242   unsigned getKernArgSegmentSize(const Function &F, Align &MaxAlign) const;
  613                                            const Function &) const;
  765   bool isMesaGfxShader(const Function &F) const {
lib/Target/AMDGPU/AMDGPUTargetMachine.cpp
  371 StringRef AMDGPUTargetMachine::getGPUName(const Function &F) const {
  377 StringRef AMDGPUTargetMachine::getFeatureString(const Function &F) const {
  387   if (const Function *F = dyn_cast<Function>(&GV))
  387   if (const Function *F = dyn_cast<Function>(&GV))
  474   const Function &F) const {
  494 R600TargetMachine::getTargetTransformInfo(const Function &F) {
  510 const GCNSubtarget *GCNTargetMachine::getSubtargetImpl(const Function &F) const {
  532 GCNTargetMachine::getTargetTransformInfo(const Function &F) {
lib/Target/AMDGPU/AMDGPUTargetMachine.h
   36   StringRef getGPUName(const Function &F) const;
   37   StringRef getFeatureString(const Function &F) const;
   50   const TargetSubtargetInfo *getSubtargetImpl(const Function &) const override = 0;
   81   const R600Subtarget *getSubtargetImpl(const Function &) const override;
   83   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
  106   const GCNSubtarget *getSubtargetImpl(const Function &) const override;
  108   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
lib/Target/AMDGPU/AMDGPUTargetTransformInfo.cpp
  520   const Function *F = A->getParent();
  625     Function *NewDecl =
  671 bool GCNTTIImpl::areInlineCompatible(const Function *Caller,
  672                                      const Function *Callee) const {
lib/Target/AMDGPU/AMDGPUTargetTransformInfo.h
   56   explicit AMDGPUTTIImpl(const AMDGPUTargetMachine *TM, const Function &F)
  129   explicit GCNTTIImpl(const AMDGPUTargetMachine *TM, const Function &F)
  204   bool areInlineCompatible(const Function *Caller,
  205                            const Function *Callee) const;
  231   explicit R600TTIImpl(const AMDGPUTargetMachine *TM, const Function &F)
lib/Target/AMDGPU/AMDGPUUnifyDivergentExitNodes.cpp
   60   bool runOnFunction(Function &F) override;
  119 static BasicBlock *unifyReturnBlockSet(Function &F,
  160 bool AMDGPUUnifyDivergentExitNodes::runOnFunction(Function &F) {
  237       Function *UnreachableIntrin =
lib/Target/AMDGPU/R600OpenCLImageTypeLoweringPass.cpp
   91 static Function *
  100   auto F = mdconst::dyn_extract<Function>(Node->getOperand(0));
  175       Function *F = Inst->getCalledFunction();
  208       Function *F = Inst->getCalledFunction();
  228   bool replaceImageAndSamplerUses(Function *F, MDNode *KernelMDNode) {
  268   std::tuple<Function *, MDNode *>
  269   addImplicitArgs(Function *F, MDNode *KernelMDNode) {
  306     auto NewF = Function::Create(NewFT, F->getLinkage(), F->getName());
  339       Function *F = GetFunctionFromMDNode(KernelMDNode);
  343       Function *NewF;
lib/Target/AMDGPU/SIAnnotateControlFlow.cpp
   68   Function *If;
   69   Function *Else;
   70   Function *IfBreak;
   71   Function *Loop;
   72   Function *EndCf;
  110   bool runOnFunction(Function &F) override;
  321 bool SIAnnotateControlFlow::runOnFunction(Function &F) {
lib/Target/AMDGPU/SIFrameLowering.cpp
  408   const Function &F = MF.getFunction();
  540   const Function &Fn = MF.getFunction();
lib/Target/AMDGPU/SIISelLowering.cpp
 2024   const Function &Fn = MF.getFunction();
 2438   const Function *CalleeFunc = CLI.CS.getCalledFunction();
 2593   const Function &CallerF = MF.getFunction();
 2659   const Function *ParentFn = CI->getParent()->getParent();
lib/Target/AMDGPU/SILowerSGPRSpills.cpp
  186   const Function &F = MF.getFunction();
lib/Target/AMDGPU/SIMachineFunctionInfo.cpp
   52   const Function &F = MF.getFunction();
lib/Target/AMDGPU/SIMemoryLegalizer.cpp
  446   const Function &Func = MI->getParent()->getParent()->getFunction();
lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.cpp
  561 int getIntegerAttribute(const Function &F, StringRef Name, int Default) {
  576 std::pair<int, int> getIntegerPairAttribute(const Function &F,
  877 unsigned getInitialPSInputAddr(const Function &F) {
 1217   const Function *F = A->getParent();
 1304 SIModeRegisterDefaults::SIModeRegisterDefaults(const Function &F) {
lib/Target/AMDGPU/Utils/AMDGPUBaseInfo.h
  325 int getIntegerAttribute(const Function &F, StringRef Name, int Default);
  336 std::pair<int, int> getIntegerPairAttribute(const Function &F,
  511 unsigned getInitialPSInputAddr(const Function &F);
  668   SIModeRegisterDefaults(const Function &F);
lib/Target/ARC/ARCTargetMachine.cpp
   89 ARCTargetMachine::getTargetTransformInfo(const Function &F) {
lib/Target/ARC/ARCTargetMachine.h
   35   const ARCSubtarget *getSubtargetImpl(const Function &) const override {
   42   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
lib/Target/ARC/ARCTargetTransformInfo.h
   40   explicit ARCTTIImpl(const ARCTargetMachine *TM, const Function &F)
lib/Target/ARM/ARM.h
   53     std::function<bool(const Function &)> Ftor = nullptr);
lib/Target/ARM/ARMAsmPrinter.cpp
  112   const Function &F = MF.getFunction();
lib/Target/ARM/ARMBaseRegisterInfo.cpp
   73   const Function &F = MF->getFunction();
lib/Target/ARM/ARMCallLowering.cpp
  196   const Function &F = MF.getFunction();
  245   const auto &F = MF.getFunction();
  417     MachineIRBuilder &MIRBuilder, const Function &F,
lib/Target/ARM/ARMCallLowering.h
   38   bool lowerFormalArguments(MachineIRBuilder &MIRBuilder, const Function &F,
lib/Target/ARM/ARMCodeGenPrepare.cpp
  175   bool runOnFunction(Function &F) override;
  592     Function *DSPInst =
 1008 bool ARMCodeGenPrepare::runOnFunction(Function &F) {
lib/Target/ARM/ARMFastISel.cpp
 2092   const Function &F = *I->getParent()->getParent();
 3005   const Function *F = FuncInfo.Fn;
lib/Target/ARM/ARMFrameLowering.cpp
  217   const Function &F = MF.getFunction();
  346 static int getMaxFPOffset(const Function &F, const ARMFunctionInfo &AFI) {
lib/Target/ARM/ARMFrameLowering.h
   68   bool isProfitableForNoCSROpt(const Function &F) const override {
lib/Target/ARM/ARMISelLowering.cpp
 2559   const Function &CallerF = MF.getFunction();
 2689   const Function &F = MF.getFunction();
 3298 static bool allUsersAreInFunction(const Value *V, const Function *F) {
 3327   const Function &F = DAG.getMachineFunction().getFunction();
 3420   return isa<Function>(GV);
 3968   Function::const_arg_iterator CurOrigArg = MF.getFunction().arg_begin();
 9131   const Function &F = DAG.getMachineFunction().getFunction();
 9348   const Function &F = MF->getFunction();
16411       Function *MCR = Intrinsic::getDeclaration(M, Intrinsic::arm_mcr);
16422     Function *DMB = Intrinsic::getDeclaration(M, Intrinsic::arm_dmb);
16547   if (Function *F = dyn_cast<Function>(SecurityCheckCookie.getCallee()))
16547   if (Function *F = dyn_cast<Function>(SecurityCheckCookie.getCallee()))
16558 Function *ARMTargetLowering::getSSPStackGuardCheck(const Module &M) const {
16618     Function *Ldrex = Intrinsic::getDeclaration(M, Int);
16635   Function *Ldrex = Intrinsic::getDeclaration(M, Int, Tys);
16662     Function *Strex = Intrinsic::getDeclaration(M, Int);
16675   Function *Strex = Intrinsic::getDeclaration(M, Int, Tys);
16792   Function *VldnFunc =
16951     Function *VstNFunc =
lib/Target/ARM/ARMISelLowering.h
  573     Function *getSSPStackGuardCheck(const Module &M) const override;
lib/Target/ARM/ARMLoadStoreOptimizer.cpp
 2180   const Function &Func = MF->getFunction();
lib/Target/ARM/ARMParallelDSP.cpp
  236     bool MatchSMLAD(Function &F);
  256     bool runOnFunction(Function &F) override {
  513 bool ARMParallelDSP::MatchSMLAD(Function &F) {
  633     Function *SMLAD = nullptr;
lib/Target/ARM/ARMTargetMachine.cpp
  252 ARMBaseTargetMachine::getSubtargetImpl(const Function &F) const {
  299 ARMBaseTargetMachine::getTargetTransformInfo(const Function &F) {
lib/Target/ARM/ARMTargetMachine.h
   48   const ARMSubtarget *getSubtargetImpl(const Function &F) const override;
   55   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
lib/Target/ARM/ARMTargetObjectFile.cpp
   77   if (const Function *F = dyn_cast<Function>(GO))
   77   if (const Function *F = dyn_cast<Function>(GO))
lib/Target/ARM/ARMTargetTransformInfo.cpp
   47 bool ARMTTIImpl::areInlineCompatible(const Function *Caller,
   48                                      const Function *Callee) const {
  531   const Function *F = I->getParent()->getParent();
  787 bool ARMTTIImpl::isLoweredToCall(const Function *F) {
  885         if (const Function *F = Call->getCalledFunction())
 1042         if (const Function *F = CS.getCalledFunction()) {
lib/Target/ARM/ARMTargetTransformInfo.h
   87   explicit ARMTTIImpl(const ARMBaseTargetMachine *TM, const Function &F)
   91   bool areInlineCompatible(const Function *Caller,
   92                            const Function *Callee) const;
  201   bool isLoweredToCall(const Function *F);
lib/Target/ARM/MVETailPredication.cpp
  115   Function &F = *L->getHeader()->getParent();
  493     Function *VCTP = Intrinsic::getDeclaration(M, VCTPID);
lib/Target/ARM/Thumb2SizeReduction.cpp
  166     Thumb2SizeReduce(std::function<bool(const Function &)> Ftor = nullptr);
  234     std::function<bool(const Function &)> PredicateFtor;
  244 Thumb2SizeReduce::Thumb2SizeReduce(std::function<bool(const Function &)> Ftor)
 1149     std::function<bool(const Function &)> Ftor) {
lib/Target/AVR/AVRISelLowering.cpp
  933                                      const Function *F, const DataLayout *TD,
 1009                                     const Function *F, const DataLayout *TD,
 1027                              const Function *F, const DataLayout *TD,
 1171   const Function *F = nullptr;
 1175     F = cast<Function>(GV);
lib/Target/AVR/AVRMCInstLower.cpp
   39   bool IsFunction = MO.isGlobal() && isa<Function>(MO.getGlobal());
lib/Target/AVR/AVRTargetMachine.cpp
   92 const AVRSubtarget *AVRTargetMachine::getSubtargetImpl(const Function &) const {
lib/Target/AVR/AVRTargetMachine.h
   37   const AVRSubtarget *getSubtargetImpl(const Function &) const override;
lib/Target/BPF/BPFAbstractMemberAccess.cpp
  148   void collectAICallChains(Module &M, Function &F);
  308   for (Function &F : M)
  489 void BPFAbstractMemberAccess::collectAICallChains(Module &M, Function &F) {
  913   for (Function &F : M) {
lib/Target/BPF/BPFRegisterInfo.cpp
   47       const Function &F = MF.getFunction();
lib/Target/BPF/BPFTargetMachine.h
   31   const BPFSubtarget *getSubtargetImpl(const Function &) const override {
lib/Target/Hexagon/HexagonCommonGEP.cpp
  104     bool runOnFunction(Function &F) override;
  158     Function *Fn;
 1271 bool HexagonCommonGEP::runOnFunction(Function &F) {
 1276   for (Function::iterator A = F.begin(), Z = F.end(); A != Z; ++A)
lib/Target/Hexagon/HexagonConstExtenders.cpp
  744       const Function &F = *ThisB->getParent();
lib/Target/Hexagon/HexagonConstPropagation.cpp
 1893       const Function &F = MF.getFunction();
lib/Target/Hexagon/HexagonCopyToCombine.cpp
  473   const Function &F = MF.getFunction();
lib/Target/Hexagon/HexagonFrameLowering.cpp
  382     const Function &F = MF.getFunction();
  556   const auto &F = MF.getFunction();
  572   const auto &F = MF.getFunction();
lib/Target/Hexagon/HexagonGenExtract.cpp
   68     bool runOnFunction(Function &F) override;
  213   Function *ExtF = Intrinsic::getDeclaration(Mod, IntId);
  250 bool HexagonGenExtract::runOnFunction(Function &F) {
  259   BasicBlock *Entry = GraphTraits<Function*>::getEntryNode(&F);
lib/Target/Hexagon/HexagonISelDAGToDAG.cpp
 1860   const Function &CurF = CurDAG->getMachineFunction().getFunction();
lib/Target/Hexagon/HexagonISelLowering.cpp
 3124   const Function &CallerF = DAG.getMachineFunction().getFunction();
 3249   Function *Fn = Intrinsic::getDeclaration(M, IntID);
 3273   Function *Fn = Intrinsic::getDeclaration(M, IntID);
lib/Target/Hexagon/HexagonISelLowering.h
  103     bool CanReturnSmallStruct(const Function* CalleeFn, unsigned& RetSize)
lib/Target/Hexagon/HexagonLoopIdiomRecognition.cpp
 1526   Function *PMF = Intrinsic::getDeclaration(M, Intrinsic::hexagon_M4_pmpyw);
 2090     Function *Func = CurLoop->getHeader()->getParent();
 2170     Function *Func = Header->getParent();
lib/Target/Hexagon/HexagonOptimizeSZextends.cpp
   37     bool runOnFunction(Function &F) override;
   65 bool HexagonOptimizeSZextends::runOnFunction(Function &F) {
lib/Target/Hexagon/HexagonTargetMachine.cpp
  227 HexagonTargetMachine::getSubtargetImpl(const Function &F) const {
  266 HexagonTargetMachine::getTargetTransformInfo(const Function &F) {
lib/Target/Hexagon/HexagonTargetMachine.h
   35   const HexagonSubtarget *getSubtargetImpl(const Function &F) const override;
   41   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
lib/Target/Hexagon/HexagonTargetObjectFile.cpp
  145     if (const Function *Fn = getLutUsedFunction(GO))
  282     bool UsesLabelDifference, const Function &F) const {
  427 const Function *
  429   const Function *ReturnFn = nullptr;
  448     const GlobalObject *GO, const TargetMachine &TM, const Function *Fn) const {
lib/Target/Hexagon/HexagonTargetObjectFile.h
   36                                              const Function &F) const override;
   38     const Function *getLutUsedFunction(const GlobalObject *GO) const;
   53                                            const Function *Fn) const;
lib/Target/Hexagon/HexagonTargetTransformInfo.cpp
  128 unsigned HexagonTTIImpl::getCallInstrCost(Function *F, Type *RetTy,
lib/Target/Hexagon/HexagonTargetTransformInfo.h
   54   explicit HexagonTTIImpl(const HexagonTargetMachine *TM, const Function &F)
  107   unsigned getCallInstrCost(Function *F, Type *RetTy, ArrayRef<Type*> Tys);
lib/Target/Hexagon/RDFGraph.cpp
  750   const Function &F = MF.getFunction();
lib/Target/Lanai/LanaiISelLowering.cpp
  611     const Function *CalleeFn = dyn_cast<Function>(G->getGlobal());
  611     const Function *CalleeFn = dyn_cast<Function>(G->getGlobal());
lib/Target/Lanai/LanaiTargetMachine.cpp
   73 LanaiTargetMachine::getTargetTransformInfo(const Function &F) {
lib/Target/Lanai/LanaiTargetMachine.h
   40   getSubtargetImpl(const llvm::Function & /*Fn*/) const override {
   44   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
lib/Target/Lanai/LanaiTargetTransformInfo.h
   40   explicit LanaiTTIImpl(const LanaiTargetMachine *TM, const Function &F)
lib/Target/MSP430/MSP430AsmPrinter.cpp
  161   const auto *F = &ISR.getFunction();
lib/Target/MSP430/MSP430RegisterInfo.cpp
   40   const Function* F = &MF->getFunction();
lib/Target/MSP430/MSP430TargetMachine.h
   36   const MSP430Subtarget *getSubtargetImpl(const Function &F) const override {
lib/Target/Mips/Mips16HardFloat.cpp
  106 static FPParamVariant whichFPParamVariantNeeded(Function &F) {
  156 static bool needsFPStubFromParams(Function &F) {
  170 static bool needsFPReturnHelper(Function &F) {
  180 static bool needsFPHelperFromSig(Function &F) {
  256 static void assureFPCallStub(Function &F, Module *M,
  269   Function *FStub = M->getFunction(StubName);
  271   FStub = Function::Create(F.getFunctionType(),
  272                            Function::InternalLinkage, StubName, M);
  370 static bool isIntrinsicInline(Function *F) {
  377 static bool fixupFPReturnAndCall(Function &F, Module *M,
  421         Function *F_ =  CI->getCalledFunction();
  446 static void createFPFnStub(Function *F, Module *M, FPParamVariant PV,
  455   Function *FStub = Function::Create
  455   Function *FStub = Function::Create
  457      Function::InternalLinkage, StubName, M);
  484 static void removeUseSoftFloat(Function &F) {
lib/Target/Mips/MipsCCState.cpp
   77       Function *F = G->getGlobal()->getParent()->getFunction(Sym);
  151     Function::const_arg_iterator FuncArg = MF.getFunction().arg_begin();
lib/Target/Mips/MipsCallLowering.cpp
   59   const Function &F = MIRBuilder.getMF().getFunction();
  424     const Function &F = MF.getFunction();
  454     MachineIRBuilder &MIRBuilder, const Function &F,
  556   const Function &F = MF.getFunction();
  608     const Function *CF = static_cast<const Function *>(Info.Callee.getGlobal());
  673     const Function &F, ArrayRef<ArgInfo> Args,
lib/Target/Mips/MipsCallLowering.h
   68   bool lowerFormalArguments(MachineIRBuilder &MIRBuilder, const Function &F,
   79   void subTargetRegTypeForCallingConv(const Function &F, ArrayRef<ArgInfo> Args,
lib/Target/Mips/MipsFastISel.cpp
  426        (GV->hasLocalLinkage() && !isa<Function>(GV)))) {
 1322   const Function *F = FuncInfo.Fn;
 1682   const Function &F = *I->getParent()->getParent();
lib/Target/Mips/MipsISelLowering.cpp
 2953       Function *F = G->getGlobal()->getParent()->getFunction(Sym);
 3251       if (auto *F = dyn_cast<Function>(N->getGlobal())) {
 3482   const Function &Func = DAG.getMachineFunction().getFunction();
 3483   Function::const_arg_iterator FuncArg = Func.arg_begin();
lib/Target/Mips/MipsOs16.cpp
   49 static  bool needsFPFromSig(Function &F) {
   73 static bool needsFP(Function &F) {
   76   for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB)
  100         Function &F_ =  *CI->getCalledFunction();
  121   for (auto &F : M) {
lib/Target/Mips/MipsRegisterInfo.cpp
   95   const Function &F = MF->getFunction();
lib/Target/Mips/MipsSEFrameLowering.cpp
  816     const Function &Func = MBB.getParent()->getFunction();
lib/Target/Mips/MipsSEInstrInfo.cpp
  301   const Function &Func = MBB.getParent()->getFunction();
  332   const Function &Func = MBB.getParent()->getFunction();
lib/Target/Mips/MipsTargetMachine.cpp
  158 MipsTargetMachine::getSubtargetImpl(const Function &F) const {
  282 MipsTargetMachine::getTargetTransformInfo(const Function &F) {
lib/Target/Mips/MipsTargetMachine.h
   46   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
   54   const MipsSubtarget *getSubtargetImpl(const Function &F) const override;
lib/Target/NVPTX/NVPTXAllocaHoisting.cpp
   36   bool runOnFunction(Function &function) override;
   40 bool NVPTXAllocaHoisting::runOnFunction(Function &function) {
   42   Function::iterator I = function.begin();
   45   for (Function::iterator E = function.end(); I != E; ++I) {
lib/Target/NVPTX/NVPTXAsmPrinter.cpp
  331 void NVPTXAsmPrinter::printReturnValStr(const Function *F, raw_ostream &O) {
  403   const Function &F = MF.getFunction();
  522 void NVPTXAsmPrinter::emitKernelFunctionDirectives(const Function &F,
  603 void NVPTXAsmPrinter::emitDeclaration(const Function *F, raw_ostream &O) {
  632 static bool usedInOneFunc(const User *U, Function const *&oneFunc) {
  640       const Function *curFunc = instr->getParent()->getParent();
  663 static bool canDemoteGlobalVar(const GlobalVariable *gv, Function const *&f) {
  670   const Function *oneFunc = nullptr;
  682                         DenseMap<const Function *, bool> &seenMap) {
  691       const Function *caller = bb->getParent();
  702   DenseMap<const Function *, bool> seenMap;
  704     const Function *F = &*FI;
  742       const Function *caller = bb->getParent();
 1117   const Function *demotedFunc = nullptr;
 1247 void NVPTXAsmPrinter::emitDemotedVars(const Function *f, raw_ostream &O) {
 1404 void NVPTXAsmPrinter::printParamName(Function::const_arg_iterator I,
 1410 void NVPTXAsmPrinter::emitFunctionParamList(const Function *F, raw_ostream &O) {
 1415   Function::const_arg_iterator I, E;
 1619   const Function &F = MF.getFunction();
 1729     if (EmitGeneric && !isa<Function>(CPV) && !IsNonGenericPointer) {
 1746       if (EmitGeneric && !isa<Function>(v) && !IsNonGenericPointer) {
lib/Target/NVPTX/NVPTXAsmPrinter.h
  168               if (EmitGeneric && !isa<Function>(v) && !IsNonGenericPointer) {
  200   const Function *F;
  219   void printParamName(Function::const_arg_iterator I, int paramIndex,
  223   void emitKernelFunctionDirectives(const Function &F, raw_ostream &O) const;
  225   void emitFunctionParamList(const Function *, raw_ostream &O);
  228   void printReturnValStr(const Function *, raw_ostream &O);
  256   std::map<const Function *, std::vector<const GlobalVariable *>> localDecls;
  268   void emitDeclaration(const Function *, raw_ostream &O);
  269   void emitDemotedVars(const Function *, raw_ostream &);
lib/Target/NVPTX/NVPTXAssignValidGlobalNames.cpp
   65   for (Function &F : M.functions())
lib/Target/NVPTX/NVPTXGenericToNVVM.cpp
   47   Value *remapConstant(Module *M, Function *F, Constant *C,
   49   Value *remapConstantVectorOrConstantAggregate(Module *M, Function *F,
   52   Value *remapConstantExpr(Module *M, Function *F, ConstantExpr *C,
  107     for (Function::iterator BBI = I->begin(), BBE = I->end(); BBI != BBE;
  156 Value *GenericToNVVM::remapConstant(Module *M, Function *F, Constant *C,
  196     Module *M, Function *F, Constant *C, IRBuilder<> &Builder) {
  234 Value *GenericToNVVM::remapConstantExpr(Module *M, Function *F, ConstantExpr *C,
lib/Target/NVPTX/NVPTXISelLowering.cpp
  124     const Function &F = MF.getFunction();
 1406       if (isa<Function>(CalleeV))
 1414     if (getAlign(*cast<Function>(DirectCallee), Idx, Align))
 1677     Function* CalleeFunc = nullptr;
 2470   const Function *F = &MF.getFunction();
 4327   const Function &F = MF.getFunction();
lib/Target/NVPTX/NVPTXImageOptimizer.cpp
   35   bool runOnFunction(Function &F) override;
   51 bool NVPTXImageOptimizer::runOnFunction(Function &F) {
   59   for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE;
   65         Function *CalledF = CI->getCalledFunction();
lib/Target/NVPTX/NVPTXLowerAggrCopies.cpp
   48   bool runOnFunction(Function &F) override;
   59 bool NVPTXLowerAggrCopies::runOnFunction(Function &F) {
   69   for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI) {
lib/Target/NVPTX/NVPTXLowerAlloca.cpp
   45   bool runOnFunction(Function &F) override;
   64 bool NVPTXLowerAlloca::runOnFunction(Function &F) {
lib/Target/NVPTX/NVPTXLowerArgs.cpp
  110   bool runOnFunction(Function &F) override;
  112   bool runOnKernelFunction(Function &F);
  113   bool runOnDeviceFunction(Function &F);
  155   Function *Func = Arg->getParent();
  208 bool NVPTXLowerArgs::runOnKernelFunction(Function &F) {
  241 bool NVPTXLowerArgs::runOnDeviceFunction(Function &F) {
  248 bool NVPTXLowerArgs::runOnFunction(Function &F) {
lib/Target/NVPTX/NVPTXTargetMachine.cpp
  209 NVPTXTargetMachine::getTargetTransformInfo(const Function &F) {
lib/Target/NVPTX/NVPTXTargetMachine.h
   44   const NVPTXSubtarget *getSubtargetImpl(const Function &) const override {
   68   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
lib/Target/NVPTX/NVPTXTargetTransformInfo.h
   39   explicit NVPTXTTIImpl(const NVPTXTargetMachine *TM, const Function &F)
   79   bool areInlineCompatible(const Function *Caller,
   80                            const Function *Callee) const {
lib/Target/NVPTX/NVPTXUtilities.cpp
  166     const Function *func = arg->getParent();
  178     const Function *func = arg->getParent();
  190     const Function *func = arg->getParent();
  202     const Function *func = arg->getParent();
  242 bool getMaxNTIDx(const Function &F, unsigned &x) {
  246 bool getMaxNTIDy(const Function &F, unsigned &y) {
  250 bool getMaxNTIDz(const Function &F, unsigned &z) {
  254 bool getReqNTIDx(const Function &F, unsigned &x) {
  258 bool getReqNTIDy(const Function &F, unsigned &y) {
  262 bool getReqNTIDz(const Function &F, unsigned &z) {
  266 bool getMinCTASm(const Function &F, unsigned &x) {
  270 bool getMaxNReg(const Function &F, unsigned &x) {
  274 bool isKernelFunction(const Function &F) {
  284 bool getAlign(const Function &F, unsigned index, unsigned &align) {
lib/Target/NVPTX/NVPTXUtilities.h
   47 bool getMaxNTIDx(const Function &, unsigned &);
   48 bool getMaxNTIDy(const Function &, unsigned &);
   49 bool getMaxNTIDz(const Function &, unsigned &);
   51 bool getReqNTIDx(const Function &, unsigned &);
   52 bool getReqNTIDy(const Function &, unsigned &);
   53 bool getReqNTIDz(const Function &, unsigned &);
   55 bool getMinCTASm(const Function &, unsigned &);
   56 bool getMaxNReg(const Function &, unsigned &);
   57 bool isKernelFunction(const Function &);
   59 bool getAlign(const Function &, unsigned index, unsigned &);
lib/Target/NVPTX/NVVMIntrRange.cpp
   52    bool runOnFunction(Function &) override;
   80 bool NVVMIntrRange::runOnFunction(Function &F) {
   88     if (Function *Callee = Call->getCalledFunction()) {
lib/Target/NVPTX/NVVMReflect.cpp
   58   bool runOnFunction(Function &) override;
   75 bool NVVMReflect::runOnFunction(Function &F) {
  118     Function *Callee = Call->getCalledFunction();
lib/Target/PowerPC/PPCAsmPrinter.cpp
 1612   for (const Function &F : M) {
 1666       for (const Function *Personality : MMI->getPersonalities()) {
lib/Target/PowerPC/PPCBoolRetToInt.cpp
  187   bool runOnFunction(Function &F) override {
lib/Target/PowerPC/PPCFastISel.cpp
 1695   const Function &F = *I->getParent()->getParent();
lib/Target/PowerPC/PPCISelLowering.cpp
 3756   Function::const_arg_iterator FuncArg = MF.getFunction().arg_begin();
 4200   Function::const_arg_iterator FuncArg = MF.getFunction().arg_begin();
 4482 callsShareTOCBase(const Function *Caller, SDValue Callee,
 4514   if (const auto *F = dyn_cast<Function>(GV)) {
 4514   if (const auto *F = dyn_cast<Function>(GV)) {
 4581 hasSameArgumentList(const Function *CallerFn, ImmutableCallSite CS) {
 4587   Function::const_arg_iterator CallerArgIter = CallerFn->arg_begin();
10262   Function *Func = Intrinsic::getDeclaration(M, Id);
15415   const Function *Caller = CI->getParent()->getParent();
15427   const Function *Callee = CI->getCalledFunction();
lib/Target/PowerPC/PPCInstrInfo.cpp
 4036             const Function *CalleeFn =
 4037               dyn_cast<Function>(CallMI.getOperand(0).getGlobal());
lib/Target/PowerPC/PPCLoopPreIncPrep.cpp
  104     bool runOnFunction(Function &F) override;
  196 bool PPCLoopPreIncPrep::runOnFunction(Function &F) {
lib/Target/PowerPC/PPCTargetMachine.cpp
  312 PPCTargetMachine::getSubtargetImpl(const Function &F) const {
  529 PPCTargetMachine::getTargetTransformInfo(const Function &F) {
lib/Target/PowerPC/PPCTargetMachine.h
   42   const PPCSubtarget *getSubtargetImpl(const Function &F) const override;
   51   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
lib/Target/PowerPC/PPCTargetTransformInfo.cpp
  273       if (Function *F = CI->getCalledFunction()) {
  574 bool PPCTTIImpl::useColdCCForColdCall(Function &F) {
lib/Target/PowerPC/PPCTargetTransformInfo.h
   39   explicit PPCTTIImpl(const PPCTargetMachine *TM, const Function &F)
   70   bool useColdCCForColdCall(Function &F);
lib/Target/RISCV/RISCVCallLowering.cpp
   38     MachineIRBuilder &MIRBuilder, const Function &F,
lib/Target/RISCV/RISCVCallLowering.h
   33   bool lowerFormalArguments(MachineIRBuilder &MIRBuilder, const Function &F,
lib/Target/RISCV/RISCVISelLowering.cpp
 1880   const Function &Func = MF.getFunction();
 2452   const Function &Func = DAG.getMachineFunction().getFunction();
 2479   const Function &F = MF.getFunction();
 2811   Function *LrwOpScwLoop = Intrinsic::getDeclaration(
 2869   Function *MaskedCmpXchg =
lib/Target/RISCV/RISCVTargetMachine.cpp
   72 RISCVTargetMachine::getTargetTransformInfo(const Function &F) {
lib/Target/RISCV/RISCVTargetMachine.h
   33   const RISCVSubtarget *getSubtargetImpl(const Function &) const override {
   43   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
lib/Target/RISCV/RISCVTargetTransformInfo.h
   40   explicit RISCVTTIImpl(const RISCVTargetMachine *TM, const Function &F)
lib/Target/Sparc/SparcISelLowering.cpp
  699   const Function *CalleeFn = nullptr;
  701     CalleeFn = dyn_cast<Function>(G->getGlobal());
  704     const Function &Fn = DAG.getMachineFunction().getFunction();
lib/Target/Sparc/SparcTargetMachine.cpp
  109 SparcTargetMachine::getSubtargetImpl(const Function &F) const {
lib/Target/Sparc/SparcTargetMachine.h
   35   const SparcSubtarget *getSubtargetImpl(const Function &) const override;
lib/Target/SystemZ/SystemZISelDAGToDAG.cpp
  349     const Function &F = MF.getFunction();
lib/Target/SystemZ/SystemZTDC.cpp
   73   bool runOnFunction(Function &F) override;
  216     Function *F = CI->getCalledFunction();
  260     Function *F = CI->getCalledFunction();
  311 bool SystemZTDCPass::runOnFunction(Function &F) {
  358       Function *TDCFunc =
lib/Target/SystemZ/SystemZTargetMachine.cpp
  279 SystemZTargetMachine::getTargetTransformInfo(const Function &F) {
lib/Target/SystemZ/SystemZTargetMachine.h
   40   const SystemZSubtarget *getSubtargetImpl(const Function &) const override {
   46   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
lib/Target/SystemZ/SystemZTargetTransformInfo.cpp
  250         if (const Function *F = CS.getCalledFunction()) {
  991       if (auto *F = CI->getCalledFunction())
lib/Target/SystemZ/SystemZTargetTransformInfo.h
   32   explicit SystemZTTIImpl(const SystemZTargetMachine *TM, const Function &F)
lib/Target/TargetIntrinsicInfo.cpp
   24 unsigned TargetIntrinsicInfo::getIntrinsicID(const Function *F) const {
lib/Target/TargetLoweringObjectFile.cpp
  149   if (isa<Function>(GO))
  262   if (auto *F = dyn_cast<Function>(GO)) {
  272     const Function &F, const TargetMachine &TM) const {
  280     bool UsesLabelDifference, const Function &F) const {
lib/Target/TargetMachine.cpp
   53 void TargetMachine::resetTargetOptions(const Function &F) const {
  184     const Function *F = dyn_cast_or_null<Function>(GV);
  184     const Function *F = dyn_cast_or_null<Function>(GV);
  243 TargetTransformInfo TargetMachine::getTargetTransformInfo(const Function &F) {
lib/Target/WebAssembly/WebAssemblyAddMissingPrototypes.cpp
   64   std::vector<std::pair<Function *, Function *>> Replacements;
   64   std::vector<std::pair<Function *, Function *>> Replacements;
   67   for (Function &F : M) {
  125     Function *NewF =
  126         Function::Create(NewType, F.getLinkage(), F.getName() + ".fixed_sig");
  133     Function *OldF = Pair.first;
  134     Function *NewF = Pair.second;
lib/Target/WebAssembly/WebAssemblyAsmPrinter.cpp
   98   for (const auto &F : M) {
  280   const Function &F = MF->getFunction();
lib/Target/WebAssembly/WebAssemblyFastISel.cpp
  639   const Function *F = FuncInfo.Fn;
  753   Function *Func = Call->getCalledFunction();
lib/Target/WebAssembly/WebAssemblyFixFunctionBitcasts.cpp
   67 static void findUses(Value *V, Function &F,
   68                      SmallVectorImpl<std::pair<Use *, Function *>> &Uses,
  118 static Function *createWrapper(Function *F, FunctionType *Ty) {
  118 static Function *createWrapper(Function *F, FunctionType *Ty) {
  121   Function *Wrapper = Function::Create(Ty, Function::PrivateLinkage,
  121   Function *Wrapper = Function::Create(Ty, Function::PrivateLinkage,
  121   Function *Wrapper = Function::Create(Ty, Function::PrivateLinkage,
  128   Function::arg_iterator AI = Wrapper->arg_begin();
  129   Function::arg_iterator AE = Wrapper->arg_end();
  211     Wrapper = Function::Create(Ty, Function::PrivateLinkage,
  211     Wrapper = Function::Create(Ty, Function::PrivateLinkage,
  240   Function *Main = nullptr;
  242   SmallVector<std::pair<Use *, Function *>, 0> Uses;
  246   for (Function &F : M) {
  274   DenseMap<std::pair<Function *, FunctionType *>, Function *> Wrappers;
  274   DenseMap<std::pair<Function *, FunctionType *>, Function *> Wrappers;
  278     Function *F = UseFunc.second;
  292     Function *Wrapper = Pair.first->second;
  306     auto *MainWrapper =
  307         cast<Function>(CallMain->getCalledValue()->stripPointerCasts());
lib/Target/WebAssembly/WebAssemblyISelLowering.cpp
  660       const Function &F = MF.getFunction();
lib/Target/WebAssembly/WebAssemblyLateEHPrepare.cpp
  339       Function *ClangCallTerminateFn =
lib/Target/WebAssembly/WebAssemblyLowerEmscriptenEHSjLj.cpp
  235   Function *GetTempRet0Func = nullptr;
  236   Function *SetTempRet0Func = nullptr;
  237   Function *ResumeF = nullptr;
  238   Function *EHTypeIDF = nullptr;
  239   Function *EmLongjmpF = nullptr;
  240   Function *EmLongjmpJmpbufF = nullptr;
  241   Function *SaveSetjmpF = nullptr;
  242   Function *TestSetjmpF = nullptr;
  246   DenseMap<int, Function *> FindMatchingCatches;
  248   StringMap<Function *> InvokeWrappers;
  256   bool runEHOnFunction(Function &F);
  257   bool runSjLjOnFunction(Function &F);
  258   Function *getFindMatchingCatch(Module &M, unsigned NumClauses);
  264   template <typename CallOrInvoke> Function *getInvokeWrapper(CallOrInvoke *CI);
  270   void rebuildSSA(Function &F);
  298   if (const auto *F = dyn_cast<const Function>(V)) {
  298   if (const auto *F = dyn_cast<const Function>(V)) {
  351 Function *
  359   Function *F = Function::Create(
  359   Function *F = Function::Create(
  381     if (auto *F = dyn_cast<Function>(CI->getCalledValue()))
  381     if (auto *F = dyn_cast<Function>(CI->getCalledValue()))
  446 Function *WebAssemblyLowerEmscriptenEHSjLj::getInvokeWrapper(CallOrInvoke *CI) {
  451   if (auto *F = dyn_cast<Function>(Callee))
  451   if (auto *F = dyn_cast<Function>(Callee))
  469   Function *F =
  470       Function::Create(FTy, GlobalValue::ExternalLinkage, "__invoke_" + Sig, M);
  477   if (auto *CalleeF = dyn_cast<Function>(Callee))
  543   Function *F = BB->getParent();
  600 void WebAssemblyLowerEmscriptenEHSjLj::rebuildSSA(Function &F) {
  630   Function *SetjmpF = M.getFunction("setjmp");
  631   Function *LongjmpF = M.getFunction("longjmp");
  642       Function::Create(FunctionType::get(IRB.getInt32Ty(), false),
  644   SetTempRet0Func = Function::Create(
  657     ResumeF = Function::Create(ResumeFTy, GlobalValue::ExternalLinkage,
  663     EHTypeIDF = Function::Create(EHTypeIDTy, GlobalValue::ExternalLinkage,
  666     for (Function &F : M) {
  680       EmLongjmpJmpbufF = Function::Create(LongjmpF->getFunctionType(),
  696           Function::Create(FTy, GlobalValue::ExternalLinkage, "saveSetjmp", &M);
  702           Function::Create(FTy, GlobalValue::ExternalLinkage, "testSetjmp", &M);
  706       EmLongjmpF = Function::Create(FTy, GlobalValue::ExternalLinkage,
  711       SmallPtrSet<Function *, 8> SetjmpUsers;
  716       for (Function *F : SetjmpUsers)
  739 bool WebAssemblyLowerEmscriptenEHSjLj::runEHOnFunction(Function &F) {
  813       const Function *Callee = CI->getCalledFunction();
  855     Function *FMCF = getFindMatchingCatch(M, FMCArgs.size());
  873 bool WebAssemblyLowerEmscriptenEHSjLj::runSjLjOnFunction(Function &F) {
  905   Function *SetjmpF = M.getFunction("setjmp");
lib/Target/WebAssembly/WebAssemblyLowerGlobalDtors.cpp
  137       Function *CallDtors = Function::Create(
  137       Function *CallDtors = Function::Create(
  138           AtExitFuncTy, Function::PrivateLinkage,
  153       Function *RegisterCallDtors = Function::Create(
  153       Function *RegisterCallDtors = Function::Create(
  154           VoidVoid, Function::PrivateLinkage,
lib/Target/WebAssembly/WebAssemblyMCInstLower.cpp
   55     const Function &CurrentFunc = MF.getFunction();
  198   const Function &F = MI->getMF()->getFunction();
lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.cpp
   29 void llvm::computeLegalValueVTs(const Function &F, const TargetMachine &TM,
   45 void llvm::computeSignatureVTs(const FunctionType *Ty, const Function &F,
lib/Target/WebAssembly/WebAssemblyMachineFunctionInfo.h
  139 void computeLegalValueVTs(const Function &F, const TargetMachine &TM, Type *Ty,
  144 void computeSignatureVTs(const FunctionType *Ty, const Function &F,
lib/Target/WebAssembly/WebAssemblyOptimizeReturned.cpp
   37   bool runOnFunction(Function &F) override;
   72 bool OptimizeReturned::runOnFunction(Function &F) {
lib/Target/WebAssembly/WebAssemblyRegStackify.cpp
  150     if (const auto *F = dyn_cast<Function>(GV)) {
  150     if (const auto *F = dyn_cast<Function>(GV)) {
lib/Target/WebAssembly/WebAssemblyTargetMachine.cpp
  149 WebAssemblyTargetMachine::getSubtargetImpl(const Function &F) const {
  186     for (auto &F : M)
  230   void replaceFeatures(Function &F, const std::string &Features) {
  240     for (auto &F : M) {
  257     for (auto &F : M)
  323 WebAssemblyTargetMachine::getTargetTransformInfo(const Function &F) {
lib/Target/WebAssembly/WebAssemblyTargetMachine.h
   39   getSubtargetImpl(const Function &F) const override;
   48   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
lib/Target/WebAssembly/WebAssemblyTargetTransformInfo.h
   40   WebAssemblyTTIImpl(const WebAssemblyTargetMachine *TM, const Function &F)
lib/Target/WebAssembly/WebAssemblyUtilities.cpp
   68   const auto *F = dyn_cast<Function>(MO.getGlobal());
   68   const auto *F = dyn_cast<Function>(MO.getGlobal());
lib/Target/X86/X86CallLowering.cpp
  196     const Function &F = MF.getFunction();
  328     MachineIRBuilder &MIRBuilder, const Function &F,
  381   const Function &F = MF.getFunction();
lib/Target/X86/X86CallLowering.h
   34   bool lowerFormalArguments(MachineIRBuilder &MIRBuilder, const Function &F,
lib/Target/X86/X86FastISel.cpp
  248   const Function *Callee = II->getCalledFunction();
 1146   const Function &F = *I->getParent()->getParent();
 2866     const Function *Callee = II->getCalledFunction();
 3061   const Function *F = FuncInfo.Fn;
 3190   const Function *CalledFn = CI ? CI->getCalledFunction() : nullptr;
lib/Target/X86/X86FrameLowering.cpp
  880   const Function &Fn = MF.getFunction();
  977   const Function &Fn = MF.getFunction();
 2181       const Function &F = MBB.getParent()->getFunction();
 2237   const Function &F = MF->getFunction();
 2238   for (Function::const_arg_iterator I = F.arg_begin(), E = F.arg_end();
 2630         const Function *F = dyn_cast<Function>(MO.getGlobal());
 2630         const Function *F = dyn_cast<Function>(MO.getGlobal());
 2816     const Function &F = MF.getFunction();
 3178   const Function &F = MF.getFunction();
lib/Target/X86/X86ISelDAGToDAG.cpp
 1330   const Function &F = MF->getFunction();
lib/Target/X86/X86ISelLowering.cpp
 2329     if (Function *F = dyn_cast<Function>(SecurityCheckCookie.getCallee())) {
 2329     if (Function *F = dyn_cast<Function>(SecurityCheckCookie.getCallee())) {
 2350 Function *X86TargetLowering::getSSPStackGuardCheck(const Module &M) const {
 3147   const Function &F = MF.getFunction();
 3181   const Function &F = MF.getFunction();
 3623   const Function *Fn = CI ? CI->getCalledFunction() : nullptr;
 4049     const Function &CallerFn = MF.getFunction();
 4312   const Function &CallerF = MF.getFunction();
22236       const Function &F = MF.getFunction();
22676 static int getSEHRegistrationNodeSize(const Function *Fn) {
22699 static SDValue recoverFramePointer(SelectionDAG &DAG, const Function *Fn,
23553     auto *Fn = cast<Function>(cast<GlobalAddressSDNode>(Op1)->getGlobal());
23567     auto *Fn = dyn_cast_or_null<Function>(GSD ? GSD->getGlobal() : nullptr);
24434     const Function *Func =
24435       cast<Function>(cast<SrcValueSDNode>(Op.getOperand(5))->getValue());
26575   Function *MFence =
29161 bool X86TargetLowering::areJTsAllowed(const Function *Fn) const {
40662   const Function &F = DAG.getMachineFunction().getFunction();
46243   const Function &Fn = MF.getFunction();
lib/Target/X86/X86ISelLowering.h
 1092     bool areJTsAllowed(const Function *Fn) const override;
 1196     Function *getSSPStackGuardCheck(const Module &M) const override;
lib/Target/X86/X86IndirectBranchTracking.cpp
   90   auto *CalleeFn = dyn_cast<Function>(MOp.getGlobal());
lib/Target/X86/X86InstrInfo.cpp
 8024   const Function &F = MF.getFunction();
lib/Target/X86/X86RegisterInfo.cpp
  236   const Function &F = MF.getFunction();
  284   const Function &F = MF->getFunction();
  499     const Function &F = MF.getFunction();
lib/Target/X86/X86RetpolineThunks.cpp
  201   Function *F =
  202       Function::Create(Type, GlobalValue::LinkOnceODRLinkage, Name, &M);
lib/Target/X86/X86Subtarget.cpp
   92         if (isa<Function>(GV))
  191   const Function *F = dyn_cast_or_null<Function>(GV);
  191   const Function *F = dyn_cast_or_null<Function>(GV);
lib/Target/X86/X86TargetMachine.cpp
  243 X86TargetMachine::getSubtargetImpl(const Function &F) const {
  332 X86TargetMachine::getTargetTransformInfo(const Function &F) {
lib/Target/X86/X86TargetMachine.h
   41   const X86Subtarget *getSubtargetImpl(const Function &F) const override;
   47   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
lib/Target/X86/X86TargetTransformInfo.cpp
 3406 bool X86TTIImpl::areInlineCompatible(const Function *Caller,
 3407                                      const Function *Callee) const {
 3422     const Function *Caller, const Function *Callee,
 3422     const Function *Caller, const Function *Callee,
lib/Target/X86/X86TargetTransformInfo.h
   99   explicit X86TTIImpl(const X86TargetMachine *TM, const Function &F)
  199   bool areInlineCompatible(const Function *Caller,
  200                            const Function *Callee) const;
  201   bool areFunctionArgsABICompatible(const Function *Caller,
  202                                     const Function *Callee,
lib/Target/X86/X86WinEHState.cpp
   45   bool runOnFunction(Function &Fn) override;
   58   void emitExceptionRegistrationRecord(Function *F);
   60   void linkExceptionRegistration(IRBuilder<> &Builder, Function *Handler);
   62   void addStateStores(Function &F, WinEHFuncInfo &FuncInfo);
   65   Value *emitEHLSDA(IRBuilder<> &Builder, Function *F);
   67   Function *generateLSDAInEAXThunk(Function *ParentFunc);
   67   Function *generateLSDAInEAXThunk(Function *ParentFunc);
   70   void rewriteSetJmpCallSite(IRBuilder<> &Builder, Function &F, CallSite CS,
   92   Function *PersonalityFn = nullptr;
  144 bool WinEHStatePass::runOnFunction(Function &F) {
  155       dyn_cast<Function>(F.getPersonalityFn()->stripPointerCasts());
  273 void WinEHStatePass::emitExceptionRegistrationRecord(Function *F) {
  297     Function *Trampoline = generateLSDAInEAXThunk(F);
  304     cast<Function>(CxxLongjmpUnwind.getCallee()->stripPointerCasts())
  360     cast<Function>(SehLongjmpUnwind.getCallee()->stripPointerCasts())
  376 Value *WinEHStatePass::emitEHLSDA(IRBuilder<> &Builder, Function *F) {
  389 Function *WinEHStatePass::generateLSDAInEAXThunk(Function *ParentFunc) {
  389 Function *WinEHStatePass::generateLSDAInEAXThunk(Function *ParentFunc) {
  401   Function *Trampoline =
  402       Function::Create(TrampolineTy, GlobalValue::InternalLinkage,
  425                                                Function *Handler) {
  462 void WinEHStatePass::rewriteSetJmpCallSite(IRBuilder<> &Builder, Function &F,
  549 static int getPredState(DenseMap<BasicBlock *, int> &FinalStates, Function &F,
  590 static int getSuccState(DenseMap<BasicBlock *, int> &InitialStates, Function &F,
  637 void WinEHStatePass::addStateStores(Function &F, WinEHFuncInfo &FuncInfo) {
  663   ReversePostOrderTraversal<Function *> RPOT(&F);
lib/Target/XCore/XCoreFrameLowering.cpp
  326       const Function *Fn = &MF.getFunction();
  361     const Function *Fn = &MF.getFunction();
lib/Target/XCore/XCoreLowerThreadLocal.cpp
  208     Function *GetID = Intrinsic::getDeclaration(GV->getParent(),
lib/Target/XCore/XCoreTargetMachine.cpp
  113 XCoreTargetMachine::getTargetTransformInfo(const Function &F) {
lib/Target/XCore/XCoreTargetMachine.h
   38   const XCoreSubtarget *getSubtargetImpl(const Function &) const override {
   45   TargetTransformInfo getTargetTransformInfo(const Function &F) override;
lib/Target/XCore/XCoreTargetTransformInfo.h
   39   explicit XCoreTTIImpl(const XCoreTargetMachine *TM, const Function &F)
lib/Transforms/AggressiveInstCombine/AggressiveInstCombine.cpp
   57   bool runOnFunction(Function &F) override;
  148   Function *F = Intrinsic::getDeclaration(Phi.getModule(), IID, Phi.getType());
  307           Function *Func = Intrinsic::getDeclaration(
  322 static bool foldUnusualPatterns(Function &F, DominatorTree &DT) {
  351 static bool runImpl(Function &F, TargetLibraryInfo &TLI, DominatorTree &DT) {
  371 bool AggressiveInstCombinerLegacyPass::runOnFunction(Function &F) {
  377 PreservedAnalyses AggressiveInstCombinePass::run(Function &F,
lib/Transforms/AggressiveInstCombine/AggressiveInstCombineInternal.h
   84   bool run(Function &F);
lib/Transforms/AggressiveInstCombine/TruncInstCombine.cpp
  387 bool TruncInstCombine::run(Function &F) {
lib/Transforms/CFGuard/CFGuard.cpp
  145   bool runOnFunction(Function &F) override;
  255 bool CFGuard::runOnFunction(Function &F) {
lib/Transforms/Coroutines/CoroCleanup.cpp
   27   bool lowerRemainingCoroIntrinsics(Function &F);
   31 static void simplifyCFG(Function &F) {
   57 bool Lowerer::lowerRemainingCoroIntrinsics(Function &F) {
  122   bool runOnFunction(Function &F) override {
lib/Transforms/Coroutines/CoroEarly.cpp
   42   bool lowerEarlyIntrinsics(Function &F);
  122     Function *NoopFn =
  123         Function::Create(FnTy, GlobalValue::LinkageTypes::PrivateLinkage,
  153 bool Lowerer::lowerEarlyIntrinsics(Function &F) {
  254   bool runOnFunction(Function &F) override {
lib/Transforms/Coroutines/CoroElide.cpp
   37   void elideHeapAllocations(Function *F, Type *FrameTy, AAResults &AA);
   38   bool shouldElide(Function *F, DominatorTree &DT) const;
   79   Function &F = *Frame->getFunction();
   93 static Type *getFrameType(Function *Resume) {
   99 static Instruction *getFirstNonAllocaInTheEntryBlock(Function *F) {
  108 void Lowerer::elideHeapAllocations(Function *F, Type *FrameTy, AAResults &AA) {
  144 bool Lowerer::shouldElide(Function *F, DominatorTree &DT) const {
  246     auto *FrameTy = getFrameType(cast<Function>(ResumeAddrConstant));
  256 static bool replaceDevirtTrigger(Function &F) {
  267   Function *DevirtFn = M.getFunction(CORO_DEVIRT_TRIGGER_FN);
  293   bool runOnFunction(Function &F) override {
lib/Transforms/Coroutines/CoroFrame.cpp
   50   BlockToIndexMapping(Function &F) {
  102   SuspendCrossingInfo(Function &F, coro::Shape &Shape);
  178 SuspendCrossingInfo::SuspendCrossingInfo(Function &F, coro::Shape &Shape)
  395 static StructType *buildFrameType(Function &F, coro::Shape &Shape,
  927 static void rewritePHIs(Function &F) {
 1226 static void eliminateSwiftErrorAlloca(Function &F, AllocaInst *Alloca,
 1257 static void eliminateSwiftErrorArgument(Function &F, Argument &Arg,
 1294 static void eliminateSwiftError(Function &F, coro::Shape &Shape) {
 1325 void coro::buildCoroutineFrame(Function &F, Shape &Shape) {
lib/Transforms/Coroutines/CoroInstr.h
  182   Function *getCoroutine() const {
  183     return cast<Function>(getArgOperand(CoroutineArg)->stripPointerCasts());
  225   Function *getPrototype() const {
  226     return cast<Function>(getArgOperand(PrototypeArg)->stripPointerCasts());
  230   Function *getAllocFunction() const {
  231     return cast<Function>(getArgOperand(AllocArg)->stripPointerCasts());
  235   Function *getDeallocFunction() const {
  236     return cast<Function>(getArgOperand(DeallocArg)->stripPointerCasts());
lib/Transforms/Coroutines/CoroInternal.h
   50 void updateCallGraph(Function &Caller, ArrayRef<Function *> Funcs,
   50 void updateCallGraph(Function &Caller, ArrayRef<Function *> Funcs,
  120     Function *ResumePrototype;
  121     Function *Alloc;
  122     Function *Dealloc;
  234   explicit Shape(Function &F) { buildFrom(F); }
  235   void buildFrom(Function &F);
  238 void buildCoroutineFrame(Function &F, Shape &Shape);
lib/Transforms/Coroutines/CoroSplit.cpp
   93   Function &OrigF;
   94   Function *NewF;
  108   CoroCloner(Function &OrigF, const Twine &Suffix, coro::Shape &Shape,
  116   CoroCloner(Function &OrigF, const Twine &Suffix, coro::Shape &Shape,
  117              Function *NewF, AnyCoroSuspendInst *ActiveSuspend)
  127   Function *getFunction() const {
  263 static void createResumeEntryBlock(Function &F, coro::Shape &Shape) {
  393 static Function *createCloneDeclaration(Function &OrigF, coro::Shape &Shape,
  393 static Function *createCloneDeclaration(Function &OrigF, coro::Shape &Shape,
  399   Function *NewF =
  400       Function::Create(FnTy, GlobalValue::LinkageTypes::InternalLinkage,
  497 static void replaceSwiftErrorOps(Function &F, coro::Shape &Shape,
  776 static Function *createClone(Function &F, const Twine &Suffix,
  776 static Function *createClone(Function &F, const Twine &Suffix,
  818 static void setCoroInfo(Function &F, coro::Shape &Shape,
  819                         ArrayRef<Function *> Fns) {
  826   Function *Part = *Fns.begin();
  842 static void updateCoroFrame(coro::Shape &Shape, Function *ResumeFn,
  843                             Function *DestroyFn, Function *CleanupFn) {
  843                             Function *DestroyFn, Function *CleanupFn) {
  867 static void postSplitCleanup(Function &F) {
  946 static void addMustTailToCoroResumes(Function &F) {
 1156 static void splitSwitchCoroutine(Function &F, coro::Shape &Shape,
 1157                                  SmallVectorImpl<Function *> &Clones) {
 1188 static void splitRetconCoroutine(Function &F, coro::Shape &Shape,
 1189                                  SmallVectorImpl<Function *> &Clones) {
 1320     Function &F;
 1322     PrettyStackTraceFunction(Function &F) : F(F) {}
 1331 static void splitCoroutine(Function &F, coro::Shape &Shape,
 1332                            SmallVectorImpl<Function *> &Clones) {
 1343 static void splitCoroutine(Function &F, CallGraph &CG, CallGraphSCC &SCC) {
 1358   SmallVector<Function*, 4> Clones;
 1382 static void prepareForSplit(Function &F, CallGraph &CG) {
 1386   Function *DevirtFn = M.getFunction(CORO_DEVIRT_TRIGGER_FN);
 1421   Function *DevirtFn =
 1422       Function::Create(FnTy, GlobalValue::LinkageTypes::PrivateLinkage,
 1442   if (auto ConcreteFn = dyn_cast<Function>(Fn)) {
 1496 static bool replaceAllPrepares(Function *PrepareFn, CallGraph &CG) {
 1544     SmallVector<Function *, 4> Coroutines;
 1546       if (auto *F = CGN->getFunction())
 1561     for (Function *F : Coroutines) {
lib/Transforms/Coroutines/Coroutines.cpp
  110   auto *Fn = Intrinsic::getDeclaration(&TheModule, Intrinsic::coro_subfn_addr);
  189   Function *F = Node->getFunction();
  194       const Function *Callee = Call->getCalledFunction();
  207 void coro::updateCallGraph(Function &ParentFunc, ArrayRef<Function *> NewFuncs,
  207 void coro::updateCallGraph(Function &ParentFunc, ArrayRef<Function *> NewFuncs,
  216   for (Function *F : NewFuncs) {
  239   auto *Fn = Intrinsic::getDeclaration(M, Intrinsic::coro_save);
  248 void coro::Shape::buildFrom(Function &F) {
  488 static void propagateCallAttrsFromCallee(CallInst *Call, Function *Callee) {
  493 static void addCallToCallGraph(CallGraph *CG, CallInst *Call, Function *Callee){
  555   auto F = dyn_cast<Function>(V->stripPointerCasts());
  591   auto F = dyn_cast<Function>(V->stripPointerCasts());
  606   auto F = dyn_cast<Function>(V->stripPointerCasts());
lib/Transforms/Hello/Hello.cpp
   30     bool runOnFunction(Function &F) override {
   48     bool runOnFunction(Function &F) override {
lib/Transforms/IPO/AlwaysInliner.cpp
   39   std::function<AssumptionCache &(Function &)> GetAssumptionCache =
   47   SmallVector<Function *, 16> InlinedFunctions;
   48   for (Function &F : M)
   79   for (Function *F : make_range(NonComdatBegin, InlinedFunctions.end()))
   88     for (Function *F : InlinedFunctions)
  154   Function *Callee = CS.getCalledFunction();
lib/Transforms/IPO/ArgumentPromotion.cpp
  104 static Function *
  105 doPromotion(Function *F, SmallPtrSetImpl<Argument *> &ArgsToPromote,
  139   for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;
  218   Function *NF = Function::Create(NFTy, F->getLinkage(), F->getAddressSpace(),
  218   Function *NF = Function::Create(NFTy, F->getLinkage(), F->getAddressSpace(),
  253     for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(); I != E;
  370   for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(),
  449         Function::arg_iterator TheArg = I2;
  486   Function *Callee = Arg->getParent();
  847     const Function &F, const TargetTransformInfo &TTI,
  852     const Function *Caller = CS.getCaller();
  853     const Function *Callee = CS.getCalledFunction();
  865 static Function *
  866 promoteArguments(Function *F, function_ref<AAResults &(Function &F)> AARGetter,
  866 promoteArguments(Function *F, function_ref<AAResults &(Function &F)> AARGetter,
 1031       Function &OldF = N.getFunction();
 1043       Function *NewF =
 1133       Function *OldF = OldNode->getFunction();
 1138         Function *Caller = OldCS.getInstruction()->getParent()->getParent();
 1149       if (Function *NewF = promoteArguments(OldF, AARGetter, MaxElements,
 1159           OldF->setLinkage(Function::ExternalLinkage);
lib/Transforms/IPO/Attributor.cpp
  333   Function *ScopeFn = IRP.getAssociatedFunction();
  410       if (const Function *Callee = ICS.getCalledFunction())
  418       if (const Function *Callee = ICS.getCalledFunction()) {
  432       const Function *Callee = ICS.getCalledFunction();
  681     const Function *AssociatedFunction =
  816     Function *F = getAssociatedFunction();
  827     Function *F = getAssociatedFunction();
  876     Function *F = getAssociatedFunction();
  995     if (Function *F = dyn_cast<Function>(&AnchorValue)) {
  995     if (Function *F = dyn_cast<Function>(&AnchorValue)) {
 1436     Function *F = getAssociatedFunction();
 1447     Function *F = getAssociatedFunction();
 1500     Function *F = getAssociatedFunction();
 1511     Function *F = getAssociatedFunction();
 1533   const Function *F = I->getFunction();
 1740     if (const Function *F = getAnchorScope())
 1781     Function *F = getAssociatedFunction();
 1792     Function *F = getAssociatedFunction();
 1808 static bool containsCycle(Function &F) {
 1826 static bool containsPossiblyEndlessLoop(Function *F) {
 1837     Function *F = getAssociatedFunction();
 1881     Function *F = getAssociatedFunction();
 1892     Function *F = getAssociatedFunction();
 2006       if (const Function *F = getAnchorScope()) {
 2074     Function *F = getAssociatedFunction();
 2085     Function *F = getAssociatedFunction();
 2102     const Function *F = getAssociatedFunction();
 2107   void exploreFromEntry(Attributor &A, const Function *F) {
 2142     Function &F = *getAssociatedFunction();
 2275   static bool mayCatchAsynchronousExceptions(const Function &F) {
 2291         if (const Function *F = ICS.getCalledFunction())
 2330   const Function &F = *BB->getParent();
 2475     const Function *FnScope = IRP.getAnchorScope();
 2647     Function *F = getAssociatedFunction();
 2660     Function *F = getAssociatedFunction();
 2825     Function *F = getAssociatedFunction();
 2836     Function *F = getAssociatedFunction();
 2854     Function *F = getAssociatedFunction();
 2894     Function *F = getAssociatedFunction();
 2924     const Function *F =
 2956                                                    const Function &F,
 3161   const Function *F =
 3555     Function *F = getAssociatedFunction();
 3610         Function *Fn = Intrinsic::getDeclaration(M, Intrinsic::memset, Tys);
 3632   const Function *F = getAssociatedFunction();
 3984     Function &F = cast<Function>(getAnchorValue());
 3984     Function &F = cast<Function>(getAnchorValue());
 4011     Function *F = getAssociatedFunction();
 4022     Function *F = getAssociatedFunction();
 4250   const Function *AssociatedFunction = IRP.getAssociatedFunction();
 4262     const function_ref<bool(AbstractCallSite)> &Pred, const Function &Fn,
 4283     Function *Caller = I->getFunction();
 4328   const Function *AssociatedFunction = IRP.getAssociatedFunction();
 4348   const Function *AssociatedFunction = IRP.getAssociatedFunction();
 4390   const Function *AssociatedFunction = IRP.getAssociatedFunction();
 4417   const Function *AssociatedFunction =
 4619     for (Function *Fn : ToBeDeletedFunctions) {
 4629     SmallVector<Function *, 8> InternalFns;
 4630     for (Function &F : M)
 4638         Function *F = InternalFns[u];
 4670 void Attributor::initializeInformationCache(Function &F) {
 4712 void Attributor::identifyDefaultAbstractAttributes(Function &F) {
 4933   for (Function &F : M)
 4936   for (Function &F : M) {
lib/Transforms/IPO/BlockExtractor.cpp
   86   void splitLandingPadPreds(Function &F);
  135 void BlockExtractor::splitLandingPadPreds(Function &F) {
  169   SmallVector<Function *, 4> Functions;
  170   for (Function &F : M) {
  179     Function *F = M.getFunction(BInfo.first);
  210     Function *F = CodeExtractor(BlocksToExtractVec).extractCodeRegion(CEAC);
  221     for (Function *F : Functions) {
  227     for (Function &F : M)
lib/Transforms/IPO/CalledValuePropagation.cpp
   64     bool operator()(const Function *LHS, const Function *RHS) const {
   64     bool operator()(const Function *LHS, const Function *RHS) const {
   71   CVPLatticeVal(std::vector<Function *> &&Functions)
   79   const std::vector<Function *> &getFunctions() const {
  105   std::vector<Function *> Functions;
  139       } else if (auto *F = cast<Function>(Key.getPointer()))
  139       } else if (auto *F = cast<Function>(Key.getPointer()))
  156     std::vector<Function *> Union;
  210     if (isa<Function>(Key.getPointer()))
  233     if (auto *F = dyn_cast<Function>(C->stripPointerCasts()))
  233     if (auto *F = dyn_cast<Function>(C->stripPointerCasts()))
  243     Function *F = I.getParent()->getParent();
  259     Function *F = CS.getCalledFunction();
  377   for (Function &F : M)
lib/Transforms/IPO/CrossDSOCFI.cpp
  107   Function *F = cast<Function>(C.getCallee());
  107   Function *F = cast<Function>(C.getCallee());
  146     Function *BitsetTestFn = Intrinsic::getDeclaration(&M, Intrinsic::type_test);
lib/Transforms/IPO/DeadArgumentElimination.cpp
  122 bool DeadArgumentEliminationPass::DeleteDeadVarargs(Function &Fn) {
  166   Function *NF = Function::Create(NFTy, Fn.getLinkage(), Fn.getAddressSpace());
  166   Function *NF = Function::Create(NFTy, Fn.getLinkage(), Fn.getAddressSpace());
  234   for (Function::arg_iterator I = Fn.arg_begin(), E = Fn.arg_end(),
  260 bool DeadArgumentEliminationPass::RemoveDeadArgumentsFromCallers(Function &Fn) {
  327 static unsigned NumRetVals(const Function *F) {
  342 static Type *getRetComponentType(const Function *F, unsigned Idx) {
  386       const Function *F = RI->getParent()->getParent();
  427       const Function *F = CS.getCalledFunction();
  486 void DeadArgumentEliminationPass::SurveyFunction(const Function &F) {
  518   for (Function::const_iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
  627   for (Function::const_arg_iterator AI = F.arg_begin(),
  680 void DeadArgumentEliminationPass::MarkLive(const Function &F) {
  729 bool DeadArgumentEliminationPass::RemoveDeadStuffFromFunction(Function *F) {
  752   for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end();
  865   Function *NF = Function::Create(NFTy, F->getLinkage(), F->getAddressSpace());
  865   Function *NF = Function::Create(NFTy, F->getLinkage(), F->getAddressSpace());
 1015   for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end(),
 1094     Function &F = *I++;
 1104   for (auto &F : M)
 1112     Function *F = &*I++;
 1118   for (auto &F : M)
lib/Transforms/IPO/ElimAvailExtern.cpp
   52   for (Function &F : M) {
lib/Transforms/IPO/ExtractGV.cpp
  104       for (Function &F : M) {
  136             Declaration = Function::Create(FTy, GlobalValue::ExternalLinkage,
lib/Transforms/IPO/ForceFunctionAttrs.cpp
   71 static void addForcedAttributes(Function &F) {
   94   for (Function &F : M.functions())
  113     for (Function &F : M.functions())
lib/Transforms/IPO/FunctionAttrs.cpp
   96 using SCCNodeSet = SmallSetVector<Function *, 8>;
  108 static MemoryAccessKind checkFunctionMemoryAccess(Function &F, bool ThisBody,
  226 MemoryAccessKind llvm::computeFunctionBodyMemoryAccess(Function &F,
  238   for (Function *F : SCCNodes) {
  270   for (Function *F : SCCNodes) {
  370     Function *F = CS.getCalledFunction();
  498       Function *F = CS.getCalledFunction();
  576   for (Function *F : SCCNodes) {
  625 static bool addArgumentAttrsFromCallsites(Function &F) {
  641       if (auto *CalledFunc = CS.getCalledFunction()) {
  691   for (Function *F : SCCNodes) {
  704       for (Function::arg_iterator A = F->arg_begin(), E = F->arg_end(); A != E;
  715     for (Function::arg_iterator A = F->arg_begin(), E = F->arg_end(); A != E;
  861 static bool isFunctionMallocLike(Function *F, const SCCNodeSet &SCCNodes) {
  928   for (Function *F : SCCNodes) {
  949   for (Function *F : SCCNodes) {
  969 static bool isReturnNonNull(Function *F, const SCCNodeSet &SCCNodes,
 1016       Function *Callee = CS.getCalledFunction();
 1044   for (Function *F : SCCNodes) {
 1080     for (Function *F : SCCNodes) {
 1113     std::function<bool(const Function &)> SkipFunction;
 1119     std::function<void(Function &)> SetAttribute;
 1129                         std::function<bool(const Function &)> SkipFunc,
 1131                         std::function<void(Function &)> SetAttr,
 1156   for (Function *F : SCCNodes) {
 1206   for (Function *F : SCCNodes)
 1236     if (Function *Callee = CI->getCalledFunction()) {
 1253   Function *Callee = CS.getCalledFunction();
 1346 static bool setDoesNotRecurse(Function &F) {
 1361   Function *F = *SCCNodes.begin();
 1371         Function *Callee = CS.getCalledFunction();
 1428     Function &F = N.getFunction();
 1501     Function *F = I->getFunction();
 1555 static bool addNoRecurseAttrsTopDown(Function &F) {
 1592   SmallVector<Function *, 16> Worklist;
 1597     Function *F = I->front()->getFunction();
 1604   for (auto *F : llvm::reverse(Worklist))
lib/Transforms/IPO/FunctionImport.cpp
  913   if (Function *F = dyn_cast<Function>(&GV)) {
  913   if (Function *F = dyn_cast<Function>(&GV)) {
  926           Function::Create(cast<FunctionType>(GV.getValueType()),
 1000   for (auto &GV : TheModule)
 1048 static Function *replaceAliasWithAliasee(Module *SrcModule, GlobalAlias *GA) {
 1049   Function *Fn = cast<Function>(GA->getBaseObject());
 1049   Function *Fn = cast<Function>(GA->getBaseObject());
 1052   Function *NewFn = CloneFunction(Fn, VMap);
 1107     for (Function &F : *SrcModule) {
 1158         auto *Fn = replaceAliasWithAliasee(SrcModule.get(), &GA);
lib/Transforms/IPO/GlobalDCE.cpp
   86 static bool isEmptyFunction(Function *F) {
  103     Function *Parent = I->getParent()->getParent();
  132     if (VFESafeVTables.count(GVU) && isa<Function>(&GV)) {
  203 void GlobalDCEPass::ScanVTableLoad(Function *Caller, Metadata *TypeId,
  218     auto Callee = dyn_cast<Function>(Ptr->stripPointerCasts());
  233   Function *TypeCheckedLoadFunc =
  293   for (Function &F : M)
  368   std::vector<Function *> DeadFunctions;
  369   for (Function &F : M)
  401   for (Function *F : DeadFunctions) {
lib/Transforms/IPO/GlobalOpt.cpp
  159     Value *V, function_ref<TargetLibraryInfo &(Function &)> GetTLI) {
  190                         function_ref<TargetLibraryInfo &(Function &)> GetTLI) {
  277     function_ref<TargetLibraryInfo &(Function &)> GetTLI) {
  752     function_ref<TargetLibraryInfo &(Function &)> GetTLI) {
 1570                          function_ref<TargetLibraryInfo &(Function &)> GetTLI) {
 1772   if (auto *F = dyn_cast<Function>(&GV))
 1772   if (auto *F = dyn_cast<Function>(&GV))
 1786     const Function *F, GlobalValue *GV,
 1787     function_ref<DominatorTree &(Function &)> LookupDomTree) {
 1924                       function_ref<TargetLibraryInfo &(Function &)> GetTLI,
 1925                       function_ref<DominatorTree &(Function &)> LookupDomTree) {
 2066               function_ref<TargetLibraryInfo &(Function &)> GetTLI,
 2067               function_ref<DominatorTree &(Function &)> LookupDomTree) {
 2103 static void ChangeCalleesToFastCall(Function *F) {
 2120 static void RemoveAttribute(Function *F, Attribute::AttrKind A) {
 2134 static bool hasChangeableCC(Function *F) {
 2179 isValidCandidateForColdCC(Function &F,
 2180                           function_ref<BlockFrequencyInfo &(Function &)> GetBFI,
 2181                           const std::vector<Function *> &AllCallsCold) {
 2191     Function *CallerFunc = CS.getInstruction()->getParent()->getParent();
 2202 static void changeCallSitesToColdCC(Function *F) {
 2215 hasOnlyColdCalls(Function &F,
 2216                  function_ref<BlockFrequencyInfo &(Function &)> GetBFI) {
 2224         Function *CalledFn = CI->getCalledFunction();
 2247                   function_ref<TargetLibraryInfo &(Function &)> GetTLI,
 2248                   function_ref<TargetTransformInfo &(Function &)> GetTTI,
 2249                   function_ref<BlockFrequencyInfo &(Function &)> GetBFI,
 2250                   function_ref<DominatorTree &(Function &)> LookupDomTree,
 2255   std::vector<Function *> AllCallsCold;
 2257     Function *F = &*FI++;
 2264     Function *F = &*FI++;
 2352                    function_ref<TargetLibraryInfo &(Function &)> GetTLI,
 2353                    function_ref<DominatorTree &(Function &)> LookupDomTree,
 2570 static bool EvaluateStaticConstructor(Function *F, const DataLayout &DL,
 2822 static Function *
 2823 FindCXAAtExit(Module &M, function_ref<TargetLibraryInfo &(Function &)> GetTLI) {
 2834   Function *Fn = M.getFunction(TLI->getName(F));
 2852 static bool cxxDtorIsEmpty(const Function &Fn) {
 2868 static bool OptimizeEmptyGlobalCXXDtors(Function *CXAAtExitFn) {
 2894     Function *DtorFn =
 2895       dyn_cast<Function>(CI->getArgOperand(0)->stripPointerCasts());
 2913     function_ref<TargetLibraryInfo &(Function &)> GetTLI,
 2914     function_ref<TargetTransformInfo &(Function &)> GetTTI,
 2915     function_ref<BlockFrequencyInfo &(Function &)> GetBFI,
 2916     function_ref<DominatorTree &(Function &)> LookupDomTree) {
 2928     for (Function &F : M)
 2955     Function *CXAAtExitFn = FindCXAAtExit(M, GetTLI);
lib/Transforms/IPO/GlobalSplit.cpp
  144   Function *TypeTestFunc =
  146   Function *TypeCheckedLoadFunc =
lib/Transforms/IPO/HotColdSplitting.cpp
  145 static bool markFunctionCold(Function &F, bool UpdateEntryCount = false) {
  186 bool HotColdSplitting::isFunctionCold(const Function &F) const {
  201 bool HotColdSplitting::shouldOutlineFrom(const Function &F) const {
  293 Function *HotColdSplitting::extractColdRegion(
  317   Function *OrigF = Region[0]->getParent();
  318   if (Function *OutF = CE.extractCodeRegion(CEAC)) {
  530 bool HotColdSplitting::outlineColdRegions(Function &F, bool HasProfileSummary) {
  542   ReversePostOrderTraversal<Function *> RPOT(&F);
  624       Function *Outlined = extractColdRegion(SubRegion, CEAC, *DT, BFI, TTI,
  640     Function &F = *It;
  679   std::function<OptimizationRemarkEmitter &(Function &)> GetORE =
  705   std::function<TargetTransformInfo &(Function &)> GTTI =
  711   std::function<OptimizationRemarkEmitter &(Function &)> GetORE =
lib/Transforms/IPO/IPConstantPropagation.cpp
   50 static bool PropagateConstantsIntoArguments(Function &F) {
   78     Function::arg_iterator Arg = F.arg_begin();
  127   Function::arg_iterator AI = F.arg_begin();
  152 static bool PropagateConstantReturn(Function &F) {
  297     for (Function &F : M)
lib/Transforms/IPO/InferFunctionAttrs.cpp
   22     Module &M, function_ref<TargetLibraryInfo &(Function &)> GetTLI) {
   25   for (Function &F : M.functions())
lib/Transforms/IPO/InlineSimple.cpp
   55     Function *Callee = CS.getCalledFunction();
   67     std::function<AssumptionCache &(Function &)> GetAssumptionCache =
lib/Transforms/IPO/Inliner.cpp
  162     Function *Caller, InlineFunctionInfo &IFI,
  277     bool InsertLifetime, function_ref<AAResults &(Function &)> &AARGetter,
  279   Function *Callee = CS.getCalledFunction();
  280   Function *Caller = CS.getCaller();
  307 shouldBeDeferred(Function *Caller, CallSite CS, InlineCost IC,
  425   Function *Callee = CS.getCalledFunction();
  426   Function *Caller = CS.getCaller();
  483     Function *F, int InlineHistoryID,
  484     const SmallVectorImpl<std::pair<Function *, int>> &InlineHistory) {
  508                               const BasicBlock *Block, const Function &Callee,
  509                               const Function &Caller, const InlineCost &IC) {
  529                 std::function<AssumptionCache &(Function &)> GetAssumptionCache,
  531                 std::function<TargetLibraryInfo &(Function &)> GetTLI,
  534                 function_ref<AAResults &(Function &)> AARGetter,
  536   SmallPtrSet<Function *, 8> SCCFunctions;
  539     Function *F = Node->getFunction();
  554   SmallVector<std::pair<Function *, int>, 8> InlineHistory;
  557     Function *F = Node->getFunction();
  573         if (Function *Callee = CS.getCalledFunction())
  602     if (Function *F = CallSites[i].first.getCalledFunction())
  621       Function *Caller = CS.getCaller();
  622       Function *Callee = CS.getCalledFunction();
  787   SmallVector<Function *, 16> DeadFunctionsInComdats;
  806     Function *F = CGN->getFunction();
  840     for (Function *F : DeadFunctionsInComdats)
  932         if (Function *Callee = CS.getCalledFunction()) {
  959   SmallVector<std::pair<Function *, int>, 16> InlineHistory;
  964   SmallSetVector<Function *, 4> InlinedCallees;
  968   SmallVector<Function *, 4> DeadFunctions;
  977     Function &F = *Calls[i].first.getCaller();
 1002     std::function<AssumptionCache &(Function &)> GetAssumptionCache =
 1011       Function &Callee = *CS.getCalledFunction();
 1029       Function &Callee = *CS.getCalledFunction();
 1100           if (Function *NewCallee = CS.getCalledFunction())
 1154     for (Function *InlinedCallee : InlinedCallees) {
 1209   for (Function *DeadF : DeadFunctions) {
lib/Transforms/IPO/Internalize.cpp
  159     for (Function &F : M)
  181   for (Function &I : M) {
lib/Transforms/IPO/LoopExtractor.cpp
  144     Function &Func = *L->getHeader()->getParent();
lib/Transforms/IPO/LowerTypeTests.cpp
  233 bool lowertypetests::isJumpTableCanonical(Function *F) {
  339   std::vector<std::pair<GlobalIndirectSymbol *, Function *>> FunctionAliases;
  362       if (auto *F =
  363               dyn_cast<Function>(GIS.getIndirectSymbol()->stripPointerCasts()))
  440   Function *WeakInitializerFn = nullptr;
  446   void importFunction(Function *F, bool isJumpTableCanonical,
  468                             SmallVectorImpl<Value *> &AsmArgs, Function *Dest);
  481   void replaceWeakDeclarationWithJumpTablePtr(Function *F, Constant *JT,
  487   void createJumpTable(Function *F, ArrayRef<GlobalTypeMember *> Functions);
  494   void replaceCfiUses(Function *Old, Value *New, bool IsJumpTableCanonical);
 1045     Function *F, bool isJumpTableCanonical,
 1056       Function *RealF = Function::Create(F->getFunctionType(),
 1056       Function *RealF = Function::Create(F->getFunctionType(),
 1066   Function *FDecl;
 1070     FDecl = Function::Create(F->getFunctionType(), GlobalValue::ExternalLinkage,
 1076     FDecl = Function::Create(F->getFunctionType(), GlobalValue::ExternalLinkage,
 1086         Function *AliasDecl = Function::Create(
 1086         Function *AliasDecl = Function::Create(
 1213     Function *Dest) {
 1251     WeakInitializerFn = Function::Create(
 1287     Function *F, Constant *JT, bool IsJumpTableCanonical) {
 1297   Function *PlaceholderFn =
 1298       Function::Create(cast<FunctionType>(F->getValueType()),
 1311 static bool isThumbFunction(Function *F, Triple::ArchType ModuleArch) {
 1345     Function *F = cast<Function>(GTM->getGlobal());
 1345     Function *F = cast<Function>(GTM->getGlobal());
 1353     Function *F, ArrayRef<GlobalTypeMember *> Functions) {
 1363                          cast<Function>(Functions[I]->getGlobal()));
 1488   Function *JumpTableFn =
 1489       Function::Create(FunctionType::get(Type::getVoidTy(M.getContext()),
 1507       Function *F = cast<Function>(Functions[I]->getGlobal());
 1507       Function *F = cast<Function>(Functions[I]->getGlobal());
 1567     Function *F = cast<Function>(GTM->getGlobal());
 1567     Function *F = cast<Function>(GTM->getGlobal());
 1712 void LowerTypeTestsModule::replaceCfiUses(Function *Old, Value *New,
 1760   Function *TypeTestFunc =
 1762   Function *ICallBranchFunnelFunc =
 1782     SmallVector<Function *, 8> Defs;
 1783     SmallVector<Function *, 8> Decls;
 1784     for (auto &F : M) {
 1889         Function *F = M.getFunction(FunctionName);
 1902           F = Function::Create(
 1951     if (Function *F = dyn_cast<Function>(&GO)) {
 1951     if (Function *F = dyn_cast<Function>(&GO)) {
 2164         if (auto *F = M.getFunction(AliasName)) {
lib/Transforms/IPO/MergeFunctions.cpp
  176   mutable AssertingVH<Function> F;
  181   FunctionNode(Function *F)
  184   Function *getFunc() const { return F; }
  189   void replaceBy(Function *G) const {
  242   bool insert(Function *NewFunction);
  246   void remove(Function *F);
  254   void replaceDirectCallers(Function *Old, Function *New);
  254   void replaceDirectCallers(Function *Old, Function *New);
  259   void mergeTwoFunctions(Function *F, Function *G);
  259   void mergeTwoFunctions(Function *F, Function *G);
  267   void eraseTail(Function *G);
  276   void writeThunk(Function *F, Function *G);
  276   void writeThunk(Function *F, Function *G);
  279   void writeAlias(Function *F, Function *G);
  279   void writeAlias(Function *F, Function *G);
  283   bool writeThunkOrAlias(Function *F, Function *G);
  283   bool writeThunkOrAlias(Function *F, Function *G);
  286   void replaceFunctionInTree(const FunctionNode &FN, Function *G);
  297   DenseMap<AssertingVH<Function>, FnTreeType::iterator> FNodesInTree;
  325         Function *F1 = cast<Function>(*I);
  325         Function *F1 = cast<Function>(*I);
  326         Function *F2 = cast<Function>(*J);
  326         Function *F2 = cast<Function>(*J);
  347           Function *F3 = cast<Function>(*K);
  347           Function *F3 = cast<Function>(*K);
  384 static bool isEligibleForMerging(Function &F) {
  396   std::vector<std::pair<FunctionComparator::FunctionHash, Function *>>
  398   for (Function &Func : M) {
  429       Function *F = cast<Function>(I);
  429       Function *F = cast<Function>(I);
  445 void MergeFunctions::replaceDirectCallers(Function *Old, Function *New) {
  445 void MergeFunctions::replaceDirectCallers(Function *Old, Function *New) {
  529 void MergeFunctions::eraseTail(Function *G) {
  531   for (Function::iterator BBI = std::next(G->begin()), BBE = G->end();
  655 static bool canCreateThunkFor(Function *F) {
  679 void MergeFunctions::writeThunk(Function *F, Function *G) {
  679 void MergeFunctions::writeThunk(Function *F, Function *G) {
  683   Function *NewG = nullptr;
  697     NewG = Function::Create(G->getFunctionType(), G->getLinkage(),
  704   Function *H = MergeFunctionsPDI ? G : NewG;
  754 static bool canCreateAliasFor(Function *F) {
  765 void MergeFunctions::writeAlias(Function *F, Function *G) {
  765 void MergeFunctions::writeAlias(Function *F, Function *G) {
  787 bool MergeFunctions::writeThunkOrAlias(Function *F, Function *G) {
  787 bool MergeFunctions::writeThunkOrAlias(Function *F, Function *G) {
  800 void MergeFunctions::mergeTwoFunctions(Function *F, Function *G) {
  800 void MergeFunctions::mergeTwoFunctions(Function *F, Function *G) {
  812     Function *NewF = Function::Create(F->getFunctionType(), F->getLinkage(),
  812     Function *NewF = Function::Create(F->getFunctionType(), F->getLinkage(),
  864                                            Function *G) {
  865   Function *F = FN.getFunc();
  883 static bool isFuncOrderCorrect(const Function *F, const Function *G) {
  883 static bool isFuncOrderCorrect(const Function *F, const Function *G) {
  902 bool MergeFunctions::insert(Function *NewFunction) {
  918     Function *F = OldF.getFunc();
  927   Function *DeleteF = NewFunction;
  934 void MergeFunctions::remove(Function *F) {
lib/Transforms/IPO/PartialInlining.cpp
  201       std::function<AssumptionCache &(Function &)> *GetAC,
  202       function_ref<AssumptionCache *(Function &)> LookupAC,
  203       std::function<TargetTransformInfo &(Function &)> *GTTI,
  204       Optional<function_ref<BlockFrequencyInfo &(Function &)>> GBFI,
  217   std::pair<bool, Function *> unswitchFunction(Function *F);
  217   std::pair<bool, Function *> unswitchFunction(Function *F);
  226     FunctionCloner(Function *F, FunctionOutliningInfo *OI,
  228                    function_ref<AssumptionCache *(Function &)> LookupAC);
  229     FunctionCloner(Function *F, FunctionOutliningMultiRegionInfo *OMRI,
  231                    function_ref<AssumptionCache *(Function &)> LookupAC);
  247     Function *doSingleRegionFunctionOutlining();
  249     Function *OrigFunc = nullptr;
  250     Function *ClonedFunc = nullptr;
  252     typedef std::pair<Function *, BasicBlock *> FuncBodyCallerPair;
  267     function_ref<AssumptionCache *(Function &)> LookupAC;
  272   std::function<AssumptionCache &(Function &)> *GetAssumptionCache;
  273   function_ref<AssumptionCache *(Function &)> LookupAssumptionCache;
  274   std::function<TargetTransformInfo &(Function &)> *GetTTI;
  275   Optional<function_ref<BlockFrequencyInfo &(Function &)>> GetBFI;
  297   void computeCallsiteToProfCountMap(Function *DuplicateFunction,
  316   static CallSite getOneCallSiteTo(Function *F) {
  321   std::tuple<DebugLoc, BasicBlock *> getOneDebugLoc(Function *F) {
  341   std::unique_ptr<FunctionOutliningInfo> computeOutliningInfo(Function *F);
  343   computeOutliningColdRegionsInfo(Function *F, OptimizationRemarkEmitter &ORE);
  369     std::function<AssumptionCache &(Function &)> GetAssumptionCache =
  378     std::function<TargetTransformInfo &(Function &)> GetTTI =
  392 PartialInlinerImpl::computeOutliningColdRegionsInfo(Function *F,
  556 PartialInlinerImpl::computeOutliningInfo(Function *F) {
  705 static bool hasProfileData(Function *F, FunctionOutliningInfo *OI) {
  767   Function *Callee = CS.getCalledFunction();
  773   Function *Caller = CS.getCaller();
  894     Function *OutlinedFunc = FuncBBPair.first;
  925     Function *DuplicateFunction,
  929   Function *CurrentCaller = nullptr;
  949     Function *Caller = CS.getCaller();
  966     Function *F, FunctionOutliningInfo *OI, OptimizationRemarkEmitter &ORE,
  967     function_ref<AssumptionCache *(Function &)> LookupAC)
  990     Function *F, FunctionOutliningMultiRegionInfo *OI,
  992     function_ref<AssumptionCache *(Function &)> LookupAC)
 1154     Function *OutlinedFunc = CE.extractCodeRegion(CEAC);
 1180 Function *
 1217   Function *OutlinedFunc =
 1250       Function *Func = FuncBBPair.first;
 1256 std::pair<bool, Function *> PartialInlinerImpl::unswitchFunction(Function *F) {
 1256 std::pair<bool, Function *> PartialInlinerImpl::unswitchFunction(Function *F) {
 1319   Function *OutlinedFunction = Cloner.doSingleRegionFunctionOutlining();
 1454   std::vector<Function *> Worklist;
 1456   for (Function &F : M)
 1462     Function *CurrFunc = Worklist.back();
 1478     std::pair<bool, Function * > Result = unswitchFunction(CurrFunc);
 1505   std::function<AssumptionCache &(Function &)> GetAssumptionCache =
 1514   std::function<BlockFrequencyInfo &(Function &)> GetBFI =
 1519   std::function<TargetTransformInfo &(Function &)> GetTTI =
lib/Transforms/IPO/PruneEH.cpp
   50 static bool SimplifyFunction(Function *F, CallGraph &CG);
   74     if (Function *F = I->getFunction())
   87     Function *F = (*I)->getFunction();
  126               if (Function *Callee = CI->getCalledFunction()) {
  152       Function *F = I->getFunction();
  169     if (Function *F = I->getFunction())
  188 static bool SimplifyFunction(Function *F, CallGraph &CG) {
  190   for (Function::iterator BB = F->begin(), E = F->end(); BB != E; ++BB) {
  246       const Function *Callee = Call->getCalledFunction();
lib/Transforms/IPO/SampleProfile.cpp
   91 using ProfileCount = Function::ProfileCount;
  211     for (const auto &F : CurrentModule) {
  214           {Function::getGUID(OrigName), OrigName});
  226             {Function::getGUID(CanonName), CanonName});
  279       std::function<AssumptionCache &(Function &)> GetAssumptionCache,
  280       std::function<TargetTransformInfo &(Function &)> GetTargetTransformInfo)
  295   bool runOnFunction(Function &F, ModuleAnalysisManager *AM);
  296   unsigned getFunctionLoc(Function &F);
  297   bool emitAnnotations(Function &F);
  306   bool inlineHotFunctions(Function &F,
  311   bool computeBlockWeights(Function &F);
  312   void findEquivalenceClasses(Function &F);
  317   void propagateWeights(Function &F);
  319   void buildEdges(Function &F);
  320   bool propagateThroughEdges(Function &F, bool UpdateBlockCount);
  321   void computeDominanceAndLoopInfo(Function &F);
  356   StringMap<Function *> SymbolMap;
  363   std::function<AssumptionCache &(Function &)> GetAC;
  364   std::function<TargetTransformInfo &(Function &)> GetTTI;
  417   DenseMap<Function *, NotInlinedProfileInfo> notInlinedCallInfo;
  740 bool SampleProfileLoader::computeBlockWeights(Function &F) {
  777     if (Function *Callee = CI->getCalledFunction())
  856   Function *CalledFunction = CS.getCalledFunction();
  901     Function &F, DenseSet<GlobalValue::GUID> &InlinedGUIDs) {
  936       Function *CalledFunction = CallSite(I).getCalledFunction();
 1006     Function *Callee = CallSite(I).getCalledFunction();
 1083 void SampleProfileLoader::findEquivalenceClasses(Function &F) {
 1167 bool SampleProfileLoader::propagateThroughEdges(Function &F,
 1316 void SampleProfileLoader::buildEdges(Function &F) {
 1369 void SampleProfileLoader::propagateWeights(Function &F) {
 1527 unsigned SampleProfileLoader::getFunctionLoc(Function &F) {
 1543 void SampleProfileLoader::computeDominanceAndLoopInfo(Function &F) {
 1602 bool SampleProfileLoader::emitAnnotations(Function &F) {
 1624         ProfileCount(Samples->getHeadSamples() + 1, Function::PCT_Real),
 1730     Function *F = dyn_cast<Function>(N_F.getValue());
 1730     Function *F = dyn_cast<Function>(N_F.getValue());
 1748   for (auto &F : M)
 1755   for (const std::pair<Function *, NotInlinedProfileInfo> &pair :
 1770 bool SampleProfileLoader::runOnFunction(Function &F, ModuleAnalysisManager *AM) {
 1813   F.setEntryCount(ProfileCount(initialEntryCount, Function::PCT_Real));
lib/Transforms/IPO/StripDeadPrototypes.cpp
   33     Function *F = &*I++;
lib/Transforms/IPO/StripSymbols.cpp
  150   else if (!isa<Function>(C))
  217   for (Function &I : M) {
  253   Function *Declare = M.getFunction("llvm.dbg.declare");
lib/Transforms/IPO/SyntheticCountsPropagation.cpp
   44 using ProfileCount = Function::ProfileCount;
   66 initializeCounts(Module &M, function_ref<void(Function *, uint64_t)> SetCount) {
   75   for (Function &F : M) {
  101   DenseMap<Function *, Scaled64> Counts;
  115     Function *Caller = CS.getCaller();
  142         Entry.second.template toInt<uint64_t>(), Function::PCT_Synthetic));
lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp
  104   if (Function *TypeTestFunc =
  112   if (Function *TypeCheckedLoadFunc =
  145     Function &F = *I++;
  156     Function *NewF =
  157         Function::Create(EmptyFT, GlobalValue::ExternalLinkage,
  187 void forEachVirtualFunction(Constant *C, function_ref<void(Function *)> Fn) {
  188   if (auto *F = dyn_cast<Function>(C))
  188   if (auto *F = dyn_cast<Function>(C))
  201     function_ref<AAResults &(Function &)> AARGetter, Module &M) {
  249   DenseSet<const Function *> EligibleVirtualFns;
  279         if (auto *F = dyn_cast<Function>(GV))
  288   for (Function &F : *MergedM)
  298   for (auto &F : M)
  320     Function &F = *cast<Function>(V);
  320     Function &F = *cast<Function>(V);
  348     if (!isa<Function>(A.getAliasee()))
  351     auto *F = cast<Function>(A.getAliasee());
  351     auto *F = cast<Function>(A.getAliasee());
  373     Function *F = M.getFunction(Name);
  448                          function_ref<AAResults &(Function &)> AARGetter,
lib/Transforms/IPO/WholeProgramDevirt.cpp
  246 VirtualCallTarget::VirtualCallTarget(Function *Fn, const TypeMemberInfo *TM)
  319              function_ref<OptimizationRemarkEmitter &(Function *)> OREGetter) {
  320     Function *F = CS.getCaller();
  333       function_ref<OptimizationRemarkEmitter &(Function *)> OREGetter,
  444   function_ref<AAResults &(Function &)> AARGetter;
  445   function_ref<DominatorTree &(Function &)> LookupDomTree;
  457   function_ref<OptimizationRemarkEmitter &(Function *)> OREGetter;
  471   DevirtModule(Module &M, function_ref<AAResults &(Function &)> AARGetter,
  472                function_ref<OptimizationRemarkEmitter &(Function *)> OREGetter,
  473                function_ref<DominatorTree &(Function &)> LookupDomTree,
  489   void scanTypeTestUsers(Function *TypeTestFunc, Function *AssumeFunc);
  489   void scanTypeTestUsers(Function *TypeTestFunc, Function *AssumeFunc);
  490   void scanTypeCheckedLoadUsers(Function *TypeCheckedLoadFunc);
  576   runForTesting(Module &M, function_ref<AAResults &(Function &)> AARGetter,
  577                 function_ref<OptimizationRemarkEmitter &(Function *)> OREGetter,
  578                 function_ref<DominatorTree &(Function &)> LookupDomTree);
  739     Module &M, function_ref<AAResults &(Function &)> AARGetter,
  740     function_ref<OptimizationRemarkEmitter &(Function *)> OREGetter,
  741     function_ref<DominatorTree &(Function &)> LookupDomTree) {
  824     auto Fn = dyn_cast<Function>(Ptr->stripPointerCasts());
  924   Function *TheFn = TargetsForSlot[0].Fn;
 1052   Function *JT;
 1054     JT = Function::Create(FT, Function::ExternalLinkage,
 1054     JT = Function::Create(FT, Function::ExternalLinkage,
 1059     JT = Function::Create(FT, Function::InternalLinkage,
 1059     JT = Function::Create(FT, Function::InternalLinkage,
 1073   Function *Intr =
 1541   for (const Function &Fn : FL) {
 1551 void DevirtModule::scanTypeTestUsers(Function *TypeTestFunc,
 1552                                      Function *AssumeFunc) {
 1598 void DevirtModule::scanTypeCheckedLoadUsers(Function *TypeCheckedLoadFunc) {
 1599   Function *TypeTestFunc = Intrinsic::getDeclaration(&M, Intrinsic::type_test);
 1771   Function *TypeTestFunc =
 1773   Function *TypeCheckedLoadFunc =
 1775   Function *AssumeFunc = M.getFunction(Intrinsic::getName(Intrinsic::assume));
 1857   std::map<std::string, Function*> DevirtTargets;
 1904       Function *F = DT.second;
lib/Transforms/InstCombine/InstCombineAndOrXor.cpp
  110   Function *F = Intrinsic::getDeclaration(I.getModule(), Intrinsic::bswap,
 2085   Function *F = Intrinsic::getDeclaration(Or.getModule(), IID, Or.getType());
lib/Transforms/InstCombine/InstCombineCalls.cpp
  806       Function *F = Intrinsic::getDeclaration(M, Intrinsic::x86_sse4a_extrqi);
  907     Function *F = Intrinsic::getDeclaration(M, Intrinsic::x86_sse4a_insertqi);
 1193     Function *F = Intrinsic::getDeclaration(II.getModule(), ID, II.getType());
 1970         Function *Fshl = Intrinsic::getDeclaration(Mod, Intrinsic::fshl, Ty);
 1990         Function *Bswap = Intrinsic::getDeclaration(Mod, Intrinsic::bswap, Ty);
 3689         Function *NewF = Intrinsic::getDeclaration(
 3784       Function *NewF =
 4300   if (!isa<Function>(Callee) && transformConstExprCastCall(Call))
 4303   if (Function *CalleeF = dyn_cast<Function>(Callee)) {
 4303   if (Function *CalleeF = dyn_cast<Function>(Callee)) {
 4409   auto *Callee = dyn_cast<Function>(Call.getCalledValue()->stripPointerCasts());
 4409   auto *Callee = dyn_cast<Function>(Call.getCalledValue()->stripPointerCasts());
 4705   Function *NestF = cast<Function>(Tramp.getArgOperand(1)->stripPointerCasts());
 4705   Function *NestF = cast<Function>(Tramp.getArgOperand(1)->stripPointerCasts());
lib/Transforms/InstCombine/InstCombineCasts.cpp
  572   Function *F = Intrinsic::getDeclaration(Trunc.getModule(), IID, DestTy);
 1661       Function *Overload = Intrinsic::getDeclaration(FPT.getModule(),
 2445       Function *Bswap =
lib/Transforms/InstCombine/InstCombineCompares.cpp
 1315   Function *F = Intrinsic::getDeclaration(
 3646   Function *F = Intrinsic::getDeclaration(
 4684   Function *F = Intrinsic::getDeclaration(
lib/Transforms/InstCombine/InstCombineSelect.cpp
  825   Function *F = Intrinsic::getDeclaration(II->getModule(), Intrinsic::cttz,
 2072   Function *F = Intrinsic::getDeclaration(MinMax1.getModule(), IntrinsicID, NewTy);
 2186   Function *F = Intrinsic::getDeclaration(Sel.getModule(), IID, Sel.getType());
lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp
 1040   Function *NewIntrin = Intrinsic::getDeclaration(M, IID, OverloadTys);
lib/Transforms/InstCombine/InstructionCombining.cpp
 2417       Function *F = Intrinsic::getDeclaration(M, Intrinsic::donothing);
 3479 static bool prepareICWorklistFromFunction(Function &F, const DataLayout &DL,
 3507     Function &F, InstCombineWorklist &Worklist, AliasAnalysis *AA,
 3551 PreservedAnalyses InstCombinePass::run(Function &F,
 3597 bool InstructionCombiningPass::runOnFunction(Function &F) {
lib/Transforms/Instrumentation/AddressSanitizer.cpp
  641   bool instrumentFunction(Function &F, const TargetLibraryInfo *TLI);
  642   bool maybeInsertAsanInitAtFunctionEntry(Function &F);
  643   void maybeInsertDynamicShadowAtFunctionEntry(Function &F);
  644   void markEscapedLocalAllocas(Function &F);
  720   bool runOnFunction(Function &F) override {
  794   void poisonOneInitializer(Function &GlobalInit, GlobalValue *ModuleName);
  821   Function *AsanCtorFunction = nullptr;
  822   Function *AsanDtorFunction = nullptr;
  870   Function &F;
  913   FunctionStackPoisoner(Function &F, AddressSanitizer &ASan)
  982       Function *DynamicAreaOffsetFunc = Intrinsic::getDeclaration(
 1167 PreservedAnalyses AddressSanitizerPass::run(Function &F,
 1168                                             AnalysisManager<Function> &AM) {
 1382     auto *F = dyn_cast<Function>(CI->getCalledValue());
 1382     auto *F = dyn_cast<Function>(CI->getCalledValue());
 1760 void ModuleAddressSanitizer::poisonOneInitializer(Function &GlobalInit,
 1791     if (Function *F = dyn_cast<Function>(CS->getOperand(1))) {
 1791     if (Function *F = dyn_cast<Function>(CS->getOperand(1))) {
 2032       Function::Create(FunctionType::get(Type::getVoidTy(*C), false),
 2538 bool AddressSanitizer::maybeInsertAsanInitAtFunctionEntry(Function &F) {
 2556 void AddressSanitizer::maybeInsertDynamicShadowAtFunctionEntry(Function &F) {
 2583 void AddressSanitizer::markEscapedLocalAllocas(Function &F) {
 2611 bool AddressSanitizer::instrumentFunction(Function &F,
lib/Transforms/Instrumentation/BoundsChecking.cpp
  142 static bool addBoundsChecking(Function &F, TargetLibraryInfo &TLI,
  180     Function *Fn = IRB.GetInsertBlock()->getParent();
  188     auto *F = Intrinsic::getDeclaration(Fn->getParent(), Intrinsic::trap);
  208 PreservedAnalyses BoundsCheckingPass::run(Function &F, FunctionAnalysisManager &AM) {
  226   bool runOnFunction(Function &F) override {
lib/Transforms/Instrumentation/CFGMST.h
   39   Function &F;
  120     for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
  275   CFGMST(Function &Func, BranchProbabilityInfo *BPI_ = nullptr,
lib/Transforms/Instrumentation/CGProfile.cpp
   27   MapVector<std::pair<Function *, Function *>, uint64_t> Counts;
   27   MapVector<std::pair<Function *, Function *>, uint64_t> Counts;
   40   for (auto &F : M) {
   81     MapVector<std::pair<Function *, Function *>, uint64_t> &Counts) const {
   81     MapVector<std::pair<Function *, Function *>, uint64_t> &Counts) const {
lib/Transforms/Instrumentation/ControlHeightReduction.cpp
  112   bool runOnFunction(Function &F) override;
  322   CHR(Function &Fin, BlockFrequencyInfo &BFIin, DominatorTree &DTin,
  402   Function &F;
  441 static bool shouldApply(Function &F, ProfileSummaryInfo& PSI) {
  455 static void LLVM_ATTRIBUTE_UNUSED dumpIR(Function &F, const char *Label,
 2074 bool ControlHeightReductionLegacyPass::runOnFunction(Function &F) {
 2093     Function &F,
lib/Transforms/Instrumentation/DataFlowSanitizer.cpp
  186   bool isIn(const Function &F, StringRef Category) const {
  355   DenseMap<Value *, Function *> UnwrappedFnMap;
  360   bool isInstrumented(const Function *F);
  366   WrapperKind getWrapperKind(Function *F);
  368   Function *buildWrapperFunction(Function *F, StringRef NewFName,
  368   Function *buildWrapperFunction(Function *F, StringRef NewFName,
  386   Function *F;
  408   DFSanFunction(DataFlowSanitizer &DFS, Function *F, bool IsNativeABI)
  603 bool DataFlowSanitizer::isInstrumented(const Function *F) {
  615 DataFlowSanitizer::WrapperKind DataFlowSanitizer::getWrapperKind(Function *F) {
  645 Function *
  646 DataFlowSanitizer::buildWrapperFunction(Function *F, StringRef NewFName,
  650   Function *NewF = Function::Create(NewFT, NewFLink, F->getAddressSpace(),
  650   Function *NewF = Function::Create(NewFT, NewFLink, F->getAddressSpace(),
  668     for (Function::arg_iterator ai = NewF->arg_begin(); n != 0; ++ai, --n)
  684   Function *F = dyn_cast<Function>(C.getCallee());
  684   Function *F = dyn_cast<Function>(C.getCallee());
  689     Function::arg_iterator AI = F->arg_begin(); ++AI;
  700     Function::arg_iterator ValAI = F->arg_begin(), ShadowAI = AI; ++ValAI;
  782   std::vector<Function *> FnsToInstrument;
  783   SmallPtrSet<Function *, 2> FnsWithNativeABI;
  784   for (Function &i : M) {
  803     if (auto F = dyn_cast<Function>(GA->getBaseObject())) {
  811         Function *NewF =
  826   for (std::vector<Function *>::iterator i = FnsToInstrument.begin(),
  829     Function &F = **i;
  840         Function *NewF = Function::Create(NewFT, F.getLinkage(),
  840         Function *NewF = Function::Create(NewFT, F.getLinkage(),
  846         for (Function::arg_iterator FArg = F.arg_begin(),
  854         for (Function::user_iterator UI = F.user_begin(), UE = F.user_end();
  888       Function *NewF = buildWrapperFunction(
  925   for (Function *i : FnsToInstrument) {
 1044         Function::arg_iterator i = F->arg_begin();
 1198     if (isa<Function>(Obj) || isa<BlockAddress>(Obj))
 1536   Function *F = CS.getCalledFunction();
 1549   DenseMap<Value *, Function *>::iterator i =
 1552     Function *F = i->second;
 1579         if (Function *CustomFn = dyn_cast<Function>(CustomF.getCallee())) {
 1579         if (Function *CustomFn = dyn_cast<Function>(CustomF.getCallee())) {
lib/Transforms/Instrumentation/GCOVProfiling.cpp
   91               std::function<const TargetLibraryInfo &(Function &F)> GetTLI);
  101   bool isFunctionInstrumented(const Function &F);
  115   Function *
  117   Function *insertFlush(ArrayRef<std::pair<GlobalVariable *, MDNode *>>);
  132   std::function<const TargetLibraryInfo &(Function &F)> GetTLI;
  342      GCOVFunction(const DISubprogram *SP, Function *F, raw_ostream *os,
  378       Function *F = Blocks.begin()->first->getParent();
  421       Function *F = Blocks.begin()->first->getParent();
  483 bool GCOVProfiler::isFunctionInstrumented(const Function &F) {
  562     Module &M, std::function<const TargetLibraryInfo &(Function &F)> GetTLI) {
  592 static bool functionHasLines(Function &F) {
  614 static bool isUsingScopeBasedEH(Function &F) {
  633   for (auto &F : M->functions()) {
  637         if (Function *Callee = CI->getCalledFunction()) {
  691     for (auto &F : M->functions()) {
  777     for (auto &F : M->functions()) {
  848     Function *WriteoutF = insertCounterWriteout(CountersBySP);
  849     Function *FlushF = insertFlush(CountersBySP);
  855     Function *F = Function::Create(FTy, GlobalValue::InternalLinkage,
  855     Function *F = Function::Create(FTy, GlobalValue::InternalLinkage,
  940 Function *GCOVProfiler::insertCounterWriteout(
  943   Function *WriteoutF = M->getFunction("__llvm_gcov_writeout");
  945     WriteoutF = Function::Create(WriteoutFTy, GlobalValue::InternalLinkage,
 1189 Function *GCOVProfiler::
 1192   Function *FlushF = M->getFunction("__llvm_gcov_flush");
 1194     FlushF = Function::Create(FTy, GlobalValue::InternalLinkage,
 1206   Function *WriteoutF = M->getFunction("__llvm_gcov_writeout");
lib/Transforms/Instrumentation/HWAddressSanitizer.cpp
  198   bool sanitizeFunction(Function &F);
  280   Function *HwasanCtorFunction;
  312   bool runOnFunction(Function &F) override {
  353   for (Function &F : M)
  908     Function *ThreadPointerFunc =
  939   Function *F = IRB.GetInsertBlock()->getParent();
 1022   Function *ReadRegister =
 1103 bool HWAddressSanitizer::sanitizeFunction(Function &F) {
 1442   MapVector<Constant *, std::vector<Function *>> PersonalityFns;
 1443   for (Function &F : M) {
 1471     auto *ThunkFn = Function::Create(ThunkFnTy,
 1471     auto *ThunkFn = Function::Create(ThunkFnTy,
 1493     for (Function *F : P.second)
lib/Transforms/Instrumentation/IndirectCallPromotion.cpp
  171   Function &F;
  184     Function *TargetFunction;
  187     PromotionCandidate(Function *F, uint64_t C) : TargetFunction(F), Count(C) {}
  206   ICallPromotionFunc(Function &Func, Module *Modu, InstrProfSymtab *Symtab,
  266     Function *TargetFunction = Symtab->getFunction(Target);
  297                                             Function *DirectCallee,
  395   for (auto &F : M) {
lib/Transforms/Instrumentation/InstrOrderFile.cpp
   70     for (Function &F : M) {
   99   void generateCodeSequence(Module &M, Function &F, int FuncId) {
  163     for (Function &F : M) {
lib/Transforms/Instrumentation/InstrProfiling.cpp
  409 bool InstrProfiling::lowerIntrinsics(Function *F) {
  440 void InstrProfiling::promoteCounterLoadStores(Function *F) {
  477   if (auto *F = M.getFunction(
  481   if (auto *F = M.getFunction(
  485   if (auto *F = M.getFunction(
  493     Module &M, std::function<const TargetLibraryInfo &(Function &F)> GetTLI) {
  516   for (Function &F : M) {
  531   for (Function &F : M)
  677   Function *F = Inc->getParent()->getParent();
  689 static inline bool shouldRecordFunctionAddr(Function *F) {
  745   Function *Fn = Inc->getParent()->getParent();
  950   auto *RegisterF = Function::Create(RegisterFTy, GlobalValue::InternalLinkage,
  950   auto *RegisterF = Function::Create(RegisterFTy, GlobalValue::InternalLinkage,
  957   auto *RuntimeRegisterF =
  958       Function::Create(RuntimeRegisterTy, GlobalVariable::ExternalLinkage,
  963     if (Data != NamesVar && !isa<Function>(Data))
  970     auto *NamesRegisterF =
  971         Function::Create(NamesRegisterTy, GlobalVariable::ExternalLinkage,
  997   auto *User = Function::Create(FunctionType::get(Int32Ty, false),
  997   auto *User = Function::Create(FunctionType::get(Int32Ty, false),
 1028   Function *RegisterF = M->getFunction(getInstrProfRegFuncsName());
 1034   auto *F = Function::Create(FunctionType::get(VoidTy, false),
 1034   auto *F = Function::Create(FunctionType::get(VoidTy, false),
lib/Transforms/Instrumentation/Instrumentation.cpp
   76 Comdat *llvm::GetOrCreateFunctionComdat(Function &F, Triple &T,
lib/Transforms/Instrumentation/MemorySanitizer.cpp
  477   bool sanitizeFunction(Function &F, TargetLibraryInfo &TLI);
  625   bool runOnFunction(Function &F) override {
  646 PreservedAnalyses MemorySanitizerPass::run(Function &F,
 1003 static VarArgHelper *CreateVarArgHelper(Function &Func, MemorySanitizer &Msan,
 1020   Function &F;
 1050   MemorySanitizerVisitor(Function &F, MemorySanitizer &MS,
 1252   BasicBlock *insertKmsanPrologue(Function &F) {
 1602       Function *F = A->getParent();
 2596     Function *BswapFunc = Intrinsic::getDeclaration(
 2803     Function *ShadowFn = Intrinsic::getDeclaration(
 3277       if (Function *Func = Call->getCalledFunction()) {
 3743   Function &F;
 3754   VarArgAMD64Helper(Function &F, MemorySanitizer &MS,
 4006   Function &F;
 4014   VarArgMIPS64Helper(Function &F, MemorySanitizer &MS,
 4134   Function &F;
 4144   VarArgAArch64Helper(Function &F, MemorySanitizer &MS,
 4382   Function &F;
 4390   VarArgPowerPC64Helper(Function &F, MemorySanitizer &MS,
 4560   VarArgNoOpHelper(Function &F, MemorySanitizer &MS,
 4574 static VarArgHelper *CreateVarArgHelper(Function &Func, MemorySanitizer &Msan,
 4592 bool MemorySanitizer::sanitizeFunction(Function &F, TargetLibraryInfo &TLI) {
lib/Transforms/Instrumentation/PGOInstrumentation.cpp
  123 using ProfileCount = Function::ProfileCount;
  308   Function &F;
  317   SelectInstVisitor(Function &Func) : F(Func) {}
  319   void countSelects(Function &Func) {
  329   void instrumentSelects(Function &Func, unsigned *Ind, unsigned TotalNC,
  340   void annotateSelects(Function &Func, PGOUseFunc *UF, unsigned *Ind) {
  521   Function &F;
  567       Function &Func,
  648     Function &F,
  664     Function *FM = dyn_cast<Function>(CM.second);
  664     Function *FM = dyn_cast<Function>(CM.second);
  712     Function *CF = dyn_cast<Function>(CM.second);
  712     Function *CF = dyn_cast<Function>(CM.second);
  804     Function &F, Module *M, BranchProbabilityInfo *BPI, BlockFrequencyInfo *BFI,
  955   PGOUseFunc(Function &Func, Module *Modu,
 1003   Function &getFunc() const { return F; }
 1011   Function &F;
 1270   F.setEntryCount(ProfileCount(FuncEntryCount, Function::PCT_Real));
 1450   for (Function &F : M)
 1462     Module &M, function_ref<BranchProbabilityInfo *(Function &)> LookupBPI,
 1463     function_ref<BlockFrequencyInfo *(Function &)> LookupBFI, bool IsCS) {
 1471   for (auto &F : M) {
 1520     function_ref<BranchProbabilityInfo *(Function &)> LookupBPI,
 1521     function_ref<BlockFrequencyInfo *(Function &)> LookupBFI,
 1562   std::vector<Function *> HotFunctions;
 1563   std::vector<Function *> ColdFunctions;
 1564   for (auto &F : M) {
 1577       F.setEntryCount(ProfileCount(0, Function::PCT_Real));
 1733     Function *F = TI->getParent()->getParent();
 1753   using nodes_iterator = pointer_iterator<Function::const_iterator>;
lib/Transforms/Instrumentation/PGOMemOPSizeOpt.cpp
  111   bool runOnFunction(Function &F) override;
  137   MemOPSizeOpt(Function &Func, BlockFrequencyInfo &BFI,
  172   Function &Func;
  414 static bool PGOMemOPSizeOptImpl(Function &F, BlockFrequencyInfo &BFI,
  427 bool PGOMemOPSizeOptLegacyPass::runOnFunction(Function &F) {
  439 PreservedAnalyses PGOMemOPSizeOpt::run(Function &F,
lib/Transforms/Instrumentation/PoisonChecking.cpp
  247   Function *TrapFunc = M->getFunction("__poison_checker_assert");
  256 static bool rewrite(Function &F) {
  319   for (auto &F : M)
  325 PreservedAnalyses PoisonCheckingPass::run(Function &F,
lib/Transforms/Instrumentation/SanitizerCoverage.cpp
  180 using DomTreeCallback = function_ref<const DominatorTree *(Function &F)>;
  182     function_ref<const PostDominatorTree *(Function &F)>;
  193   void instrumentFunction(Function &F, DomTreeCallback DTCallback,
  195   void InjectCoverageForIndirectCalls(Function &F,
  197   void InjectTraceForCmp(Function &F, ArrayRef<Instruction *> CmpTraceTargets);
  198   void InjectTraceForDiv(Function &F,
  200   void InjectTraceForGep(Function &F,
  202   void InjectTraceForSwitch(Function &F,
  204   bool InjectCoverage(Function &F, ArrayRef<BasicBlock *> AllBlocks,
  207                                                     Function &F, Type *Ty,
  209   GlobalVariable *CreatePCArray(Function &F, ArrayRef<BasicBlock *> AllBlocks);
  210   void CreateFunctionLocalArrays(Function &F, ArrayRef<BasicBlock *> AllBlocks);
  211   void InjectCoverageAtBlock(Function &F, BasicBlock &BB, size_t Idx,
  213   Function *CreateInitCallsForSections(Module &M, const char *CtorName,
  326 Function *ModuleSanitizerCoverage::CreateInitCallsForSections(
  332   Function *CtorFunc;
  451   for (auto &F : M)
  454   Function *Ctor = nullptr;
  506 static bool shouldInstrumentBlock(const Function &F, const BasicBlock *BB,
  568     Function &F, DomTreeCallback DTCallback, PostDomTreeCallback PDTCallback) {
  644     size_t NumElements, Function &F, Type *Ty, const char *Section) {
  667 ModuleSanitizerCoverage::CreatePCArray(Function &F,
  695     Function &F, ArrayRef<BasicBlock *> AllBlocks) {
  708 bool ModuleSanitizerCoverage::InjectCoverage(Function &F,
  726     Function &F, ArrayRef<Instruction *> IndirCalls) {
  745     Function &, ArrayRef<Instruction *> SwitchTraceTargets) {
  784     Function &, ArrayRef<BinaryOperator *> DivTraceTargets) {
  802     Function &, ArrayRef<GetElementPtrInst *> GepTraceTargets) {
  813     Function &, ArrayRef<Instruction *> CmpTraceTargets) {
  847 void ModuleSanitizerCoverage::InjectCoverageAtBlock(Function &F, BasicBlock &BB,
  891     Function *GetFrameAddr = Intrinsic::getDeclaration(
lib/Transforms/Instrumentation/ThreadSanitizer.cpp
   95   bool sanitizeFunction(Function &F, const TargetLibraryInfo &TLI);
  107   void InsertRuntimeIgnores(Function &F);
  136   bool runOnFunction(Function &F) override;
  154 PreservedAnalyses ThreadSanitizerPass::run(Function &F,
  189 bool ThreadSanitizerLegacyPass::runOnFunction(Function &F) {
  428 void ThreadSanitizer::InsertRuntimeIgnores(Function &F) {
  437 bool ThreadSanitizer::sanitizeFunction(Function &F,
lib/Transforms/Instrumentation/ValueProfileCollector.cpp
   41   PluginChain(Function &F) {}
   51   PluginChain(Function &F) : PluginChain<Ts...>(F), Plugin(F) {}
   65   using PluginChainFinal::PluginChainFinal;
   68 ValueProfileCollector::ValueProfileCollector(Function &F)
lib/Transforms/Instrumentation/ValueProfileCollector.h
   61   ValueProfileCollector(Function &Fn);
lib/Transforms/Instrumentation/ValueProfilePlugins.inc
   25   Function &F;
   31   MemIntrinsicPlugin(Function &Fn) : F(Fn), Candidates(nullptr) {}
   52   Function &F;
   57   IndirectCallPromotionPlugin(Function &Fn) : F(Fn) {}
lib/Transforms/ObjCARC/ARCRuntimeEntryPoints.h
   72   Function *get(ARCRuntimeEntryPointKind kind) {
  108   Function *AutoreleaseRV = nullptr;
  111   Function *Release = nullptr;
  114   Function *Retain = nullptr;
  117   Function *RetainBlock = nullptr;
  120   Function *Autorelease = nullptr;
  123   Function *StoreStrong = nullptr;
  126   Function *RetainRV = nullptr;
  129   Function *RetainAutorelease = nullptr;
  132   Function *RetainAutoreleaseRV = nullptr;
  134   Function *getIntrinsicEntryPoint(Function *&Decl, Intrinsic::ID IntID) {
  134   Function *getIntrinsicEntryPoint(Function *&Decl, Intrinsic::ID IntID) {
lib/Transforms/ObjCARC/ObjCARCAPElim.cpp
   71   if (const Function *Callee = CS.getCalledFunction()) {
  161     Function *F = dyn_cast<Function>(cast<ConstantStruct>(Op)->getOperand(1));
  161     Function *F = dyn_cast<Function>(cast<ConstantStruct>(Op)->getOperand(1));
lib/Transforms/ObjCARC/ObjCARCContract.cpp
   82         Function &F, Instruction *Inst, inst_iterator &Iter,
   88     bool optimizeRetainCall(Function &F, Instruction *Retain);
   91     contractAutorelease(Function &F, Instruction *Autorelease,
  102     bool runOnFunction(Function &F) override;
  119 bool ObjCARCContract::optimizeRetainCall(Function &F, Instruction *Retain) {
  146   Function *Decl = EP.get(ARCRuntimeEntryPointKind::RetainRV);
  155     Function &F, Instruction *Autorelease, ARCInstKind Class,
  195   Function *Decl = EP.get(Class == ARCInstKind::AutoreleaseRV
  423   Function *Decl = EP.get(ARCRuntimeEntryPointKind::StoreStrong);
  446     Function &F, Instruction *Inst, inst_iterator &Iter,
  546 bool ObjCARCContract::runOnFunction(Function &F) {
lib/Transforms/ObjCARC/ObjCARCExpand.cpp
   53     bool runOnFunction(Function &F) override;
   83 bool ObjCARCExpand::runOnFunction(Function &F) {
lib/Transforms/ObjCARC/ObjCARCOpts.cpp
  504     bool OptimizeRetainRVCall(Function &F, Instruction *RetainRV);
  505     void OptimizeAutoreleaseRVCall(Function &F, Instruction *AutoreleaseRV,
  507     void OptimizeIndividualCalls(Function &F);
  524     bool Visit(Function &F, DenseMap<const BasicBlock *, BBState> &BBStates,
  547     void OptimizeWeakCalls(Function &F);
  549     bool OptimizeSequences(Function &F);
  551     void OptimizeReturns(Function &F);
  554     void GatherStatistics(Function &F, bool AfterOptimization = false);
  559     bool runOnFunction(Function &F) override;
  595 ObjCARCOpt::OptimizeRetainRVCall(Function &F, Instruction *RetainRV) {
  661   Function *NewDecl = EP.get(ARCRuntimeEntryPointKind::Retain);
  671 void ObjCARCOpt::OptimizeAutoreleaseRVCall(Function &F,
  710   Function *NewDecl = EP.get(ARCRuntimeEntryPointKind::Autorelease);
  745 void ObjCARCOpt::OptimizeIndividualCalls(Function &F) {
  862         Function *Decl = EP.get(ARCRuntimeEntryPointKind::Release);
 1451 ComputePostOrders(Function &F,
 1530 bool ObjCARCOpt::Visit(Function &F,
 1580     Function *Decl = EP.get(ARCRuntimeEntryPointKind::Retain);
 1593     Function *Decl = EP.get(ARCRuntimeEntryPointKind::Release);
 1882 void ObjCARCOpt::OptimizeWeakCalls(Function &F) {
 1929             Function *Decl = EP.get(ARCRuntimeEntryPointKind::Retain);
 1958             Function *Decl = EP.get(ARCRuntimeEntryPointKind::Retain);
 2040 bool ObjCARCOpt::OptimizeSequences(Function &F) {
 2149 void ObjCARCOpt::OptimizeReturns(Function &F) {
 2209 ObjCARCOpt::GatherStatistics(Function &F, bool AfterOptimization) {
 2251 bool ObjCARCOpt::runOnFunction(Function &F) {
lib/Transforms/ObjCARC/ProvenanceAnalysisEvaluator.cpp
   29   bool runOnFunction(Function &F) override;
   53 bool PAEval::runOnFunction(Function &F) {
lib/Transforms/Scalar/ADCE.cpp
  115   Function &F;
  194   AggressiveDeadCodeElimination(Function &F, DominatorTree *DT,
  346     if (Function *Callee = CI->getCalledFunction())
  678 PreservedAnalyses ADCEPass::run(Function &F, FunctionAnalysisManager &FAM) {
  703   bool runOnFunction(Function &F) override {
lib/Transforms/Scalar/AlignmentFromAssumptions.cpp
   53   bool runOnFunction(Function &F) override;
  373 bool AlignmentFromAssumptions::runOnFunction(Function &F) {
  384 bool AlignmentFromAssumptionsPass::runImpl(Function &F, AssumptionCache &AC,
  399 AlignmentFromAssumptionsPass::run(Function &F, FunctionAnalysisManager &AM) {
lib/Transforms/Scalar/BDCE.cpp
   88 static bool bitTrackingDCE(Function &F, DemandedBits &DB) {
  143 PreservedAnalyses BDCEPass::run(Function &F, FunctionAnalysisManager &AM) {
  161   bool runOnFunction(Function &F) override {
lib/Transforms/Scalar/CallSiteSplitting.cpp
  508 static bool doCallSiteSplitting(Function &F, TargetLibraryInfo &TLI,
  513   for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE;) {
  527       Function *Callee = CS.getCalledFunction();
  561   bool runOnFunction(Function &F) override {
  585 PreservedAnalyses CallSiteSplittingPass::run(Function &F,
lib/Transforms/Scalar/ConstantHoisting.cpp
  107   bool runOnFunction(Function &Fn) override;
  142 bool ConstantHoistingLegacyPass::runOnFunction(Function &Fn) {
  500 void ConstantHoistingPass::collectConstantCandidates(Function &Fn) {
  925 bool ConstantHoistingPass::runImpl(Function &Fn, TargetTransformInfo &TTI,
  964 PreservedAnalyses ConstantHoistingPass::run(Function &F,
lib/Transforms/Scalar/ConstantProp.cpp
   47     bool runOnFunction(Function &F) override;
   67 bool ConstantPropagation::runOnFunction(Function &F) {
lib/Transforms/Scalar/CorrelatedValuePropagation.cpp
   98     bool runOnFunction(Function &F) override;
  829 static bool runImpl(Function &F, LazyValueInfo *LVI, DominatorTree *DT,
  915 bool CorrelatedValuePropagation::runOnFunction(Function &F) {
  926 CorrelatedValuePropagationPass::run(Function &F, FunctionAnalysisManager &AM) {
lib/Transforms/Scalar/DCE.cpp
   46   bool runOnFunction(Function &F) override {
  116 static bool eliminateDeadCode(Function &F, TargetLibraryInfo *TLI) {
  139 PreservedAnalyses DCEPass::run(Function &F, FunctionAnalysisManager &AM) {
  155   bool runOnFunction(Function &F) override {
lib/Transforms/Scalar/DeadStoreElimination.cpp
  171     if (Function *F = CS.getCalledFunction()) {
  313                                const Function *F) {
  350                                    const Function *F) {
  719                                   const Function *F) {
 1313 static bool eliminateDeadStores(Function &F, AliasAnalysis *AA,
 1329 PreservedAnalyses DSEPass::run(Function &F, FunctionAnalysisManager &AM) {
 1356   bool runOnFunction(Function &F) override {
lib/Transforms/Scalar/DivRemPairs.cpp
  179 static bool optimizeDivRem(Function &F, const TargetTransformInfo &TTI,
  338   bool runOnFunction(Function &F) override {
  360 PreservedAnalyses DivRemPairsPass::run(Function &F,
lib/Transforms/Scalar/EarlyCSE.cpp
 1316 PreservedAnalyses EarlyCSEPass::run(Function &F,
 1359   bool runOnFunction(Function &F) override {
lib/Transforms/Scalar/FlattenCFGPass.cpp
   31   bool runOnFunction(Function &F) override;
   54 static bool iterativelyFlattenCFG(Function &F, AliasAnalysis *AA) {
   80 bool FlattenCFGPass::runOnFunction(Function &F) {
lib/Transforms/Scalar/Float2Int.cpp
   59     bool runOnFunction(Function &F) override {
  121 void Float2IntPass::findRoots(Function &F, const DominatorTree &DT,
  516 bool Float2IntPass::runImpl(Function &F, const DominatorTree &DT) {
  540 PreservedAnalyses Float2IntPass::run(Function &F, FunctionAnalysisManager &AM) {
lib/Transforms/Scalar/GVN.cpp
  611 PreservedAnalyses GVN::run(Function &F, FunctionAnalysisManager &AM) {
 1747 void GVN::assignBlockRPONumber(Function &F) {
 1750   ReversePostOrderTraversal<Function *> RPOT(&F);
 2079 bool GVN::runImpl(Function &F, AssumptionCache &RunAC, DominatorTree &RunDT,
 2102   for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE; ) {
 2422 bool GVN::performPRE(Function &F) {
 2474 bool GVN::iterateOnFunction(Function &F) {
 2482   ReversePostOrderTraversal<Function *> RPOT(&F);
 2659   bool runOnFunction(Function &F) override {
lib/Transforms/Scalar/GVNHoist.cpp
  262   bool run(Function &F) {
 1080   std::pair<unsigned, unsigned> hoistExpressions(Function &F) {
 1149   bool runOnFunction(Function &F) override {
 1176 PreservedAnalyses GVNHoistPass::run(Function &F, FunctionAnalysisManager &AM) {
lib/Transforms/Scalar/GVNSink.cpp
  563   bool run(Function &F) {
  568     ReversePostOrderTraversal<Function*> RPOT(&F);
  896   bool runOnFunction(Function &F) override {
  910 PreservedAnalyses GVNSinkPass::run(Function &F, FunctionAnalysisManager &AM) {
lib/Transforms/Scalar/GuardWidening.cpp
  803 PreservedAnalyses GuardWideningPass::run(Function &F,
  826   Function &F = *L.getHeader()->getParent();
  853   bool runOnFunction(Function &F) override {
lib/Transforms/Scalar/IndVarSimplify.cpp
 1968   auto *GuardDecl = L->getBlocks()[0]->getModule()->getFunction(
 3142   Function *F = L.getHeader()->getParent();
lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp
  601   Function &F;
 1752   Function *F = L.getHeader()->getParent();
lib/Transforms/Scalar/InferAddressSpaces.cpp
  162   bool runOnFunction(Function &F) override;
  182       const ValueToAddrSpaceMapTy &InferredAddrSpace, Function *F) const;
  195   std::vector<WeakTrackingVH> collectFlatAddressExpressions(Function &F) const;
  272     Function *NewDecl =
  341 InferAddressSpaces::collectFlatAddressExpressions(Function &F) const {
  623 bool InferAddressSpaces::runOnFunction(Function &F) {
  874     const ValueToAddrSpaceMapTy &InferredAddrSpace, Function *F) const {
lib/Transforms/Scalar/InstSimplifyPass.cpp
   30 static bool runImpl(Function &F, const SimplifyQuery &SQ,
   96   bool runOnFunction(Function &F) override {
  130 PreservedAnalyses InstSimplifyPass::run(Function &F,
lib/Transforms/Scalar/JumpThreading.cpp
  138     bool runOnFunction(Function &F) override;
  296 bool JumpThreading::runOnFunction(Function &F) {
  324 PreservedAnalyses JumpThreadingPass::run(Function &F,
  354 bool JumpThreadingPass::runImpl(Function &F, TargetLibraryInfo *TLI_,
  369   auto *GuardDecl = F.getParent()->getFunction(
  560 void JumpThreadingPass::FindLoopHeaders(Function &F) {
lib/Transforms/Scalar/LICM.cpp
  281   Function *F = L.getHeader()->getParent();
  627         Function *F = TrueDest->getParent();
lib/Transforms/Scalar/LoopAccessAnalysisPrinter.cpp
   18   Function &F = *L.getHeader()->getParent();
lib/Transforms/Scalar/LoopDataPrefetch.cpp
  121   bool runOnFunction(Function &F) override;
  156 PreservedAnalyses LoopDataPrefetchPass::run(Function &F,
  178 bool LoopDataPrefetchLegacyPass::runOnFunction(Function &F) {
  229         if (Function *F = CI->getCalledFunction())
  315       Function *PrefetchFunc = Intrinsic::getDeclaration(
lib/Transforms/Scalar/LoopDistribute.cpp
  658   LoopDistributeForLoop(Loop *L, Function *F, LoopInfo *LI, DominatorTree *DT,
  953   Function *F;
  974 static bool runImpl(Function &F, LoopInfo *LI, DominatorTree *DT,
 1015   bool runOnFunction(Function &F) override {
 1044 PreservedAnalyses LoopDistributePass::run(Function &F,
lib/Transforms/Scalar/LoopFuse.cpp
  523   bool fuseLoops(Function &F) {
 1584   bool runOnFunction(Function &F) override {
 1601 PreservedAnalyses LoopFusePass::run(Function &F, FunctionAnalysisManager &AM) {
lib/Transforms/Scalar/LoopIdiomRecognize.cpp
  313   Function *F = L.getHeader()->getParent();
 1640   Function *Func = Intrinsic::getDeclaration(M, Intrinsic::ctpop, Tys);
 1654   Function *Func = Intrinsic::getDeclaration(M, IID, Tys);
 2235   Function *Func = PreheaderBB->getParent();
lib/Transforms/Scalar/LoopLoadElimination.cpp
  545       auto *F = HeaderBB->getParent();
  599 eliminateLoadsAcrossLoops(Function &F, LoopInfo &LI, DominatorTree &DT,
  637   bool runOnFunction(Function &F) override {
  689 PreservedAnalyses LoopLoadEliminationPass::run(Function &F,
lib/Transforms/Scalar/LoopPredication.cpp
  353   Function *F = L.getHeader()->getParent();
  965   auto *GuardDecl =
  968   auto *WCDecl = M->getFunction(
lib/Transforms/Scalar/LoopRotation.cpp
   92     Function &F = *L->getHeader()->getParent();
lib/Transforms/Scalar/LoopSink.cpp
  313 PreservedAnalyses LoopSinkPass::run(Function &F, FunctionAnalysisManager &FAM) {
lib/Transforms/Scalar/LoopUnrollAndJamPass.cpp
  444     Function &F = *L->getHeader()->getParent();
  499   Function *F = L.getHeader()->getParent();
lib/Transforms/Scalar/LoopUnrollPass.cpp
  540           const Function *Callee = CI->getCalledFunction();
 1223     Function &F = *L->getHeader()->getParent();
 1299   Function *F = L.getHeader()->getParent();
 1409 PreservedAnalyses LoopUnrollPass::run(Function &F,
lib/Transforms/Scalar/LoopUnswitch.cpp
  533   Function *F = currentLoop->getHeader()->getParent();
 1235   Function *F = loopHeader->getParent();
lib/Transforms/Scalar/LowerAtomic.cpp
  138 static bool lowerAtomics(Function &F) {
  146 PreservedAnalyses LowerAtomicPass::run(Function &F, FunctionAnalysisManager &) {
  161   bool runOnFunction(Function &F) override {
lib/Transforms/Scalar/LowerConstantIntrinsics.cpp
   85 static bool lowerConstantIntrinsics(Function &F, const TargetLibraryInfo *TLI) {
   90   ReversePostOrderTraversal<Function *> RPOT(&F);
  136 LowerConstantIntrinsicsPass::run(Function &F, FunctionAnalysisManager &AM) {
  156   bool runOnFunction(Function &F) override {
lib/Transforms/Scalar/LowerExpectIntrinsic.cpp
   62   Function *Fn = CI->getCalledFunction();
  278   Function *Fn = CI->getCalledFunction();
  321 static bool lowerExpectIntrinsic(Function &F) {
  348       Function *Fn = CI->getCalledFunction();
  365 PreservedAnalyses LowerExpectIntrinsicPass::run(Function &F,
  387   bool runOnFunction(Function &F) override { return lowerExpectIntrinsic(F); }
lib/Transforms/Scalar/LowerGuardIntrinsic.cpp
   38   bool runOnFunction(Function &F) override;
   42 static bool lowerGuardIntrinsic(Function &F) {
   45   auto *GuardDecl = F.getParent()->getFunction(
   58   auto *DeoptIntrinsic = Intrinsic::getDeclaration(
   70 bool LowerGuardIntrinsicLegacyPass::runOnFunction(Function &F) {
   83 PreservedAnalyses LowerGuardIntrinsicPass::run(Function &F,
lib/Transforms/Scalar/LowerWidenableCondition.cpp
   38   bool runOnFunction(Function &F) override;
   42 static bool lowerWidenableCondition(Function &F) {
   45   auto *WCDecl = F.getParent()->getFunction(
   66 bool LowerWidenableConditionLegacyPass::runOnFunction(Function &F) {
   79 PreservedAnalyses LowerWidenableConditionPass::run(Function &F,
lib/Transforms/Scalar/MakeGuardsExplicit.cpp
   53   bool runOnFunction(Function &F) override;
   57 static void turnToExplicitForm(CallInst *Guard, Function *DeoptIntrinsic) {
   79 static bool explicifyGuards(Function &F) {
   82   auto *GuardDecl = F.getParent()->getFunction(
   95   auto *DeoptIntrinsic = Intrinsic::getDeclaration(
  105 bool MakeGuardsExplicitLegacyPass::runOnFunction(Function &F) {
  114 PreservedAnalyses MakeGuardsExplicitPass::run(Function &F,
lib/Transforms/Scalar/MemCpyOptimizer.cpp
  266   bool runOnFunction(Function &F) override;
  740   if (Function *F = C->getCalledFunction())
 1333 bool MemCpyOptPass::iterateOnFunction(Function &F) {
 1379 PreservedAnalyses MemCpyOptPass::run(Function &F, FunctionAnalysisManager &AM) {
 1406     Function &F, MemoryDependenceResults *MD_, TargetLibraryInfo *TLI_,
 1434 bool MemCpyOptLegacyPass::runOnFunction(Function &F) {
lib/Transforms/Scalar/MergeICmps.cpp
  862 static bool runImpl(Function &F, const TargetLibraryInfo &TLI,
  898   bool runOnFunction(Function &F) override {
  932 PreservedAnalyses MergeICmpsPass::run(Function &F,
lib/Transforms/Scalar/MergedLoadStoreMotion.cpp
  111   bool run(Function &F, AliasAnalysis &AA);
  346 bool MergedLoadStoreMotion::run(Function &F, AliasAnalysis &AA) {
  356   for (Function::iterator FI = F.begin(), FE = F.end(); FI != FE;) {
  382   bool runOnFunction(Function &F) override {
  415 MergedLoadStoreMotionPass::run(Function &F, FunctionAnalysisManager &AM) {
lib/Transforms/Scalar/NaryReassociate.cpp
  130   bool runOnFunction(Function &F) override;
  166 bool NaryReassociateLegacyPass::runOnFunction(Function &F) {
  179 PreservedAnalyses NaryReassociatePass::run(Function &F,
  196 bool NaryReassociatePass::runImpl(Function &F, AssumptionCache *AC_,
  227 bool NaryReassociatePass::doOneIteration(Function &F) {
lib/Transforms/Scalar/NewGVN.cpp
  491   Function &F;
  657   NewGVN(Function &F, DominatorTree *DT, AssumptionCache *AC,
  721   void initializeCongruenceClasses(Function &F);
  793   bool eliminateInstructions(Function &);
  827   void verifyIterationSettled(Function &F);
  900   return DOTGraphTraits<const Function *>::getSimpleNodeLabel(B, nullptr);
 2855 void NewGVN::initializeCongruenceClasses(Function &F) {
 3258 void NewGVN::verifyIterationSettled(Function &F) {
 3425   ReversePostOrderTraversal<Function *> RPOT(&F);
 3803 bool NewGVN::eliminateInstructions(Function &F) {
 4181   bool runOnFunction(Function &F) override;
 4197 bool NewGVNLegacyPass::runOnFunction(Function &F) {
 4225 PreservedAnalyses NewGVNPass::run(Function &F, AnalysisManager<Function> &AM) {
 4225 PreservedAnalyses NewGVNPass::run(Function &F, AnalysisManager<Function> &AM) {
lib/Transforms/Scalar/PartiallyInlineLibCalls.cpp
   30 static bool optimizeSQRT(CallInst *Call, Function *CalledFunc,
   31                          BasicBlock &CurrBB, Function::iterator &BB,
   89 static bool runPartiallyInlineLibCalls(Function &F, TargetLibraryInfo *TLI,
   93   Function::iterator CurrBB;
   94   for (Function::iterator BB = F.begin(), BE = F.end(); BB != BE;) {
  100       Function *CalledFunc;
  135 PartiallyInlineLibCallsPass::run(Function &F, FunctionAnalysisManager &AM) {
  159   bool runOnFunction(Function &F) override {
lib/Transforms/Scalar/PlaceSafepoints.cpp
  130   bool runOnFunction(Function &F) override {
  164   bool runOnFunction(Function &F) override;
  383 static Instruction *findLocationForEntrySafepoint(Function &F,
  438 static bool isGCSafepointPoll(Function &F) {
  445 static bool shouldRewriteFunction(Function &F) {
  459 static bool enableEntrySafepoints(Function &F) { return !NoEntry; }
  460 static bool enableBackedgeSafepoints(Function &F) { return !NoBackedge; }
  461 static bool enableCallSafepoints(Function &F) { return !NoCall; }
  463 bool PlaceSafepoints::runOnFunction(Function &F) {
  631   auto *F = M->getFunction(GCSafepointPollName);
lib/Transforms/Scalar/Reassociate.cpp
  165 void ReassociatePass::BuildRankMap(Function &F,
  166                                    ReversePostOrderTraversal<Function*> &RPOT) {
 2325 ReassociatePass::BuildPairMap(ReversePostOrderTraversal<Function *> &RPOT) {
 2385 PreservedAnalyses ReassociatePass::run(Function &F, FunctionAnalysisManager &) {
 2390   ReversePostOrderTraversal<Function *> RPOT(&F);
 2476     bool runOnFunction(Function &F) override {
lib/Transforms/Scalar/Reg2Mem.cpp
   59     bool runOnFunction(Function &F) override;
   70 bool RegToMem::runOnFunction(Function &F) {
lib/Transforms/Scalar/RewriteStatepointsForGC.cpp
  125 static bool shouldRewriteStatepointsIn(Function &F);
  131   for (Function &F : M) {
  175     for (Function &F : M) {
  301 static void computeLiveInValues(DominatorTree &DT, Function &F,
 1202     Function &F, DominatorTree &DT, ArrayRef<CallBase *> toUpdate,
 1305   DenseMap<Type *, Function *> TypeToDeclMap;
 1316     Function *GCRelocateDecl = TypeToDeclMap[Ty];
 1358     auto *F = cast<CallInst>(Old)->getCalledFunction();
 1406     Function *F = Call->getCalledFunction();
 1462   if (Function *F = dyn_cast<Function>(CallTarget)) {
 1462   if (Function *F = dyn_cast<Function>(CallTarget)) {
 1687     Function &F, DominatorTree &DT, ArrayRef<Value *> Live,
 1916     Function &F, DominatorTree &DT, ArrayRef<CallBase *> toUpdate,
 2171 static bool insertParsePoints(Function &F, DominatorTree &DT,
 2383 static void RemoveNonValidAttrAtIndex(LLVMContext &Ctx, AttrHolder &AH,
 2399 static void stripNonValidAttributesFromPrototype(Function &F) {
 2442 static void stripNonValidDataFromBody(Function &F) {
 2492 static bool shouldRewriteStatepointsIn(Function &F) {
 2509   for (Function &F : M)
 2512   for (Function &F : M)
 2516 bool RewriteStatepointsForGC::runOnFunction(Function &F, DominatorTree &DT,
 2724 static void computeLiveInValues(DominatorTree &DT, Function &F,
lib/Transforms/Scalar/SCCP.cpp
  194   std::function<const TargetLibraryInfo &(Function &)> GetTLI;
  213   MapVector<Function *, LatticeVal> TrackedRetVals;
  217   MapVector<std::pair<Function *, unsigned>, LatticeVal> TrackedMultipleRetVals;
  221   SmallPtrSet<Function *, 16> MRVFunctionsTracked;
  225   SmallPtrSet<Function *, 16> MustTailCallees;
  230   SmallPtrSet<Function *, 16> TrackingIncomingArguments;
  250   DenseMap<Function *, AnalysisResultsForFn> AnalysisResults;
  254   void addAnalysis(Function &F, AnalysisResultsForFn A) {
  265   DomTreeUpdater getDTU(Function &F) {
  272              std::function<const TargetLibraryInfo &(Function &)> GetTLI)
  303   void AddTrackedFunction(Function *F) {
  316   void AddMustTailCallee(Function *F) {
  322   bool isMustTailCallee(Function *F) {
  326   void AddArgumentTrackedFunction(Function *F) {
  332   bool isArgumentTrackedFunction(Function *F) {
  344   bool ResolvedUndefsIn(Function &F);
  376   const MapVector<Function*, LatticeVal> &getTrackedRetVals() {
  388   const SmallPtrSet<Function *, 16> getMRVFunctionsTracked() {
  394   const SmallPtrSet<Function *, 16> getMustTailCallees() {
  411   bool isStructLatticeConstant(Function *F, StructType *STy) {
  837   Function *F = I.getParent()->getParent();
  842     MapVector<Function*, LatticeVal>::iterator TFRVI =
 1199   Function *F = CS.getCalledFunction();
 1314     for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end();
 1356     MapVector<Function*, LatticeVal>::iterator TFRVI = TrackedRetVals.find(F);
 1435 bool SCCPSolver::ResolvedUndefsIn(Function &F) {
 1449           if (Function *F = CS.getCalledFunction())
 1478         if (Function *F = CS.getCalledFunction())
 1782     Function *F = CS.getCalledFunction();
 1802 static bool runSCCP(Function &F, const DataLayout &DL,
 1860 PreservedAnalyses SCCPPass::run(Function &F, FunctionAnalysisManager &AM) {
 1896   bool runOnFunction(Function &F) override {
 1919 static void findReturnsToZap(Function &F,
 2006     std::function<const TargetLibraryInfo &(Function &)> GetTLI,
 2007     function_ref<AnalysisResultsForFn(Function &)> getAnalysis) {
 2012   for (Function &F : M) {
 2053     for (Function &F : M)
 2067   for (Function &F : M) {
 2074       for (Function::arg_iterator AI = F.arg_begin(), E = F.arg_end(); AI != E;
 2082     for (Function::iterator BB = F.begin(), E = F.end(); BB != E; ++BB) {
 2191   const MapVector<Function*, LatticeVal> &RV = Solver.getTrackedRetVals();
 2193     Function *F = I.first;
 2209     Function *F = ReturnsToZap[i]->getParent()->getParent();
lib/Transforms/Scalar/SROA.cpp
 4545 bool SROA::promoteAllocas(Function &F) {
 4557 PreservedAnalyses SROA::runImpl(Function &F, DominatorTree &RunDT,
 4608 PreservedAnalyses SROA::run(Function &F, FunctionAnalysisManager &AM) {
 4628   bool runOnFunction(Function &F) override {
lib/Transforms/Scalar/Scalarizer.cpp
  180   bool visit(Function &F);
  227   bool runOnFunction(Function &F) override;
  299 bool ScalarizerLegacyPass::runOnFunction(Function &F) {
  314 bool ScalarizerVisitor::visit(Function &F) {
  338     Function *F = VArg->getParent();
  486 static Function *getScalarIntrinsicDeclaration(Module *M,
  499   Function *F = CI.getCalledFunction();
  530   Function *NewIntrin = getScalarIntrinsicDeclaration(F->getParent(), ID, VT);
  855 PreservedAnalyses ScalarizerPass::run(Function &F, FunctionAnalysisManager &AM) {
lib/Transforms/Scalar/SeparateConstOffsetFromGEP.cpp
  367   bool runOnFunction(Function &F) override;
  427   bool reuniteExts(Function &F);
  436   void verifyNoDeadCode(Function &F);
 1114 bool SeparateConstOffsetFromGEP::runOnFunction(Function &F) {
 1198 bool SeparateConstOffsetFromGEP::reuniteExts(Function &F) {
 1211 void SeparateConstOffsetFromGEP::verifyNoDeadCode(Function &F) {
lib/Transforms/Scalar/SimpleLoopUnswitch.cpp
 2536     auto *GuardDecl = L.getHeader()->getParent()->getParent()->getFunction(
 2846   Function &F = *L.getHeader()->getParent();
 2926   Function &F = *L->getHeader()->getParent();
lib/Transforms/Scalar/SimplifyCFGPass.cpp
   72 static bool mergeEmptyReturnBlocks(Function &F) {
   78   for (Function::iterator BBI = F.begin(), E = F.end(); BBI != E; ) {
  147 static bool iterativelySimplifyCFG(Function &F, const TargetTransformInfo &TTI,
  162     for (Function::iterator BBIt = F.begin(); BBIt != F.end(); ) {
  173 static bool simplifyFunctionCFG(Function &F, const TargetTransformInfo &TTI,
  217 PreservedAnalyses SimplifyCFGPass::run(Function &F,
  232   std::function<bool(const Function &)> PredicateFtor;
  237                   std::function<bool(const Function &)> Ftor = nullptr)
  263   bool runOnFunction(Function &F) override {
  292                                   std::function<bool(const Function &)> Ftor) {
lib/Transforms/Scalar/Sink.cpp
  238 static bool iterativelySinkInstructions(Function &F, DominatorTree &DT,
  255 PreservedAnalyses SinkingPass::run(Function &F, FunctionAnalysisManager &AM) {
  276     bool runOnFunction(Function &F) override {
lib/Transforms/Scalar/SpeculateAroundPHIs.cpp
  804 PreservedAnalyses SpeculateAroundPHIsPass::run(Function &F,
lib/Transforms/Scalar/SpeculativeExecution.cpp
  112   bool runOnFunction(Function &F) override;
  142 bool SpeculativeExecutionLegacyPass::runOnFunction(Function &F) {
  152 bool SpeculativeExecutionPass::runImpl(Function &F, TargetTransformInfo *TTI) {
  308 PreservedAnalyses SpeculativeExecutionPass::run(Function &F,
lib/Transforms/Scalar/StraightLineStrengthReduce.cpp
  165   bool runOnFunction(Function &F) override;
  706 bool StraightLineStrengthReduce::runOnFunction(Function &F) {
lib/Transforms/Scalar/StructurizeCFG.cpp
  188   Function *Func;
  859   Function *LoopFunc = LoopStart->getParent();
lib/Transforms/Scalar/TailRecursionElimination.cpp
   94 static bool canTRE(Function &F) {
  188 static bool markTails(Function &F, bool &AllCallsAreTailCalls,
  370     Function *F = CI->getParent()->getParent();
  371     for (Function::arg_iterator AI = F->arg_begin(); &*AI != Arg; ++AI)
  397   Function *F = CI->getParent()->getParent();
  452   Function *F = BB->getParent();
  488     Function::arg_iterator FI = F->arg_begin(),
  560   Function *F = BB->getParent();
  594     for (Function::arg_iterator I = F->arg_begin(), E = F->arg_end();
  748 static bool eliminateTailRecursion(Function &F, const TargetTransformInfo *TTI,
  781   for (Function::iterator BBI = F.begin(), E = F.end(); BBI != E; /*in loop*/) {
  827   bool runOnFunction(Function &F) override {
  861 PreservedAnalyses TailCallElimPass::run(Function &F,
lib/Transforms/Scalar/WarnMissedTransforms.cpp
   84 static void warnAboutLeftoverTransformations(Function *F, LoopInfo *LI,
   92 WarnMissedTransformationsPass::run(Function &F, FunctionAnalysisManager &AM) {
  117   bool runOnFunction(Function &F) override {
lib/Transforms/Utils/AddDiscriminators.cpp
   95   bool runOnFunction(Function &F) override;
  167 static bool addDiscriminators(Function &F) {
  265 bool AddDiscriminatorsLegacyPass::runOnFunction(Function &F) {
  269 PreservedAnalyses AddDiscriminatorsPass::run(Function &F,
lib/Transforms/Utils/BasicBlockUtils.cpp
  117 bool llvm::EliminateUnreachableBlocks(Function &F, DomTreeUpdater *DTU,
  127   for (Function::iterator I = F.begin(), E = F.end(); I != E; ++I)
  389 llvm::SplitAllCriticalEdges(Function &F,
lib/Transforms/Utils/BreakCriticalEdges.cpp
   49     bool runOnFunction(Function &F) override {
   84 PreservedAnalyses BreakCriticalEdgesPass::run(Function &F,
  171   Function &F = *TIBB->getParent();
  172   Function::iterator FBBI = TIBB->getIterator();
  356 bool llvm::SplitIndirectBrCriticalEdges(Function &F,
lib/Transforms/Utils/BuildLibCalls.cpp
   43 static bool setDoesNotAccessMemory(Function &F) {
   51 static bool setOnlyReadsMemory(Function &F) {
   59 static bool setOnlyAccessesArgMemory(Function &F) {
   67 static bool setDoesNotThrow(Function &F) {
   75 static bool setRetDoesNotAlias(Function &F) {
   83 static bool setDoesNotCapture(Function &F, unsigned ArgNo) {
   91 static bool setDoesNotAlias(Function &F, unsigned ArgNo) {
   99 static bool setOnlyReadsMemory(Function &F, unsigned ArgNo) {
  107 static bool setRetNonNull(Function &F) {
  117 static bool setReturnedArg(Function &F, unsigned ArgNo) {
  125 static bool setNonLazyBind(Function &F) {
  132 static bool setDoesNotFreeMemory(Function &F) {
  141   Function *F = M->getFunction(Name);
  147 bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {
  841   if (const Function *F =
  842           dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
  923   if (const Function *F =
  924           dyn_cast<Function>(MemCpy.getCallee()->stripPointerCasts()))
 1058   if (const Function *F =
 1059           dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
 1100   if (const Function *F =
 1101           dyn_cast<Function>(Callee.getCallee()->stripPointerCasts()))
 1146   if (const Function *F =
 1147           dyn_cast<Function>(PutChar.getCallee()->stripPointerCasts()))
 1163   if (const Function *F =
 1164           dyn_cast<Function>(PutS.getCallee()->stripPointerCasts()))
 1184   if (const Function *Fn =
 1185           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
 1204   if (const Function *Fn =
 1205           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
 1223   if (const Function *Fn =
 1224           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
 1242   if (const Function *Fn =
 1243           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
 1266   if (const Function *Fn =
 1267           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
 1285   if (const Function *F =
 1286           dyn_cast<Function>(Malloc.getCallee()->stripPointerCasts()))
 1306   if (const auto *F =
 1307           dyn_cast<Function>(Calloc.getCallee()->stripPointerCasts()))
 1330   if (const Function *Fn =
 1331           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
 1349   if (const Function *Fn =
 1350           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
 1369   if (const Function *Fn =
 1370           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
 1392   if (const Function *Fn =
 1393           dyn_cast<Function>(F.getCallee()->stripPointerCasts()))
lib/Transforms/Utils/CallPromotionUtils.cpp
  319 bool llvm::isLegalToPromote(CallSite CS, Function *Callee,
  365 Instruction *llvm::promoteCall(CallSite CS, Function *Callee,
  449 Instruction *llvm::promoteCallWithIfThenElse(CallSite CS, Function *Callee,
lib/Transforms/Utils/CloneFunction.cpp
   41                                   const Twine &NameSuffix, Function *F,
   84 void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
   84 void llvm::CloneFunctionInto(Function *NewFunc, const Function *OldFunc,
  164   for (Function::const_iterator BI = OldFunc->begin(), BE = OldFunc->end();
  204   for (Function::iterator BB =
  237 Function *llvm::CloneFunction(Function *F, ValueToValueMapTy &VMap,
  237 Function *llvm::CloneFunction(Function *F, ValueToValueMapTy &VMap,
  253   Function *NewF = Function::Create(FTy, F->getLinkage(), F->getAddressSpace(),
  253   Function *NewF = Function::Create(FTy, F->getLinkage(), F->getAddressSpace(),
  257   Function::arg_iterator DestI = NewF->arg_begin();
  276     Function *NewFunc;
  277     const Function *OldFunc;
  284     PruningFunctionCloner(Function *newFunc, const Function *oldFunc,
  284     PruningFunctionCloner(Function *newFunc, const Function *oldFunc,
  448 void llvm::CloneAndPruneIntoFromInst(Function *NewFunc, const Function *OldFunc,
  448 void llvm::CloneAndPruneIntoFromInst(Function *NewFunc, const Function *OldFunc,
  651   Function::iterator Begin = cast<BasicBlock>(VMap[StartingBB])->getIterator();
  652   Function::iterator I = Begin;
  711   for (Function::iterator I = cast<BasicBlock>(VMap[StartingBB])->getIterator(),
  726 void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
  726 void llvm::CloneAndPruneFunctionInto(Function *NewFunc, const Function *OldFunc,
  757   Function *F = OrigLoop->getHeader()->getParent();
lib/Transforms/Utils/CloneModule.cpp
   75   for (const Function &I : M) {
   76     Function *NF =
   77         Function::Create(cast<FunctionType>(I.getValueType()), I.getLinkage(),
   93         GV = Function::Create(cast<FunctionType>(I->getValueType()),
  143   for (const Function &I : M) {
  147     Function *F = cast<Function>(VMap[&I]);
  147     Function *F = cast<Function>(VMap[&I]);
  156     Function::arg_iterator DestI = F->arg_begin();
  157     for (Function::const_arg_iterator J = I.arg_begin(); J != I.arg_end();
lib/Transforms/Utils/CodeExtractor.cpp
   72 using ProfileCount = Function::ProfileCount;
  174       if (const Function *F = CI->getCalledFunction()) {
  308 CodeExtractorAnalysisCache::CodeExtractorAnalysisCache(Function &F) {
  374   Function *Func = (*Blocks.begin())->getParent();
  489   Function *Func = (*Blocks.begin())->getParent();
  517     Function *AIFunc = BB->getParent();
  575   Function *F = Header->getParent();
  582         if (const Function *Callee = CI->getCalledFunction())
  766 Function *CodeExtractor::constructFunction(const ValueSet &inputs,
  771                                            Function *oldFunction,
  823   Function *newFunction = Function::Create(
  823   Function *newFunction = Function::Create(
  926   Function::arg_iterator AI = newFunction->arg_begin();
 1060 CallInst *CodeExtractor::emitCallAndSwitchStatement(Function *newFunction,
 1147   Function::arg_iterator OutputArgBegin = newFunction->arg_begin();
 1234   Function::arg_iterator OAI = OutputArgBegin;
 1326 void CodeExtractor::moveCodeToFunction(Function *newFunction) {
 1327   Function *oldFunc = (*Blocks.begin())->getParent();
 1328   Function::BasicBlockListType &oldBlocks = oldFunc->getBasicBlockList();
 1329   Function::BasicBlockListType &newBlocks = newFunction->getBasicBlockList();
 1385 Function *
 1393   Function *oldFunction = header->getParent();
 1512   Function *newFunction =
 1521           ProfileCount(Count.getValue(), Function::PCT_Real)); // FIXME
 1612 bool CodeExtractor::verifyAssumptionCache(const Function& F,
lib/Transforms/Utils/CtorUtils.cpp
   65 static std::vector<Function *> parseGlobalCtors(GlobalVariable *GV) {
   69   std::vector<Function *> Result;
   73     Result.push_back(dyn_cast<Function>(CS->getOperand(1)));
  102     if (!isa<Function>(CS->getOperand(1)))
  117     Module &M, function_ref<bool(Function *)> ShouldRemove) {
  122   std::vector<Function *> Ctors = parseGlobalCtors(GlobalCtors);
  132     Function *F = Ctors[i];
lib/Transforms/Utils/DemoteRegToStack.cpp
   30   Function *F = I.getParent()->getParent();
  124     Function *F = P->getParent()->getParent();
lib/Transforms/Utils/EntryExitInstrumenter.cpp
   20 static void insertCall(Function &CurFn, StringRef Func,
   65 static bool runOnFunction(Function &F, bool PostInlining) {
  130   bool runOnFunction(Function &F) override { return ::runOnFunction(F, false); }
  143   bool runOnFunction(Function &F) override { return ::runOnFunction(F, true); }
  166 llvm::EntryExitInstrumenterPass::run(Function &F, FunctionAnalysisManager &AM) {
lib/Transforms/Utils/Evaluator.cpp
  258 static Function *getFunction(Constant *C) {
  259   if (auto *Fn = dyn_cast<Function>(C))
  259   if (auto *Fn = dyn_cast<Function>(C))
  263     if (auto *Fn = dyn_cast<Function>(Alias->getAliasee()))
  263     if (auto *Fn = dyn_cast<Function>(Alias->getAliasee()))
  268 Function *
  272   if (auto *Fn = getFunction(getVal(V)))
  280   return dyn_cast<Function>(
  284 bool Evaluator::getFormalParams(CallSite &CS, Function *F,
  562       Function *Callee = getCalleeWithFormalArgs(CS, Formals);
  672 bool Evaluator::EvaluateFunction(Function *F, Constant *&RetVal,
  683   for (Function::arg_iterator AI = F->arg_begin(), E = F->arg_end(); AI != E;
lib/Transforms/Utils/FunctionComparator.cpp
  364       Function* F = LBA->getFunction();
  831   for (Function::const_arg_iterator ArgLI = FnL->arg_begin(),
  920 FunctionComparator::FunctionHash FunctionComparator::functionHash(Function &F) {
lib/Transforms/Utils/FunctionImportUtils.cpp
  210       if (Function *F = dyn_cast<Function>(&GV)) {
  210       if (Function *F = dyn_cast<Function>(&GV)) {
  216                                                       Function::PCT_Synthetic));
  294   for (Function &SF : M)
lib/Transforms/Utils/GlobalStatus.cpp
   82         const Function *F = I->getParent()->getParent();
lib/Transforms/Utils/GuardUtils.cpp
   26 void llvm::makeGuardControlFlowExplicit(Function *DeoptIntrinsic,
lib/Transforms/Utils/ImportedFunctionsInliningStatistics.cpp
   24 ImportedFunctionsInliningStatistics::createInlineGraphNode(const Function &F) {
   34 void ImportedFunctionsInliningStatistics::recordInline(const Function &Caller,
   35                                                        const Function &Callee) {
   63   for (const auto &F : M.functions()) {
lib/Transforms/Utils/InlineFunction.cpp
   75 using ProfileCount = Function::ProfileCount;
  542     if (auto *F = CI->getCalledFunction())
  588   Function *Caller = FirstNewBlock->getParent();
  597   for (Function::iterator I = FirstNewBlock->getIterator(), E = Caller->end();
  614   for (Function::iterator BB = FirstNewBlock->getIterator(), E = Caller->end();
  644   Function *Caller = FirstNewBlock->getParent();
  675   for (Function::iterator BB = FirstNewBlock->getIterator(), E = Caller->end();
  751     for (Function::iterator BB = FirstNewBlock->getIterator(),
  814   const Function *CalledFunc = CS.getCalledFunction();
  924   const Function *CalledFunc = CS.getCalledFunction();
 1153   Function *CalledFunc = CS.getCalledFunction();
 1180                                          Function::iterator FirstNewBlock,
 1184   const Function *Caller = CS.getCaller();
 1185   const Function *Callee = CS.getCalledFunction();
 1231       if (Function *F = NewCall->getCalledFunction()) {
 1263                                   const Function *CalledFunc,
 1269   Function *Caller = TheCall->getFunction();
 1388 static void fixupLineNumbers(Function *Fn, Function::iterator FI,
 1388 static void fixupLineNumbers(Function *Fn, Function::iterator FI,
 1479 static void updateCallProfile(Function *Callee, const ValueToValueMapTy &VMap,
 1495     Function *Callee, int64_t entryDelta,
 1540                                         Function *ForwardVarArgsTo) {
 1552   Function *CalledFunc = CS.getCalledFunction();
 1578   Function *Caller = OrigBB->getParent();
 1667   Function::iterator LastBlock = --Caller->end();
 1673   Function::iterator FirstNewBlock;
 1686     for (Function::arg_iterator I = CalledFunc->arg_begin(),
 1881     for (Function::iterator BB = FirstNewBlock, E = Caller->end(); BB != E;
 1921         if (Function *F = CI->getCalledFunction())
 2012     Function *StackSave = Intrinsic::getDeclaration(M, Intrinsic::stacksave);
 2013     Function *StackRestore=Intrinsic::getDeclaration(M,Intrinsic::stackrestore);
 2051     for (Function::iterator BB = FirstNewBlock->getIterator(),
 2063         auto *CalledFn =
 2064             dyn_cast<Function>(CS.getCalledValue()->stripPointerCasts());
 2125       Function *NewDeoptIntrinsic = Intrinsic::getDeclaration(
lib/Transforms/Utils/InstructionNamer.cpp
   33     bool runOnFunction(Function &F) override {
lib/Transforms/Utils/IntegerDivision.cpp
  181   Function *F = IBB->getParent();
  182   Function *CTLZ = Intrinsic::getDeclaration(F->getParent(), Intrinsic::ctlz,
lib/Transforms/Utils/LCSSA.cpp
  418   bool runOnFunction(Function &F) override;
  470 bool LCSSAWrapperPass::runOnFunction(Function &F) {
  479 PreservedAnalyses LCSSAPass::run(Function &F, FunctionAnalysisManager &AM) {
lib/Transforms/Utils/LibCallsShrinkWrap.cpp
   60   bool runOnFunction(Function &F) override;
  300   Function *Callee = CI.getCalledFunction();
  506   Function *Callee = CI->getCalledFunction();
  522 static bool runImpl(Function &F, const TargetLibraryInfo &TLI,
  535 bool LibCallsShrinkWrapLegacyPass::runOnFunction(Function &F) {
  550 PreservedAnalyses LibCallsShrinkWrapPass::run(Function &F,
lib/Transforms/Utils/Local.cpp
 1391 bool llvm::LowerDbgDeclare(Function &F) {
 1919     Function *TrapFn =
 2012 static bool markAliveBlocks(Function &F,
 2030         if (Function *F = dyn_cast<Function>(Callee)) {
 2030         if (Function *F = dyn_cast<Function>(Callee)) {
 2214 bool llvm::removeUnreachableBlocks(Function &F, DomTreeUpdater *DTU,
 2520   if (const Function *F = Call->getCalledFunction()) {
 2864     Function *F = Intrinsic::getDeclaration(I->getModule(), Intrin, DemandedTy);
 2881   Function *F = Intrinsic::getDeclaration(I->getModule(), Intrin, ITy);
 2893   Function *F = CI->getCalledFunction();
lib/Transforms/Utils/LoopSimplify.cpp
   89   Function::iterator BBI = --NewBB->getIterator();
  103     Function::iterator BBI = SplitPreds[i]->getIterator();
  355   Function *F = Header->getParent();
  386   Function::iterator InsertPos = ++BackedgeBlocks.back()->getIterator();
  751     bool runOnFunction(Function &F) override;
  797 bool LoopSimplify::runOnFunction(Function &F) {
  831 PreservedAnalyses LoopSimplifyPass::run(Function &F,
lib/Transforms/Utils/LoopUnrollPeel.cpp
  478   Function *F = Header->getParent();
  624   Function *F = Header->getParent();
lib/Transforms/Utils/LoopUnrollRuntime.cpp
  308   Function *F = Header->getParent();
  763   Function *F = Header->getParent();
lib/Transforms/Utils/LoopVersioning.cpp
  262   bool runOnFunction(Function &F) override {
lib/Transforms/Utils/LowerInvoke.cpp
   37     bool runOnFunction(Function &F) override;
   46 static bool runImpl(Function &F) {
   78 bool LowerInvokeLegacyPass::runOnFunction(Function &F) {
   88 PreservedAnalyses LowerInvokePass::run(Function &F,
lib/Transforms/Utils/LowerMemIntrinsics.cpp
   36   Function *ParentFunc = PreLoopBB->getParent();
  145   Function *ParentFunc = PreLoopBB->getParent();
  293   Function *F = OrigBB->getParent();
  373   Function *F = OrigBB->getParent();
lib/Transforms/Utils/LowerSwitch.cpp
   82     bool runOnFunction(Function &F) override;
  146 bool LowerSwitch::runOnFunction(Function &F) {
  161   for (Function::iterator I = F.begin(), E = F.end(); I != E; ) {
  308   Function* F = OrigBlock->getParent();
  337   Function* F = OrigBlock->getParent();
  444   Function *F = OrigBlock->getParent();
lib/Transforms/Utils/Mem2Reg.cpp
   34 static bool promoteMemoryToRegister(Function &F, DominatorTree &DT,
   60 PreservedAnalyses PromotePass::run(Function &F, FunctionAnalysisManager &AM) {
   83   bool runOnFunction(Function &F) override {
lib/Transforms/Utils/MetaRenamer.cpp
  124       for (auto &F : M) {
  144     bool runOnFunction(Function &F) {
lib/Transforms/Utils/ModuleUtils.cpp
   22 static void appendToGlobalArray(const char *Array, Module &M, Function *F,
   63 void llvm::appendToGlobalCtors(Module &M, Function *F, int Priority, Constant *Data) {
   67 void llvm::appendToGlobalDtors(Module &M, Function *F, int Priority, Constant *Data) {
  119 std::pair<Function *, FunctionCallee> llvm::createSanitizerCtorAndInitFunctions(
  128   Function *Ctor = Function::Create(
  128   Function *Ctor = Function::Create(
  143 std::pair<Function *, FunctionCallee>
  147     function_ref<void(Function *, FunctionCallee)> FunctionsCreatedCallback,
  151   if (Function *Ctor = M.getFunction(CtorName))
  158   Function *Ctor;
  166 Function *llvm::getOrCreateInitFunction(Module &M, StringRef Name) {
  168   if (Function *F = M.getFunction(Name)) {
  178   Function *F =
  179       cast<Function>(M.getOrInsertFunction(Name, AttributeList(),
  189     Module &M, SmallVectorImpl<Function *> &DeadComdatFunctions) {
  195   for (Function *F : DeadComdatFunctions) {
  219     for (Function &F : M.functions())
  264   for (auto &F : *M)
lib/Transforms/Utils/NameAnonGlobals.cpp
   40     for (auto &F : TheModule) {
lib/Transforms/Utils/PredicateInfo.cpp
  522 static Function *getCopyDeclaration(Module *M, Type *Ty) {
  524   return cast<Function>(
  558       Function *IF = getCopyDeclaration(F.getParent(), Op->getType());
  570       Function *IF = getCopyDeclaration(F.getParent(), Op->getType());
  743 PredicateInfo::PredicateInfo(Function &F, DominatorTree &DT,
  756   SmallPtrSet<Function *, 20> FunctionPtrs;
  761   for (Function *F : FunctionPtrs) {
  785 static void replaceCreatedSSACopys(PredicateInfo &PredInfo, Function &F) {
  798 bool PredicateInfoPrinterLegacyPass::runOnFunction(Function &F) {
  810 PreservedAnalyses PredicateInfoPrinterPass::run(Function &F,
  870 PreservedAnalyses PredicateInfoVerifierPass::run(Function &F,
lib/Transforms/Utils/PromoteMemoryToRegister.cpp
  305   Function *AssumeIntrinsic =
  532   Function &F = *DT.getRoot()->getParent();
lib/Transforms/Utils/SanitizerStats.cpp
   43   Function *F = B.GetInsertBlock()->getParent();
   94   auto F = Function::Create(FunctionType::get(VoidTy, false),
lib/Transforms/Utils/SimplifyCFG.cpp
 2302   const Function *Fn = BB->getParent();
 5296   Function *Fn = SI->getParent()->getParent();
 5862   const Function *Fn = BB->getParent();
lib/Transforms/Utils/SimplifyLibCalls.cpp
  147   Function *InnerCallee = FOpen->getCalledFunction();
  193   const Function *F = CI->getCaller();
  219   Function *F = CI->getCaller();
  340   Function *Callee = CI->getCalledFunction();
  571   Function *Callee = CI->getCalledFunction();
  598   Function *Callee = CI->getCalledFunction();
 1160   Function *InnerCallee = Malloc->getCalledFunction();
 1223   Function *F = Intrinsic::getDeclaration(M, IID, CI->getType());
 1254   Function *CalleeFn = CI->getCalledFunction();
 1299     Function *Fn = Intrinsic::getDeclaration(M, IID, B.getFloatTy());
 1345   Function *FSqrt = Intrinsic::getDeclaration(CI->getModule(), Intrinsic::sqrt,
 1455     Function *CalleeFn = BaseFn->getCalledFunction();
 1574     Function *SqrtFn =
 1608     Function *FAbsFn = Intrinsic::getDeclaration(Mod, Intrinsic::fabs, Ty);
 1631   Function *F = Intrinsic::getDeclaration(M, Intrinsic::powi, Base->getType());
 1638   Function *Callee = Pow->getCalledFunction();
 1761   Function *Callee = CI->getCalledFunction();
 1787   Function *Callee = CI->getCalledFunction();
 1807   Function *F = Intrinsic::getDeclaration(CI->getModule(), IID, CI->getType());
 1812   Function *LogFn = Log->getCalledFunction();
 1964   Function *Callee = CI->getCalledFunction();
 2018   Function *Fabs = Intrinsic::getDeclaration(M, Intrinsic::fabs, ArgType);
 2024     Function *Sqrt = Intrinsic::getDeclaration(M, Intrinsic::sqrt, ArgType);
 2033   Function *Callee = CI->getCalledFunction();
 2052   Function *F = OpC->getCalledFunction();
 2069 static void insertSinCosCall(IRBuilder<> &B, Function *OrigCallee, Value *Arg,
 2135   Function *F = CI->getFunction();
 2160     Value *Val, Function *F, bool IsFloat,
 2173   Function *Callee = CI->getCalledFunction();
 2204   Function *F = Intrinsic::getDeclaration(CI->getCalledFunction()->getParent(),
 2218   Function *F = Intrinsic::getDeclaration(CI->getCalledFunction()->getParent(),
 2283 static bool isReportingError(Function *Callee, CallInst *CI, int StreamArg);
 2287   Function *Callee = CI->getCalledFunction();
 2304 static bool isReportingError(Function *Callee, CallInst *CI, int StreamArg) {
 2380   Function *Callee = CI->getCalledFunction();
 2475   Function *Callee = CI->getCalledFunction();
 2648   Function *Callee = CI->getCalledFunction();
 2811   Function *Callee = CI->getCalledFunction();
 2996   Function *Callee = CI->getCalledFunction();
 3418   Function *Callee = CI->getCalledFunction();
lib/Transforms/Utils/SizeOpts.cpp
   42   static bool isFunctionColdInCallGraph(const Function *F,
   48                                                     const Function *F,
   67 bool llvm::shouldOptimizeForSize(const Function *F, ProfileSummaryInfo *PSI,
lib/Transforms/Utils/SplitModule.cpp
   68   } else if (isa<GlobalIndirectSymbol>(U) || isa<Function>(U) ||
  134     if (const Function *F = dyn_cast<Function>(&GV)) {
  134     if (const Function *F = dyn_cast<Function>(&GV)) {
  254     for (Function &F : *M)
lib/Transforms/Utils/StripGCRelocates.cpp
   35   bool runOnFunction(Function &F) override;
   41 bool StripGCRelocates::runOnFunction(Function &F) {
lib/Transforms/Utils/SymbolRewriter.cpp
  135   if (ValueType *S = (M.*Get)(Source)) {
  179   for (auto &C : (M.*Iterator)()) {
  209     ExplicitRewriteDescriptor<RewriteDescriptor::Type::Function, Function,
  229     PatternRewriteDescriptor<RewriteDescriptor::Type::Function, Function,
lib/Transforms/Utils/UnifyFunctionExitNodes.cpp
   45 bool UnifyFunctionExitNodes::runOnFunction(Function &F) {
lib/Transforms/Utils/ValueMapper.cpp
   93     Function *RemapF;
  146   void remapFunction(Function &F);
  166   void scheduleRemapFunction(Function &F, unsigned MCID);
  176   void remapFunction(Function &F, ValueToValueMapTy &VM);
  491   Function *F = cast<Function>(mapValue(BA.getFunction()));
  491   Function *F = cast<Function>(mapValue(BA.getFunction()));
  935 void Mapper::remapFunction(Function &F) {
 1040 void Mapper::scheduleRemapFunction(Function &F, unsigned MCID) {
 1114 void ValueMapper::remapFunction(Function &F) {
 1139 void ValueMapper::scheduleRemapFunction(Function &F, unsigned MCID) {
lib/Transforms/Vectorize/LoadStoreVectorizer.cpp
  112   Function &F;
  121   Vectorizer(Function &F, AliasAnalysis &AA, DominatorTree &DT,
  216   bool runOnFunction(Function &F) override;
  249 bool LoadStoreVectorizerLegacyPass::runOnFunction(Function &F) {
  264 PreservedAnalyses LoadStoreVectorizerPass::run(Function &F, FunctionAnalysisManager &AM) {
lib/Transforms/Vectorize/LoopVectorizationLegality.cpp
  113     Function *F, Loop *L, bool VectorizeOnlyWhenForced) const {
  240     Function *F, Loop *L, const LoopVectorizeHints &Hints) {
  573   Function &F = *Header->getParent();
lib/Transforms/Vectorize/LoopVectorize.cpp
  959                              OptimizationRemarkEmitter *ORE, const Function *F,
 1494   const Function *TheFunction;
 1536   Function *Fn = OuterLp->getHeader()->getParent();
 1596   bool runOnFunction(Function &F) override {
 3223   Function *F = CI->getCalledFunction();
 4267     Function *F = CI->getCalledFunction();
 4296       Function *VectorF;
 4312               Function::Create(FTy, Function::ExternalLinkage, VFnName, M);
 4312               Function::Create(FTy, Function::ExternalLinkage, VFnName, M);
 7442 getScalarEpilogueLowering(Function *F, Loop *L, LoopVectorizeHints &Hints,
 7467   Function *F = L->getHeader()->getParent();
 7532   Function *F = L->getHeader()->getParent();
 7802     Function &F, ScalarEvolution &SE_, LoopInfo &LI_, TargetTransformInfo &TTI_,
 7867 PreservedAnalyses LoopVectorizePass::run(Function &F,
lib/Transforms/Vectorize/SLPVectorizer.cpp
  502   BoUpSLP(Function *Func, ScalarEvolution *Se, TargetTransformInfo *Tti,
 1952   Function *F;
 2701       Function *Int = CI->getCalledFunction();
 4114       if (Function *FI = CI->getCalledFunction())
 4138       Function *CF = Intrinsic::getDeclaration(M, ID, Tys);
 5204   bool runOnFunction(Function &F) override {
 5242 PreservedAnalyses SLPVectorizerPass::run(Function &F, FunctionAnalysisManager &AM) {
 5264 bool SLPVectorizerPass::runImpl(Function &F, ScalarEvolution *SE_,
tools/bugpoint-passes/TestPasses.cpp
   87     for (auto &F : M.functions()) {
  137   bool runOnFunction(Function &F) override {
tools/bugpoint/BugDriver.cpp
  240 void llvm::PrintFunctionList(const std::vector<Function *> &Funcs) {
tools/bugpoint/BugDriver.h
  285 void PrintFunctionList(const std::vector<Function *> &Funcs);
  299 void DeleteFunctionBody(Function *F);
  304 SplitFunctionsOutOfModule(Module *M, const std::vector<Function *> &F,
tools/bugpoint/CrashDebugger.cpp
  190 class ReduceCrashingFunctions : public ListReducer<Function *> {
  198   Expected<TestResult> doTest(std::vector<Function *> &Prefix,
  199                               std::vector<Function *> &Kept) override {
  207   bool TestFuncs(std::vector<Function *> &Prefix);
  235 bool ReduceCrashingFunctions::TestFuncs(std::vector<Function *> &Funcs) {
  245   std::set<Function *> Functions;
  247     Function *CMF = cast<Function>(VMap[Funcs[i]]);
  247     Function *CMF = cast<Function>(VMap[Funcs[i]]);
  260     for (Function &I : *M)
  268       Function *F = dyn_cast_or_null<Function>(Root);
  268       Function *F = dyn_cast_or_null<Function>(Root);
  287     for (Function &I : *M) {
  348   Function *F = M->getFunction(FnName);
  381 void simpleSimplifyCfg(Function &F, SmallVectorImpl<BasicBlock *> &BBs) {
  463   for (Function &F : M->functions()) {
  495   for (auto &F : *M) {
  521       Function *F = cast<Function>(GST.lookup(BI.first));
  521       Function *F = cast<Function>(GST.lookup(BI.first));
  583   for (auto &F : *M)
  602   for (auto &F : *M) {
  628       auto *F = cast<Function>(GST.lookup(BI.first));
  628       auto *F = cast<Function>(GST.lookup(BI.first));
  692   for (auto &F : *M)
  694     for (Function::iterator BBIt = F.begin(); BBIt != F.end();) {
  720       auto *F = cast<Function>(GST.lookup(BI.first));
  720       auto *F = cast<Function>(GST.lookup(BI.first));
  776     for (Function::iterator FI = MI->begin(), FE = MI->end(); FI != FE; ++FI)
 1009     for (const Function &F : BD.getProgram())
 1048         for (Function::const_iterator BI = FI->begin(), E = FI->end(); BI != E;
 1099   std::vector<Function *> Functions;
 1100   for (Function &F : BD.getProgram())
 1120   for (Function &F : BD.getProgram())
 1130       Function *Fn = BD.getProgram().getFunction(Name);
 1154     for (Function &F : BD.getProgram())
 1176     for (Function &F : BD.getProgram())
 1189     for (Function &F : BD.getProgram())
tools/bugpoint/ExtractFunction.cpp
   50 Function *globalInitUsesExternalBA(GlobalVariable *GV) {
   68       Function *F = BA->getFunction();
   90   const Function *PF = PBB->getParent();
   96   Function::iterator RBI = RFI->begin(); // Get iterator to corresponding BB
  216 void llvm::DeleteFunctionBody(Function *F) {
  228 static Constant *GetTorInit(std::vector<std::pair<Function *, int>> &TorList) {
  253   std::vector<std::pair<Function *, int>> M1Tors, M2Tors;
  274       if (Function *F = dyn_cast<Function>(FP)) {
  274       if (Function *F = dyn_cast<Function>(FP)) {
  279           F = cast<Function>(VMap[F]);
  306 llvm::SplitFunctionsOutOfModule(Module *M, const std::vector<Function *> &F,
  323   std::set<Function *> TestFunctions;
  325     Function *TNOF = cast<Function>(VMap[F[i]]);
  325     Function *TNOF = cast<Function>(VMap[F[i]]);
  329     TestFunctions.insert(cast<Function>(NewVMap[TNOF]));
  334   for (Function &I : *New)
  341     if (Function *TestFn = globalInitUsesExternalBA(&I)) {
  342       if (Function *SafeFn = globalInitUsesExternalBA(GV)) {
  386   for (Function &F : *M)
tools/bugpoint/Miscompilation.cpp
  186 class ReduceMiscompilingFunctions : public ListReducer<Function *> {
  198   Expected<TestResult> doTest(std::vector<Function *> &Prefix,
  199                               std::vector<Function *> &Suffix) override {
  217   Expected<bool> TestFuncs(const std::vector<Function *> &Prefix);
  249 ReduceMiscompilingFunctions::TestFuncs(const std::vector<Function *> &Funcs) {
  270   std::vector<Function *> FuncsOnClone;
  272     Function *F = cast<Function>(VMap[Funcs[i]]);
  272     Function *F = cast<Function>(VMap[Funcs[i]]);
  309              std::vector<Function *> &MiscompiledFunctions) {
  345       MiscompiledFunctions[i] = cast<Function>(VMap[MiscompiledFunctions[i]]);
  375       MiscompiledFunctions[i] = cast<Function>(VMap[MiscompiledFunctions[i]]);
  391       for (Function *F : MiscompiledFunctions) {
  401         Function *NewF = ToNotOptimize->getFunction(MisCompFunctions[i].first);
  432       Function *NewF = ToNotOptimize->getFunction(MisCompFunctions[i].first);
  448   std::vector<Function *> FunctionsBeingTested;
  455                           const std::vector<Function *> &Fns)
  504   std::vector<Function *> FuncsOnClone;
  507     Function *F = cast<Function>(VMap[FunctionsBeingTested[i]]);
  507     Function *F = cast<Function>(VMap[FunctionsBeingTested[i]]);
  539               std::vector<Function *> &MiscompiledFunctions) {
  598     Function *NewF = ProgClone->getFunction(MisCompFunctions[i].first);
  612 static Expected<std::vector<Function *>> DebugAMiscompilation(
  620   std::vector<Function *> MiscompiledFunctions;
  622   for (Function &F : Prog)
  752   Expected<std::vector<Function *>> MiscompiledFunctions =
  791   if (Function *oldMain = Safe->getFunction("main"))
  796       Function *newMain =
  797           Function::Create(oldMain->getFunctionType(),
  801       Function *oldMainProto = Function::Create(oldMain->getFunctionType(),
  801       Function *oldMainProto = Function::Create(oldMain->getFunctionType(),
  806       for (Function::arg_iterator I = newMain->arg_begin(),
  838       Function *TestFn = Test->getFunction(F->getName());
  871           Function *FuncWrapper =
  872               Function::Create(FuncTy, GlobalValue::InternalLinkage,
 1024   Expected<std::vector<Function *>> Funcs =
tools/clang/include/clang/CodeGen/CodeGenABITypes.h
   91 llvm::Function *getNonTrivialCStructDefaultConstructor(CodeGenModule &GCM,
  100 llvm::Function *getNonTrivialCStructCopyConstructor(CodeGenModule &CGM,
  110 llvm::Function *getNonTrivialCStructMoveConstructor(CodeGenModule &CGM,
  120 llvm::Function *getNonTrivialCStructCopyAssignmentOperator(
  128 llvm::Function *getNonTrivialCStructMoveAssignmentOperator(
  136 llvm::Function *getNonTrivialCStructDestructor(CodeGenModule &CGM,
tools/clang/lib/CodeGen/Address.h
  108 template <class U> inline U cast(CodeGen::Address addr) {
tools/clang/lib/CodeGen/BackendUtil.cpp
  901     for (Function &F : *TheModule)
tools/clang/lib/CodeGen/CGBlocks.cpp
  234     if (cast<llvm::Function>(copyHelper->getOperand(0))->hasInternalLinkage() ||
  235         cast<llvm::Function>(disposeHelper->getOperand(0))
  937   auto *InvokeFn = BlockCGF.GenerateBlockFunction(
 1445     auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.VoidTy,
 1445     auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.VoidTy,
 1471         cast<llvm::Function>(blockFn->stripPointerCasts()), Result);
 1514 llvm::Function *
 1574   llvm::Function *fn = llvm::Function::Create(
 1574   llvm::Function *fn = llvm::Function::Create(
 1971                                                llvm::Function *Fn,
 2019   llvm::Function *Fn =
 2020     llvm::Function::Create(LTy, llvm::GlobalValue::LinkOnceODRLinkage,
 2212   llvm::Function *Fn =
 2213     llvm::Function::Create(LTy, llvm::GlobalValue::LinkOnceODRLinkage,
 2464   llvm::Function *Fn =
 2465     llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
 2539   llvm::Function *Fn =
 2540     llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
tools/clang/lib/CodeGen/CGBuiltin.cpp
  356   Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
  367   Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
  379   Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
  390   Function *F = CGF.CGM.getIntrinsic(IntrinsicID, Src0->getType());
  401    Function *F = CGF.CGM.getIntrinsic(IntrinsicID,
  408   Function *F = CGF.CGM.getIntrinsic(Intrinsic::fabs, V->getType());
  469   Function *Callee = CGF.CGM.getIntrinsic(IntrinsicID, X->getType());
  480     Function *F = CGF.CGM.getIntrinsic(IntrinsicID, {});
  607   Function *F =
  942       Function *F = CGM.getIntrinsic(Intrinsic::cttz, ArgType);
  950       Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ArgType);
 1118 llvm::Function *CodeGenFunction::generateBuiltinOSLogHelperFunction(
 1135   if (llvm::Function *F = CGM.getModule().getFunction(Name))
 1167   llvm::Function *Fn = llvm::Function::Create(
 1167   llvm::Function *Fn = llvm::Function::Create(
 1278   llvm::Function *F = CodeGenFunction(CGM).generateBuiltinOSLogHelperFunction(
 1527   Function *F = CGM.getIntrinsic(IID, Ty);
 1902     Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ArgType);
 1922     Function *F = CGM.getIntrinsic(Intrinsic::cttz, ArgType);
 1939     Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ArgType);
 1956     Function *F = CGM.getIntrinsic(Intrinsic::cttz, ArgType);
 1977     Function *F = CGM.getIntrinsic(Intrinsic::ctpop, ArgType);
 1993     Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ArgType);
 2011     Function *F = CGM.getIntrinsic(Intrinsic::ctpop, ArgType);
 2037     Function *FnExpect = CGM.getIntrinsic(Intrinsic::expect, ArgType);
 2065     Function *FnAssume = CGM.getIntrinsic(Intrinsic::assume);
 2126     Function *F =
 2153     Function *F = CGM.getIntrinsic(Intrinsic::prefetch, Address->getType());
 2157     Function *F = CGM.getIntrinsic(Intrinsic::readcyclecounter);
 2163     Function *F = CGM.getIntrinsic(Intrinsic::clear_cache);
 2185     Function *F = CGM.getIntrinsic(Intrinsic::powi, ArgType);
 2287     Function *F = CGM.getIntrinsic(Intrinsic::flt_rounds);
 2561     Function *F = CGM.getIntrinsic(Intrinsic::eh_dwarf_cfa);
 2568     Function *F = CGM.getIntrinsic(Intrinsic::returnaddress);
 2572     Function *F = CGM.getIntrinsic(Intrinsic::returnaddress);
 2578     Function *F = CGM.getIntrinsic(Intrinsic::frameaddress, AllocaInt8PtrTy);
 2614     Function *F =
 2626     Function *F = CGM.getIntrinsic(Intrinsic::eh_unwind_init);
 2671     Function *F = CGM.getIntrinsic(Intrinsic::eh_sjlj_setjmp);
 3127     llvm::Function *F =
 3135     llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::annotation,
 3530     Function *F = CGM.getIntrinsic(Intrinsic::coro_size, T);
 4024     Function *F = CGM.getIntrinsic(Intrinsic::xray_customevent);
 4058     Function *F = CGM.getIntrinsic(Intrinsic::xray_typedevent);
 4156     Function *F = CGM.getIntrinsic(IntrinsicID);
 4341 Value *CodeGenFunction::EmitNeonCall(Function *F, SmallVectorImpl<Value*> &Ops,
 4345   for (Function::const_arg_iterator ai = F->arg_begin(), ae = F->arg_end();
 5133 Function *CodeGenFunction::LookupNeonLLVMIntrinsic(unsigned IntrinsicID,
 5206   Function *F = CGF.LookupNeonLLVMIntrinsic(Int, Modifier, ArgTy, E);
 5210   for (Function::const_arg_iterator ai = F->arg_begin(), ae = F->arg_end();
 5321     Function *F = CGM.getIntrinsic(LLVMIntrinsic, Tys);
 5372     Function *F = CGM.getIntrinsic(Int, Tys);
 5388     Function *F = CGM.getIntrinsic(LLVMIntrinsic, Tys);
 5471     Function *F = CGM.getIntrinsic(Intrinsic::fma, Ty);
 5494     Function *F = CGM.getIntrinsic(LLVMIntrinsic, Tys);
 5513     Function *F = CGM.getIntrinsic(LLVMIntrinsic, Tys);
 5537     Function *F = CGM.getIntrinsic(LLVMIntrinsic, Tys);
 5804   Function *F = LookupNeonLLVMIntrinsic(Int, Modifier, Ty, E);
 5866   Function *TblF;
 5940     llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::read_register, Types);
 5954   llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::write_register, Types);
 6048     Function *F = CGM.getIntrinsic(Intrinsic::prefetch, Address->getType());
 6082     Function *F;
 6116     Function *F;
 6153     Function *F;
 6192     Function *F = CGM.getIntrinsic(BuiltinID == ARM::BI__builtin_arm_ldaex
 6212     Function *F = CGM.getIntrinsic(BuiltinID == ARM::BI__builtin_arm_stlex
 6250     Function *F = CGM.getIntrinsic(BuiltinID == ARM::BI__builtin_arm_stlex
 6258     Function *F = CGM.getIntrinsic(Intrinsic::arm_clrex);
 6294       Function *F = CGM.getIntrinsic(CRCIntrinsicID);
 6300       Function *F = CGM.getIntrinsic(CRCIntrinsicID);
 6446     Function *F = CGM.getIntrinsic(Intrinsic::arm_neon_vrintn, Tys);
 6478     Function *F = CGM.getIntrinsic(BuiltinID == ARM::BI_MoveToCoprocessor ?
 6643     Function *F = CGM.getIntrinsic(Int, Ty);
 6683       Function *F = CGM.getIntrinsic(Intrinsic::arm_neon_vld1, Tys);
 6835     Function *F = CGM.getIntrinsic(IRIntr, makeArrayRef(Tys));
 6877     Function *F = CGM.getIntrinsic(IRIntr, makeArrayRef(Tys));
 7034   Function *F = CGF.CGM.getIntrinsic(Int, Ty);
 7079     Function *F = CGM.getIntrinsic(Intrinsic::aarch64_hint);
 7102     Function *F = CGM.getIntrinsic(Intrinsic::prefetch, Address->getType());
 7155     Function *F = CGM.getIntrinsic(BuiltinID == AArch64::BI__builtin_arm_ldaex
 7183     Function *F = CGM.getIntrinsic(BuiltinID == AArch64::BI__builtin_arm_ldaex
 7201     Function *F = CGM.getIntrinsic(BuiltinID == AArch64::BI__builtin_arm_stlex
 7239     Function *F = CGM.getIntrinsic(BuiltinID == AArch64::BI__builtin_arm_stlex
 7259     llvm::Function *F =
 7265     Function *F = CGM.getIntrinsic(Intrinsic::aarch64_clrex);
 7297     Function *F = CGM.getIntrinsic(CRCIntrinsicID);
 7436       llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::read_register, Types);
 7441     llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::write_register, Types);
 7448     llvm::Function *F =
 7454     llvm::Function *F = CGM.getIntrinsic(Intrinsic::sponentry, AllocaInt8PtrTy);
 7992     Function *F = CGM.getIntrinsic(Intrinsic::fma, HalfTy);
 7998     Function *F = CGM.getIntrinsic(Intrinsic::fma, HalfTy);
 8382       Function *F = CGM.getIntrinsic(Intrinsic::fma, DoubleTy);
 8386     Function *F = CGM.getIntrinsic(Intrinsic::fma, Ty);
 8400     Function *F = CGM.getIntrinsic(Intrinsic::fma, Ty);
 8416     Function *F = CGM.getIntrinsic(Intrinsic::fma, Ty);
 8464     Function *F = CGM.getIntrinsic(Int, Tys);
 9098     llvm::Function *Intrin = CGM.getIntrinsic(Int, Ty);
 9104     llvm::Function *Intrin = CGM.getIntrinsic(Int, Ty);
 9118     Function* F = CGM.getIntrinsic(Int, Ty);
 9171     Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld2, Tys);
 9182     Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld3, Tys);
 9193     Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld4, Tys);
 9205     Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld2r, Tys);
 9217     Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld3r, Tys);
 9229     Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld4r, Tys);
 9238     Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld2lane, Tys);
 9252     Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld3lane, Tys);
 9267     Function *F = CGM.getIntrinsic(Intrinsic::aarch64_neon_ld4lane, Tys);
 9457   llvm::Function *FnGetFieldInfo = llvm::Intrinsic::getDeclaration(
 9547   llvm::Function *F = CGF.CGM.getIntrinsic(Intrinsic::masked_expandload,
 9562   llvm::Function *F = CGF.CGM.getIntrinsic(IID, ResultTy);
 9578   llvm::Function *F = CGF.CGM.getIntrinsic(Intrinsic::masked_compressstore,
 9611   Function *F = CGF.CGM.getIntrinsic(IID, Ty);
 9754     Function *F = CGF.CGM.getIntrinsic(IID, { Ty, Ops[0]->getType() });
 9835     Function *Intr = CGF.CGM.getIntrinsic(IID);
 9839     Function *FMA = CGF.CGM.getIntrinsic(Intrinsic::fma, Ty);
 9910     Function *FMA = CGF.CGM.getIntrinsic(Intrinsic::fma, Ops[0]->getType());
10000   llvm::Function *F = CGF.CGM.getIntrinsic(IID, Ops[0]->getType());
10196     llvm::Function *F = CGM.getIntrinsic(ID);
10221     Function *F = CGM.getIntrinsic(Intrinsic::prefetch, Address->getType());
10252     Function *F = CGM.getIntrinsic(Intrinsic::ctlz, Ops[0]->getType());
10258     Function *F = CGM.getIntrinsic(Intrinsic::cttz, Ops[0]->getType());
10407     llvm::Function *F = CGM.getIntrinsic(Intrinsic::ctpop, ResultType);
10734     Function *Intr = CGM.getIntrinsic(IID);
10842     Function *Intr = CGM.getIntrinsic(IID);
10955     Function *Intr = CGM.getIntrinsic(IID);
11520     Function *Intr = CGM.getIntrinsic(IID);
11548     Function *Intr = CGM.getIntrinsic(IID);
11627     Function *F = CGM.getIntrinsic(Intrinsic::ctlz, Ops[0]->getType());
11633     Function *F = CGM.getIntrinsic(Intrinsic::sqrt, A->getType());
11649     Function *F = CGM.getIntrinsic(Intrinsic::sqrt, A->getType());
11672     Function *F = CGM.getIntrinsic(Intrinsic::sqrt, Ops[0]->getType());
11819     llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_3dnowa_pswapd);
12300     Function *F =
12462     llvm::Function *F = CGM.getIntrinsic(ID);
12524     llvm::Function *F = CGM.getIntrinsic(ID);
12533     llvm::Function *F = CGM.getIntrinsic(ID, ResultType);
12544     Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ResultType);
12554     Function *F = CGM.getIntrinsic(Intrinsic::cttz, ResultType);
12563     llvm::Function *F = CGM.getIntrinsic(Intrinsic::ctpop, ResultType);
12573     llvm::Function *F = CGM.getIntrinsic(ID, ResultType);
12604     llvm::Function *F = CGM.getIntrinsic(ID, ResultType);
12613     llvm::Function *F = CGM.getIntrinsic(Intrinsic::fabs, ResultType);
12631     llvm::Function *F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
12655     llvm::Function *F = CGM.getIntrinsic(Intrinsic::ppc_vsx_xxinsertw);
12698     llvm::Function *F = CGM.getIntrinsic(Intrinsic::ppc_vsx_xxextractuw);
12837     llvm::Function *Callee = CGM.getIntrinsic(Intrinsic::amdgcn_div_scale,
12859     llvm::Function *F = CGM.getIntrinsic(Intrinsic::amdgcn_div_fmas,
12877     Function *F =
12918     Function *F = CGM.getIntrinsic(Intrinsic::amdgcn_frexp_exp,
12924     Function *F = CGM.getIntrinsic(Intrinsic::amdgcn_frexp_exp,
12974     Function *F = CGM.getIntrinsic(Intrin, { Src0->getType() });
13026   Function *F = CGF.CGM.getIntrinsic(IntrinsicID);
13039     Function *F = CGM.getIntrinsic(Intrinsic::s390_tbegin);
13045     Function *F = CGM.getIntrinsic(Intrinsic::s390_tbegin_nofloat);
13051     Function *F = CGM.getIntrinsic(Intrinsic::s390_tbeginc);
13056     Function *F = CGM.getIntrinsic(Intrinsic::s390_tabort);
13062     Function *F = CGM.getIntrinsic(Intrinsic::s390_ntstg);
13077     Function *F = CGM.getIntrinsic(Intrinsic::ctpop, ResultType);
13088     Function *F = CGM.getIntrinsic(Intrinsic::ctlz, ResultType);
13099     Function *F = CGM.getIntrinsic(Intrinsic::cttz, ResultType);
13107     Function *F = CGM.getIntrinsic(Intrinsic::sqrt, ResultType);
13116     Function *F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
13126     Function *F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
13136     Function *F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
13146     Function *F = CGM.getIntrinsic(Intrinsic::fma, ResultType);
13154     Function *F = CGM.getIntrinsic(Intrinsic::fabs, ResultType);
13162     Function *F = CGM.getIntrinsic(Intrinsic::fabs, ResultType);
13198       Function *F = CGM.getIntrinsic(ID, ResultType);
13206     Function *F = CGM.getIntrinsic(ID);
13229       Function *F = CGM.getIntrinsic(ID, ResultType);
13237     Function *F = CGM.getIntrinsic(ID);
13259       Function *F = CGM.getIntrinsic(ID, ResultType);
13267     Function *F = CGM.getIntrinsic(ID);
13277     Function *F = CGM.getIntrinsic(Intrinsic::bswap, ResultType);
13702     Function *FnALI32 =
13710     Function *FnALD32 =
13962     Function *Intrinsic =
14022     Function *Intrinsic = CGM.getIntrinsic(IID);
14071     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_size, ResultType);
14080     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_grow, ResultType);
14096     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_memory_init);
14104     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_data_drop);
14109     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_tls_size, ResultType);
14114     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_tls_align, ResultType);
14118     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_tls_base);
14124     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_throw);
14128     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_rethrow_in_catch);
14135     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_atomic_wait_i32);
14142     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_atomic_wait_i64);
14148     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_atomic_notify);
14157     Function *Callee =
14167     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_trunc_unsigned,
14179     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_trunc_saturate_signed,
14191     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_trunc_saturate_unsigned,
14201     Function *Callee = CGM.getIntrinsic(Intrinsic::minimum,
14211     Function *Callee = CGM.getIntrinsic(Intrinsic::maximum,
14218     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_swizzle);
14310     Function *Callee = CGM.getIntrinsic(IntNo, ConvertType(E->getType()));
14317     Function *Callee = CGM.getIntrinsic(Intrinsic::wasm_bitselect,
14347     Function *Callee = CGM.getIntrinsic(IntNo, Vec->getType());
14353     Function *Callee = CGM.getIntrinsic(Intrinsic::fabs, Vec->getType());
14359     Function *Callee = CGM.getIntrinsic(Intrinsic::sqrt, Vec->getType());
14382     Function *Callee = CGM.getIntrinsic(IntNo, A->getType());
14404     Function *Callee =
14438     Function *Callee =
tools/clang/lib/CodeGen/CGCUDANV.cpp
   46     llvm::Function *Kernel;
   75   llvm::Function *makeRegisterGlobalsFn();
  103   llvm::Function *makeDummyFunction(llvm::FunctionType *FnTy) {
  106     llvm::Function *DummyFunc = llvm::Function::Create(
  106     llvm::Function *DummyFunc = llvm::Function::Create(
  132   llvm::Function *makeModuleCtorFunction() override;
  134   llvm::Function *makeModuleDtorFunction() override;
  394 llvm::Function *CGNVCUDARuntime::makeRegisterGlobalsFn() {
  399   llvm::Function *RegisterKernelsFunc = llvm::Function::Create(
  399   llvm::Function *RegisterKernelsFunc = llvm::Function::Create(
  486 llvm::Function *CGNVCUDARuntime::makeModuleCtorFunction() {
  498   llvm::Function *RegisterGlobalsFunc = makeRegisterGlobalsFn();
  528   llvm::Function *ModuleCtorFunc = llvm::Function::Create(
  528   llvm::Function *ModuleCtorFunc = llvm::Function::Create(
  719   if (llvm::Function *CleanupFn = makeModuleDtorFunction()) {
  752 llvm::Function *CGNVCUDARuntime::makeModuleDtorFunction() {
  762   llvm::Function *ModuleDtorFunc = llvm::Function::Create(
  762   llvm::Function *ModuleDtorFunc = llvm::Function::Create(
tools/clang/lib/CodeGen/CGCUDARuntime.h
   63   virtual llvm::Function *makeModuleCtorFunction() = 0;
   67   virtual llvm::Function *makeModuleDtorFunction() = 0;
tools/clang/lib/CodeGen/CGCXX.cpp
  206 llvm::Function *CodeGenModule::codegenCXXStructor(GlobalDecl GD) {
  208   auto *Fn = cast<llvm::Function>(
  208   auto *Fn = cast<llvm::Function>(
tools/clang/lib/CodeGen/CGCXXABI.h
  444   virtual void setThunkLinkage(llvm::Function *Thunk, bool ForVTable,
  575       ArrayRef<llvm::Function *> CXXThreadLocalInits,
tools/clang/lib/CodeGen/CGCall.cpp
 1813 void CodeGenModule::AddDefaultFnAttrs(llvm::Function &F) {
 2223                                          llvm::Function *Fn,
 2825       llvm::Function::arg_iterator EI = CurFn->arg_end();
 3338   llvm::Function *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stacksave);
 3345     llvm::Function *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stackrestore);
 3689   auto *CalleeFn = dyn_cast<llvm::Function>(Callee->stripPointerCasts());
 3689   auto *CalleeFn = dyn_cast<llvm::Function>(Callee->stripPointerCasts());
 4246     llvm::Function *OrigFn = dyn_cast<llvm::Function>(Ptr);
 4246     llvm::Function *OrigFn = dyn_cast<llvm::Function>(Ptr);
 4266   if (llvm::Function *OrigFn = simplifyVariadicCallee(IRFuncTy, CalleePtr)) {
 4420       if (auto *F = CI->getCalledFunction())
tools/clang/lib/CodeGen/CGCoroutine.cpp
  197   llvm::Function *CoroSave = CGF.CGM.getIntrinsic(llvm::Intrinsic::coro_save);
  212   llvm::Function *CoroSuspend =
  400     llvm::Function *CoroEndFn = CGM.getIntrinsic(llvm::Intrinsic::coro_end);
  688   llvm::Function *CoroEnd = CGM.getIntrinsic(llvm::Intrinsic::coro_end);
  737   llvm::Function *F = CGM.getIntrinsic(IID);
tools/clang/lib/CodeGen/CGDebugInfo.cpp
 1921                                                  llvm::Function *InitFn) {
 3537                                     llvm::Function *Fn, bool CurFuncIsThunk,
 3659                                    QualType FnType, llvm::Function *Fn) {
 3717   auto *Func = CallOrInvoke->getCalledFunction();
 3816 void CGDebugInfo::EmitFunctionEnd(CGBuilderTy &Builder, llvm::Function *Fn) {
tools/clang/lib/CodeGen/CGDebugInfo.h
  403                          llvm::Function *Fn, bool CurFnIsThunk,
  414                         QualType FnType, llvm::Function *Fn = nullptr);
  423   void EmitFunctionEnd(CGBuilderTy &Builder, llvm::Function *Fn);
  670                                       llvm::Function *InitFn);
tools/clang/lib/CodeGen/CGDecl.cpp
  538       llvm::Function *F = CGF.CGM.getIntrinsic(llvm::Intrinsic::stackrestore);
 1529       llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::stacksave);
 2307 llvm::Function *CodeGenModule::getLLVMLifetimeStartFn() {
 2316 llvm::Function *CodeGenModule::getLLVMLifetimeEndFn() {
tools/clang/lib/CodeGen/CGDeclCXX.cpp
  163   llvm::Function *InvariantStart = CGM.getIntrinsic(InvStartID, ObjectPtr);
  228 llvm::Function *CodeGenFunction::createAtExitStub(const VarDecl &VD,
  240   llvm::Function *fn = CGM.CreateGlobalInitOrDestructFunction(
  251   if (auto *dtorFn = dyn_cast<llvm::Function>(
  251   if (auto *dtorFn = dyn_cast<llvm::Function>(
  277   if (llvm::Function *atexitFn = dyn_cast<llvm::Function>(atexit.getCallee()))
  277   if (llvm::Function *atexitFn = dyn_cast<llvm::Function>(atexit.getCallee()))
  334 llvm::Function *CodeGenModule::CreateGlobalInitOrDestructFunction(
  337   llvm::Function *Fn =
  338     llvm::Function::Create(FTy, llvm::GlobalValue::InternalLinkage,
  417                                           llvm::Function *InitFunc,
  462   llvm::Function *Fn =
  547     SmallVector<llvm::Function *, 8> LocalCXXGlobalInits;
  566       llvm::Function *Fn = CreateGlobalInitOrDestructFunction(
  592   llvm::Function *Fn = CreateGlobalInitOrDestructFunction(
  627   llvm::Function *Fn =
  635 void CodeGenFunction::GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
  669 CodeGenFunction::GenerateCXXGlobalInitFunc(llvm::Function *Fn,
  670                                            ArrayRef<llvm::Function *> Decls,
  728     llvm::Function *Fn,
  746       if (llvm::Function *F = dyn_cast<llvm::Function>(Callee))
  746       if (llvm::Function *F = dyn_cast<llvm::Function>(Callee))
  757 llvm::Function *CodeGenFunction::generateDestroyHelper(
  768   llvm::Function *fn = CGM.CreateGlobalInitOrDestructFunction(
tools/clang/lib/CodeGen/CGException.cpp
  299     llvm::Function *F = dyn_cast<llvm::Function>(U);
  299     llvm::Function *F = dyn_cast<llvm::Function>(U);
  334   llvm::Function *Fn = getModule().getFunction(ObjCXX.PersonalityFn);
  977   llvm::Function *GetExnFn =
  979   llvm::Function *GetSelectorFn =
  985   llvm::Function *TypeIDFn = CGF.CGM.getIntrinsic(llvm::Intrinsic::eh_typeid_for);
 1069   llvm::Function *llvm_eh_typeid_for =
 1259     llvm::Function *RethrowInCatchFn =
 1545     llvm::Function *GetExnFn =
 1615   llvm::Function *OutlinedFinally;
 1616   PerformSEHFinally(llvm::Function *OutlinedFinally)
 1632       llvm::Function *LocalAddrFn =
 1723     llvm::Function *FrameRecoverFn = llvm::Intrinsic::getDeclaration(
 1789     llvm::Function *RecoverFPIntrin =
 1878   llvm::Function *Fn = llvm::Function::Create(
 1878   llvm::Function *Fn = llvm::Function::Create(
 1894 llvm::Function *
 1911 llvm::Function *
 1986                                      llvm::Function *FinallyFunc) {
 1994     llvm::Function *FinallyFunc =
 2023   llvm::Function *FilterFunc =
 2078     llvm::Function *SEHCodeIntrin =
tools/clang/lib/CodeGen/CGExpr.cpp
  727       llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, Tys);
 1915   llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::read_register, Types);
 2176   llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::write_register, Types);
 3166   llvm::Function *F = llvm::Function::Create(
 3166   llvm::Function *F = llvm::Function::Create(
 3200   llvm::Function *F = llvm::Function::Create(
 3200   llvm::Function *F = llvm::Function::Create(
tools/clang/lib/CodeGen/CGExprCXX.cpp
  862       llvm::Function *umul_with_overflow
  902       llvm::Function *uadd_with_overflow
 1302   llvm::Function *Fn = dyn_cast<llvm::Function>(CalleePtr);
 1302   llvm::Function *Fn = dyn_cast<llvm::Function>(CalleePtr);
tools/clang/lib/CodeGen/CGExprScalar.cpp
 3086   llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, opTy);
 3805       llvm::Function *F = CGF.CGM.getIntrinsic(ID);
 4586   auto *SAddIntrinsic =
 4588   auto *SMulIntrinsic =
tools/clang/lib/CodeGen/CGGPUBuiltin.cpp
   23 static llvm::Function *GetVprintfDeclaration(llvm::Module &M) {
   29   if (auto* F = M.getFunction("vprintf")) {
   39   return llvm::Function::Create(
  119   llvm::Function* VprintfFunc = GetVprintfDeclaration(CGM.getModule());
tools/clang/lib/CodeGen/CGNonTrivialStruct.cpp
  427   llvm::Function *
  431     if (llvm::Function *F = CGM.getModule().getFunction(FuncName)) {
  455     llvm::Function *F =
  456         llvm::Function::Create(FuncTy, llvm::GlobalValue::LinkOnceODRLinkage,
  493     if (llvm::Function *F =
  838 static llvm::Function *
  935 llvm::Function *clang::CodeGen::getNonTrivialCStructDefaultConstructor(
  944 llvm::Function *clang::CodeGen::getNonTrivialCStructCopyConstructor(
  956 llvm::Function *clang::CodeGen::getNonTrivialCStructMoveConstructor(
  968 llvm::Function *clang::CodeGen::getNonTrivialCStructCopyAssignmentOperator(
  980 llvm::Function *clang::CodeGen::getNonTrivialCStructMoveAssignmentOperator(
  992 llvm::Function *clang::CodeGen::getNonTrivialCStructDestructor(
tools/clang/lib/CodeGen/CGObjC.cpp
  683   llvm::Function *Fn = CGM.getObjCRuntime().GenerateMethod(OMD, CD);
 1954   llvm::Function *&fn = CGM.getObjCEntrypoints().clang_arc_use;
 1964   if (auto *F = dyn_cast<llvm::Function>(RTF)) {
 1964   if (auto *F = dyn_cast<llvm::Function>(RTF)) {
 1970       F->setLinkage(llvm::Function::ExternalWeakLinkage);
 1985     llvm::Function *&fn, llvm::Intrinsic::ID IntID,
 2010                                          llvm::Function *&fn,
 2035                                           llvm::Function *&fn,
 2061                                  llvm::Function *&fn,
 2094     if (llvm::Function *f = dyn_cast<llvm::Function>(fn.getCallee()))
 2094     if (llvm::Function *f = dyn_cast<llvm::Function>(fn.getCallee()))
 2235   llvm::Function *&fn = CGM.getObjCEntrypoints().objc_release;
 2281   llvm::Function *&fn = CGM.getObjCEntrypoints().objc_storeStrong;
 2437   llvm::Function *&fn = CGM.getObjCEntrypoints().objc_destroyWeak;
 2485   llvm::Function *&fn = CGM.getObjCEntrypoints().objc_autoreleasePoolPush;
 2643     if (llvm::Function *f = dyn_cast<llvm::Function>(fn.getCallee()))
 2643     if (llvm::Function *f = dyn_cast<llvm::Function>(fn.getCallee()))
 3534   llvm::Function *Fn =
 3535     llvm::Function::Create(LTy, llvm::GlobalValue::InternalLinkage,
 3618   llvm::Function *Fn = llvm::Function::Create(
 3618   llvm::Function *Fn = llvm::Function::Create(
 3739   llvm::Function *CFLinkCheckFunc =
 3740       cast<llvm::Function>(CFLinkCheckFuncRef.getCallee()->stripPointerCasts());
tools/clang/lib/CodeGen/CGObjCGNU.cpp
  607   llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
  615   llvm::Function *ModuleInitFunction() override;
  768       if (auto *LookupFn2 = dyn_cast<llvm::Function>(LookupFn.getCallee()))
  768       if (auto *LookupFn2 = dyn_cast<llvm::Function>(LookupFn.getCallee()))
 1520   llvm::Function *ModuleInitFunction() override {
 1521     llvm::Function *LoadFunction = llvm::Function::Create(
 1521     llvm::Function *LoadFunction = llvm::Function::Create(
 1637       auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.VoidTy,
 1637       auto *Init = llvm::Function::Create(llvm::FunctionType::get(CGM.VoidTy,
 3605 llvm::Function *CGObjCGNU::ModuleInitFunction() {
 3795   llvm::Function * LoadFunction = llvm::Function::Create(
 3795   llvm::Function * LoadFunction = llvm::Function::Create(
 3815     llvm::Function *RegisterAlias = llvm::Function::Create(
 3815     llvm::Function *RegisterAlias = llvm::Function::Create(
 3853 llvm::Function *CGObjCGNU::GenerateMethod(const ObjCMethodDecl *OMD,
 3868   llvm::Function *Method
 3869     = llvm::Function::Create(MethodTy,
tools/clang/lib/CodeGen/CGObjCMac.cpp
  745       cast<llvm::Function>(F.getCallee())->setLinkage(
  746         llvm::Function::ExternalWeakLinkage);
  875   llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*> MethodDefinitions;
  954   llvm::Function *GetMethodDefinition(const ObjCMethodDecl *MD);
 1092   llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
 1313   llvm::Function *ModuleInitFunction() override;
 1598   llvm::Function *ModuleInitFunction() override;
 3859   llvm::Function *fn = GetMethodDefinition(MD);
 3971 llvm::Function *CGObjCCommonMac::GenerateMethod(const ObjCMethodDecl *OMD,
 3979   llvm::Function *Method =
 3980     llvm::Function::Create(MethodTy,
 4071 llvm::Function *CGObjCMac::ModuleInitFunction() {
 4212   for (llvm::Function::iterator
 4270   for (llvm::Function::iterator
 5148 llvm::Function *CGObjCCommonMac::GetMethodDefinition(const ObjCMethodDecl *MD) {
 5149   llvm::DenseMap<const ObjCMethodDecl*, llvm::Function*>::iterator
 6044 llvm::Function *CGObjCNonFragileABIMac::ModuleInitFunction() {
 6640     llvm::Function *fn = GetMethodDefinition(MD);
tools/clang/lib/CodeGen/CGObjCRuntime.cpp
  207         llvm::Function *FinallyFunc = HelperCGF.CurFn;
tools/clang/lib/CodeGen/CGObjCRuntime.h
  120   virtual llvm::Function *ModuleInitFunction() = 0;
  205   virtual llvm::Function *GenerateMethod(const ObjCMethodDecl *OMD,
tools/clang/lib/CodeGen/CGOpenCLRuntime.cpp
  145                                       llvm::Function *InvokeF,
  156 llvm::Function *CGOpenCLRuntime::getInvokeFunction(const Expr *E) {
  176   auto *F = CGF.getTargetHooks().createEnqueuedBlockKernel(
tools/clang/lib/CodeGen/CGOpenCLRuntime.h
   44     llvm::Function *InvokeFunc; /// Block invoke function.
   45     llvm::Function *Kernel;     /// Enqueued block kernel.
   92   void recordBlockInfo(const BlockExpr *E, llvm::Function *InvokeF,
   97   llvm::Function *getInvokeFunction(const Expr *E);
tools/clang/lib/CodeGen/CGOpenMPRuntime.cpp
  808     std::pair<llvm::Function *, llvm::Function *> Reduction =
  808     std::pair<llvm::Function *, llvm::Function *> Reduction =
 1305       GA->setLinkage(llvm::Function::WeakAnyLinkage);
 1347 static llvm::Function *
 1366   auto *Fn = llvm::Function::Create(FnTy, llvm::GlobalValue::InternalLinkage,
 1366   auto *Fn = llvm::Function::Create(FnTy, llvm::GlobalValue::InternalLinkage,
 1408   llvm::Function *Combiner = emitCombinerOrInitializer(
 1413   llvm::Function *Initializer = nullptr;
 1430 std::pair<llvm::Function *, llvm::Function *>
 1430 std::pair<llvm::Function *, llvm::Function *>
 1439 static llvm::Function *emitParallelOrTeamsOutlinedFunction(
 1469 llvm::Function *CGOpenMPRuntime::emitParallelOutlinedFunction(
 1477 llvm::Function *CGOpenMPRuntime::emitTeamsOutlinedFunction(
 1485 llvm::Function *CGOpenMPRuntime::emitTaskOutlinedFunction(
 1516   llvm::Function *Res = CGF.GenerateCapturedStmtFunction(*CS);
 1786     if (auto *F = dyn_cast<llvm::Function>(RTLFn.getCallee())) {
 1786     if (auto *F = dyn_cast<llvm::Function>(RTLFn.getCallee())) {
 2224     if (auto *F = dyn_cast<llvm::Function>(RTLFn.getCallee())) {
 2224     if (auto *F = dyn_cast<llvm::Function>(RTLFn.getCallee())) {
 2754 llvm::Function *CGOpenMPRuntime::emitThreadPrivateVarDefinition(
 2781       llvm::Function *Fn =
 2814       llvm::Function *Fn =
 2858       llvm::Function *InitFunction = CGM.CreateGlobalInitOrDestructFunction(
 2918       llvm::Function *Fn = CGM.CreateGlobalInitOrDestructFunction(
 2956       llvm::Function *Fn = CGM.CreateGlobalInitOrDestructFunction(
 3051                                        llvm::Function *OutlinedFn,
 3305   auto *Fn = llvm::Function::Create(CGM.getTypes().GetFunctionType(CGFI),
 3305   auto *Fn = llvm::Function::Create(CGM.getTypes().GetFunctionType(CGFI),
 4494 static llvm::Function *
 4499                       QualType SharedsPtrTy, llvm::Function *TaskFunction,
 4515   auto *TaskEntry = llvm::Function::Create(
 4515   auto *TaskEntry = llvm::Function::Create(
 4618   auto *DestructorFn =
 4619       llvm::Function::Create(DestructorFnTy, llvm::GlobalValue::InternalLinkage,
 4712   auto *TaskPrivatesMap = llvm::Function::Create(
 4712   auto *TaskPrivatesMap = llvm::Function::Create(
 4902   auto *TaskDup = llvm::Function::Create(
 4902   auto *TaskDup = llvm::Function::Create(
 4964                               llvm::Function *TaskFunction, QualType SharedsTy,
 5054   llvm::Function *TaskEntry = emitProxyTaskFunction(
 5183                                    llvm::Function *TaskFunction,
 5193   llvm::Function *TaskEntry = Result.TaskEntry;
 5378                                        llvm::Function *TaskFunction,
 5548           std::pair<llvm::Function *, llvm::Function *> Reduction =
 5548           std::pair<llvm::Function *, llvm::Function *> Reduction =
 5558 llvm::Function *CGOpenMPRuntime::emitReductionFunction(
 5575   auto *Fn = llvm::Function::Create(CGM.getTypes().GetFunctionType(CGFI),
 5575   auto *Fn = llvm::Function::Create(CGM.getTypes().GetFunctionType(CGFI),
 5771   llvm::Function *ReductionFn = emitReductionFunction(
 6012   auto *Fn = llvm::Function::Create(FnTy, llvm::GlobalValue::InternalLinkage,
 6012   auto *Fn = llvm::Function::Create(FnTy, llvm::GlobalValue::InternalLinkage,
 6089   auto *Fn = llvm::Function::Create(FnTy, llvm::GlobalValue::InternalLinkage,
 6089   auto *Fn = llvm::Function::Create(FnTy, llvm::GlobalValue::InternalLinkage,
 6159   auto *Fn = llvm::Function::Create(FnTy, llvm::GlobalValue::InternalLinkage,
 6159   auto *Fn = llvm::Function::Create(FnTy, llvm::GlobalValue::InternalLinkage,
 6463     llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID,
 6473     llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID,
 8868   auto *Fn = llvm::Function::Create(FnTy, llvm::GlobalValue::InternalLinkage,
 8868   auto *Fn = llvm::Function::Create(FnTy, llvm::GlobalValue::InternalLinkage,
 9161     llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond,
 9844       if (auto *F = dyn_cast_or_null<llvm::Function>(CGM.GetGlobalValue(Name)))
 9844       if (auto *F = dyn_cast_or_null<llvm::Function>(CGM.GetGlobalValue(Name)))
 9854 llvm::Function *CGOpenMPRuntime::emitRequiresDirectiveRegFun() {
 9867   llvm::Function *RequiresRegFn;
 9898                                     llvm::Function *OutlinedFn,
10295 emitX86DeclareSimdFunction(const FunctionDecl *FD, llvm::Function *Fn,
10514                                  llvm::Function *Fn) {
10530                                       llvm::Function *Fn) {
10565     char ISA, unsigned VecRegSize, llvm::Function *Fn, SourceLocation SLoc) {
10670                                               llvm::Function *Fn) {
10914   if (auto *Fn = dyn_cast<llvm::Function>(Callee.getCallee())) {
10914   if (auto *Fn = dyn_cast<llvm::Function>(Callee.getCallee())) {
11146 llvm::Function *CGOpenMPSIMDRuntime::emitParallelOutlinedFunction(
11152 llvm::Function *CGOpenMPSIMDRuntime::emitTeamsOutlinedFunction(
11158 llvm::Function *CGOpenMPSIMDRuntime::emitTaskOutlinedFunction(
11168                                            llvm::Function *OutlinedFn,
11280 llvm::Function *CGOpenMPSIMDRuntime::emitThreadPrivateVarDefinition(
11299                                        llvm::Function *TaskFunction,
11308     llvm::Function *TaskFunction, QualType SharedsTy, Address Shareds,
11361     llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID,
11368     llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID, const Expr *IfCond,
11391                                         llvm::Function *OutlinedFn,
tools/clang/lib/CodeGen/CGOpenMPRuntime.h
  239                                                 llvm::Function *&OutlinedFn,
  346   typedef llvm::DenseMap<llvm::Function *, DebugLocThreadIdTy>
  351                          std::pair<llvm::Function *, llvm::Function *>>
  351                          std::pair<llvm::Function *, llvm::Function *>>
  355   typedef llvm::DenseMap<llvm::Function *,
  361   llvm::DenseMap<const OMPDeclareMapperDecl *, llvm::Function *> UDMMap;
  364       llvm::DenseMap<llvm::Function *,
  768     llvm::Function *TaskEntry = nullptr;
  798                             llvm::Function *TaskFunction, QualType SharedsTy,
  834   virtual std::pair<llvm::Function *, llvm::Function *>
  834   virtual std::pair<llvm::Function *, llvm::Function *>
  849   virtual llvm::Function *emitParallelOutlinedFunction(
  861   virtual llvm::Function *emitTeamsOutlinedFunction(
  880   virtual llvm::Function *emitTaskOutlinedFunction(
  901                                 llvm::Function *OutlinedFn,
 1175   virtual llvm::Function *
 1230                             llvm::Function *TaskFunction, QualType SharedsTy,
 1265                                 llvm::Function *TaskFunction,
 1288   llvm::Function *emitReductionFunction(SourceLocation Loc,
 1432                                           llvm::Function *&OutlinedFn,
 1451                  llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID,
 1485   llvm::Function *emitRequiresDirectiveRegFun();
 1501                              SourceLocation Loc, llvm::Function *OutlinedFn,
 1583                                        llvm::Function *Fn);
 1682   llvm::Function *
 1696   llvm::Function *
 1717   llvm::Function *emitTaskOutlinedFunction(
 1734                         llvm::Function *OutlinedFn,
 1914   llvm::Function *
 1961                     llvm::Function *TaskFunction, QualType SharedsTy,
 1995                         const OMPLoopDirective &D, llvm::Function *TaskFunction,
 2122                                   llvm::Function *&OutlinedFn,
 2139                  llvm::Function *OutlinedFn, llvm::Value *OutlinedFnID,
 2170                      SourceLocation Loc, llvm::Function *OutlinedFn,
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.cpp
  704   WorkerFn = llvm::Function::Create(
 1140                                              llvm::Function *&OutlinedFn,
 1272                                           llvm::Function *&OutlinedFn,
 1459   for (llvm::Function *W : Work) {
 1840   if (!isa<llvm::Function>(Addr))
 1858     llvm::Function *&OutlinedFn, llvm::Constant *&OutlinedFnID,
 1951 llvm::Function *CGOpenMPRuntimeNVPTX::emitParallelOutlinedFunction(
 1975   auto *OutlinedFun =
 1976       cast<llvm::Function>(CGOpenMPRuntime::emitParallelOutlinedFunction(
 1987     llvm::Function *WrapperFun =
 2033 llvm::Function *CGOpenMPRuntimeNVPTX::emitTeamsOutlinedFunction(
 2097   llvm::Function *OutlinedFun = CGOpenMPRuntime::emitTeamsOutlinedFunction(
 2458                                          llvm::Function *OutlinedFn,
 2474     CodeGenFunction &CGF, SourceLocation Loc, llvm::Function *OutlinedFn,
 2488   llvm::Function *Fn = cast<llvm::Function>(OutlinedFn);
 2488   llvm::Function *Fn = cast<llvm::Function>(OutlinedFn);
 2532     llvm::Function *WFn = WrapperFunctionsMap[Fn];
 2655     CodeGenFunction &CGF, SourceLocation Loc, llvm::Function *OutlinedFn,
 3190   auto *Fn = llvm::Function::Create(CGM.getTypes().GetFunctionType(CGFI),
 3190   auto *Fn = llvm::Function::Create(CGM.getTypes().GetFunctionType(CGFI),
 3459 static llvm::Function *emitShuffleAndReduceFunction(
 3461     QualType ReductionArrayTy, llvm::Function *ReduceFn, SourceLocation Loc) {
 3484   auto *Fn = llvm::Function::Create(
 3484   auto *Fn = llvm::Function::Create(
 3645   auto *Fn = llvm::Function::Create(
 3645   auto *Fn = llvm::Function::Create(
 3732     llvm::Function *ReduceFn) {
 3751   auto *Fn = llvm::Function::Create(
 3751   auto *Fn = llvm::Function::Create(
 3845   auto *Fn = llvm::Function::Create(
 3845   auto *Fn = llvm::Function::Create(
 3932     llvm::Function *ReduceFn) {
 3951   auto *Fn = llvm::Function::Create(
 3951   auto *Fn = llvm::Function::Create(
 4327   llvm::Function *ReductionFn = emitReductionFunction(
 4331   llvm::Function *ShuffleAndReduceFn = emitShuffleAndReduceFunction(
 4538 llvm::Function *CGOpenMPRuntimeNVPTX::createParallelDataSharingWrapper(
 4539     llvm::Function *OutlinedParallelFn, const OMPExecutableDirective &D) {
 4561   auto *Fn = llvm::Function::Create(
 4561   auto *Fn = llvm::Function::Create(
tools/clang/lib/CodeGen/CGOpenMPRuntimeNVPTX.h
   37   llvm::SmallVector<llvm::Function *, 16> Work;
   45     llvm::Function *WorkerFn;
  111                          llvm::Function *&OutlinedFn,
  127                       llvm::Function *&OutlinedFn,
  142                                   llvm::Function *&OutlinedFn,
  174                             llvm::Function *OutlinedFn,
  243   llvm::Function *
  258   llvm::Function *
  273                      SourceLocation Loc, llvm::Function *OutlinedFn,
  286                         llvm::Function *OutlinedFn,
  429   llvm::DenseMap<llvm::Function *, llvm::Function *> WrapperFunctionsMap;
  429   llvm::DenseMap<llvm::Function *, llvm::Function *> WrapperFunctionsMap;
  435   llvm::Function *createParallelDataSharingWrapper(
  436       llvm::Function *OutlinedParallelFn, const OMPExecutableDirective &D);
  469   llvm::SmallDenseMap<llvm::Function *, FunctionData> FunctionGlobalizedDecls;
tools/clang/lib/CodeGen/CGStmt.cpp
 2375 llvm::Function *
 2382   llvm::Function *F = CGF.GenerateCapturedStmtFunction(S);
 2397 llvm::Function *
 2416   llvm::Function *F =
 2417     llvm::Function::Create(FuncLLVMTy, llvm::GlobalValue::InternalLinkage,
tools/clang/lib/CodeGen/CGStmtOpenMP.cpp
  383 static llvm::Function *emitOutlinedFunctionPrologue(
  472   auto *F =
  473       llvm::Function::Create(FuncLLVMTy, llvm::GlobalValue::InternalLinkage,
  556 llvm::Function *
  576   llvm::Function *F = emitOutlinedFunctionPrologue(*this, Args, LocalAddrs,
  604   llvm::Function *WrapperF =
 1274   llvm::Function *OutlinedFn =
 2284   llvm::Function *Fn;
 3124   llvm::Function *OutlinedFn = CGM.getOpenMPRuntime().emitTaskOutlinedFunction(
 3267   llvm::Function *OutlinedFn = CGM.getOpenMPRuntime().emitTaskOutlinedFunction(
 3603 static llvm::Function *emitOutlinedOrderedFunction(CodeGenModule &CGM,
 3608   llvm::Function *Fn = CGF.GenerateOpenMPCapturedStmtFunction(*S);
 3628       llvm::Function *OutlinedFn = emitOutlinedOrderedFunction(CGM, CS);
 4130   llvm::Function *Fn = nullptr;
 4212   llvm::Function *Fn;
 4232   llvm::Function *OutlinedFn =
 4298   llvm::Function *Fn;
 4344   llvm::Function *Fn;
 4390   llvm::Function *Fn;
 4532   llvm::Function *Fn;
 4584   llvm::Function *Fn;
 4860   llvm::Function *Fn;
 4900   llvm::Function *Fn;
 4939   llvm::Function *Fn;
tools/clang/lib/CodeGen/CGVTables.cpp
   40                                llvm::Function *ThunkFn, bool ForVTable,
  117 static void resolveTopLevelMetadata(llvm::Function *Fn,
  155 llvm::Function *
  156 CodeGenFunction::GenerateVarArgsThunk(llvm::Function *Fn,
  167   llvm::Function *BaseFn = cast<llvm::Function>(Callee);
  167   llvm::Function *BaseFn = cast<llvm::Function>(Callee);
  184   llvm::Function *NewFn = llvm::CloneFunction(BaseFn, VMap);
  194   llvm::Function::arg_iterator AI = Fn->arg_begin();
  235 void CodeGenFunction::StartThunk(llvm::Function *Fn, GlobalDecl GD,
  442 void CodeGenFunction::generateThunk(llvm::Function *Fn,
  520   llvm::Function *ThunkFn = cast<llvm::Function>(Thunk->stripPointerCasts());
  520   llvm::Function *ThunkFn = cast<llvm::Function>(Thunk->stripPointerCasts());
  528     ThunkFn = llvm::Function::Create(ThunkFnTy, llvm::Function::ExternalLinkage,
  528     ThunkFn = llvm::Function::Create(ThunkFnTy, llvm::Function::ExternalLinkage,
  683       if (auto f = dyn_cast<llvm::Function>(fn))
  853                    llvm::Function::InternalLinkage;
  860                  llvm::Function::InternalLinkage;
  865                  llvm::Function::InternalLinkage;
  875     return llvm::Function::InternalLinkage;
tools/clang/lib/CodeGen/CodeGenAction.cpp
  207           for (Function &F : *LM.Module)
tools/clang/lib/CodeGen/CodeGenFunction.cpp
  379     llvm::Function *FrameEscapeFn = llvm::Intrinsic::getDeclaration(
  500 CodeGenFunction::EncodeAddrForUseInPrologue(llvm::Function *F,
  537                                                llvm::Function *Fn)
  602 void CodeGenFunction::markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn) {
  640                                     llvm::Function *Fn,
  920     llvm::Function::arg_iterator EI = CurFn->arg_end();
 1072 static void TryMarkNoThrow(llvm::Function *F) {
 1141 void CodeGenFunction::GenerateCode(GlobalDecl GD, llvm::Function *Fn,
 2073 llvm::Value *CodeGenFunction::EmitAnnotationCall(llvm::Function *AnnotationFn,
 2101   llvm::Function *F = CGM.getIntrinsic(llvm::Intrinsic::ptr_annotation,
 2265                                              llvm::Function *Resolver,
 2267                                              llvm::Function *FuncToReturn,
 2288     llvm::Function *Resolver, ArrayRef<MultiVersionResolverOption> Options) {
tools/clang/lib/CodeGen/CodeGenFunction.h
  300   llvm::Function *CurFn = nullptr;
 1610                                 llvm::Function *Fn);
 1697   llvm::Function *generateDestroyHelper(Address addr, QualType type,
 1767   llvm::Function *GenerateBlockFunction(GlobalDecl GD,
 1829   void GenerateCode(GlobalDecl GD, llvm::Function *Fn,
 1834   void markAsIgnoreThreadCheckingAtRuntime(llvm::Function *Fn);
 1841                      llvm::Function *Fn,
 1875   void StartThunk(llvm::Function *Fn, GlobalDecl GD,
 1888   void generateThunk(llvm::Function *Fn, const CGFunctionInfo &FnInfo,
 1892   llvm::Function *GenerateVarArgsThunk(llvm::Function *Fn,
 1892   llvm::Function *GenerateVarArgsThunk(llvm::Function *Fn,
 1995   llvm::Constant *EncodeAddrForUseInPrologue(llvm::Function *F,
 2007                           llvm::Function *Fn,
 2062                                      llvm::Function *parent = nullptr,
 2919                       llvm::Function *FinallyFunc);
 2923   llvm::Function *GenerateSEHFilterFunction(CodeGenFunction &ParentCGF,
 2926   llvm::Function *GenerateSEHFinallyFunction(CodeGenFunction &ParentCGF,
 2973   llvm::Function *EmitCapturedStmt(const CapturedStmt &S, CapturedRegionKind K);
 2974   llvm::Function *GenerateCapturedStmtFunction(const CapturedStmt &S);
 2976   llvm::Function *GenerateOpenMPCapturedStmtFunction(const CapturedStmt &S);
 3101                                         llvm::Function * /*OutlinedFn*/,
 3721   llvm::Function *generateBuiltinOSLogHelperFunction(
 3753   llvm::Function *LookupNeonLLVMIntrinsic(unsigned IntrinsicID,
 3756   llvm::Value *EmitNeonCall(llvm::Function *F,
 3948   llvm::Function *createAtExitStub(const VarDecl &VD, llvm::FunctionCallee Dtor,
 3978   GenerateCXXGlobalInitFunc(llvm::Function *Fn,
 3979                             ArrayRef<llvm::Function *> CXXThreadLocals,
 3985       llvm::Function *Fn,
 3989   void GenerateCXXGlobalVarDeclInitFunc(llvm::Function *Fn,
 4015   llvm::Value *EmitAnnotationCall(llvm::Function *AnnotationFn,
 4329     llvm::Function *Function;
 4339     MultiVersionResolverOption(llvm::Function *F, StringRef Arch,
 4347   void EmitMultiVersionResolver(llvm::Function *Resolver,
tools/clang/lib/CodeGen/CodeGenModule.cpp
  236     auto *OldF = cast<llvm::Function>(Entry);
  236     auto *OldF = cast<llvm::Function>(Entry);
  237     auto *NewF = dyn_cast<llvm::Function>(Replacement);
  237     auto *NewF = dyn_cast<llvm::Function>(Replacement);
  240         NewF = dyn_cast<llvm::Function>(Alias->getAliasee());
  245         NewF = dyn_cast<llvm::Function>(CE->getOperand(0));
  404     if (llvm::Function *ObjCInitFunction = ObjCRuntime->ModuleInitFunction())
  408     if (llvm::Function *CudaCtorFunction =
  413     if (llvm::Function *OpenMPRequiresDirectiveRegFun =
  847   if (isa<llvm::Function>(GV) && !CGOpts.NoPLT && RM == llvm::Reloc::Static)
 1132 void CodeGenModule::AddGlobalCtor(llvm::Function *Ctor, int Priority,
 1140 void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority) {
 1218                                               llvm::Function *F) {
 1263 void CodeGenModule::GenOpenCLArgMetadata(llvm::Function *Fn,
 1481                                                            llvm::Function *F) {
 1722     if (auto *F = dyn_cast<llvm::Function>(GO)) {
 1722     if (auto *F = dyn_cast<llvm::Function>(GO)) {
 1748                                                   llvm::Function *F,
 1754   F->setLinkage(llvm::Function::InternalLinkage);
 1771                                                        llvm::Function *F) {
 1791 void CodeGenModule::SetFunctionAttributes(GlobalDecl GD, llvm::Function *F,
 2232                                            llvm::Function *Fn,
 2283 bool CodeGenModule::imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc,
 2409   F->setLinkage(llvm::Function::ExternalWeakLinkage);
 2694   if (getFunctionLinkage(GD) != llvm::Function::AvailableExternallyLinkage)
 2761     SetFunctionAttributes(OldGD, cast<llvm::Function>(GV),
 2769   auto *Fn = cast<llvm::Function>(GV);
 2769   auto *Fn = cast<llvm::Function>(GV);
 2838                                                       llvm::Function *NewFn);
 2881           Options.emplace_back(cast<llvm::Function>(Func),
 2885     llvm::Function *ResolverFunc;
 2889       ResolverFunc = cast<llvm::Function>(
 2891       ResolverFunc->setLinkage(llvm::Function::WeakODRLinkage);
 2893       ResolverFunc = cast<llvm::Function>(GetGlobalValue(getMangledName(GD)));
 2936   auto *ResolverFunc = cast<llvm::Function>(GetOrCreateLLVMFunction(
 2936   auto *ResolverFunc = cast<llvm::Function>(GetOrCreateLLVMFunction(
 2938   ResolverFunc->setLinkage(llvm::Function::WeakODRLinkage);
 2978     Options.emplace_back(cast<llvm::Function>(Func), StringRef{}, Features);
 3017       GA->setLinkage(llvm::Function::WeakODRLinkage);
 3057         DeclTy, 0, llvm::Function::WeakODRLinkage, "", Resolver, &getModule());
 3123         Entry->setLinkage(llvm::Function::ExternalLinkage);
 3149     if ((isa<llvm::Function>(Entry) || isa<llvm::GlobalAlias>(Entry)) &&
 3174   llvm::Function *F =
 3175       llvm::Function::Create(FTy, llvm::Function::ExternalLinkage,
 3175       llvm::Function::Create(FTy, llvm::Function::ExternalLinkage,