lib/Analysis/ModuleSummaryAnalysis.cpp

   1 //===- ModuleSummaryAnalysis.cpp - Module summary index builder -----------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This pass builds a ModuleSummaryIndex object for the module, to be written
  11 // to bitcode or LLVM assembly.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "llvm/Analysis/ModuleSummaryAnalysis.h"
  16 #include "llvm/ADT/ArrayRef.h"
  17 #include "llvm/ADT/DenseSet.h"
  18 #include "llvm/ADT/MapVector.h"
  19 #include "llvm/ADT/STLExtras.h"
  20 #include "llvm/ADT/SetVector.h"
  21 #include "llvm/ADT/SmallPtrSet.h"
  22 #include "llvm/ADT/SmallVector.h"
  23 #include "llvm/ADT/StringRef.h"
  24 #include "llvm/Analysis/BlockFrequencyInfo.h"
  25 #include "llvm/Analysis/BranchProbabilityInfo.h"
  26 #include "llvm/Analysis/IndirectCallPromotionAnalysis.h"
  27 #include "llvm/Analysis/LoopInfo.h"
  28 #include "llvm/Analysis/ProfileSummaryInfo.h"
  29 #include "llvm/Analysis/TypeMetadataUtils.h"
  30 #include "llvm/IR/Attributes.h"
  31 #include "llvm/IR/BasicBlock.h"
  32 #include "llvm/IR/CallSite.h"
  33 #include "llvm/IR/Constant.h"
  34 #include "llvm/IR/Constants.h"
  35 #include "llvm/IR/Dominators.h"
  36 #include "llvm/IR/Function.h"
  37 #include "llvm/IR/GlobalAlias.h"
  38 #include "llvm/IR/GlobalValue.h"
  39 #include "llvm/IR/GlobalVariable.h"
  40 #include "llvm/IR/Instructions.h"
  41 #include "llvm/IR/IntrinsicInst.h"
  42 #include "llvm/IR/Intrinsics.h"
  43 #include "llvm/IR/Metadata.h"
  44 #include "llvm/IR/Module.h"
  45 #include "llvm/IR/ModuleSummaryIndex.h"
  46 #include "llvm/IR/Use.h"
  47 #include "llvm/IR/User.h"
  48 #include "llvm/Object/ModuleSymbolTable.h"
  49 #include "llvm/Object/SymbolicFile.h"
  50 #include "llvm/Pass.h"
  51 #include "llvm/Support/Casting.h"
  52 #include "llvm/Support/CommandLine.h"
  53 #include <algorithm>
  54 #include <cassert>
  55 #include <cstdint>
  56 #include <vector>
  57
  58 using namespace llvm;
  59
  60 #define DEBUG_TYPE "module-summary-analysis"
  61
  62 // Option to force edges cold which will block importing when the
  63 // -import-cold-multiplier is set to 0. Useful for debugging.
  64 FunctionSummary::ForceSummaryHotnessType ForceSummaryEdgesCold =
  65     FunctionSummary::FSHT_None;
  66 cl::opt<FunctionSummary::ForceSummaryHotnessType, true> FSEC(
  67     "force-summary-edges-cold", cl::Hidden, cl::location(ForceSummaryEdgesCold),
  68     cl::desc("Force all edges in the function summary to cold"),
  69     cl::values(clEnumValN(FunctionSummary::FSHT_None, "none", "None."),
  70                clEnumValN(FunctionSummary::FSHT_AllNonCritical,
  71                           "all-non-critical", "All non-critical edges."),
  72                clEnumValN(FunctionSummary::FSHT_All, "all", "All edges.")));
  73
  74 // Walk through the operands of a given User via worklist iteration and populate
  75 // the set of GlobalValue references encountered. Invoked either on an
  76 // Instruction or a GlobalVariable (which walks its initializer).
  77 static void findRefEdges(ModuleSummaryIndex &Index, const User *CurUser,
  78                          SetVector<ValueInfo> &RefEdges,
  79                          SmallPtrSet<const User *, 8> &Visited) {
  80   SmallVector<const User *, 32> Worklist;
  81   Worklist.push_back(CurUser);
  82
  83   while (!Worklist.empty()) {
  84     const User *U = Worklist.pop_back_val();
  85
  86     if (!Visited.insert(U).second)
  87       continue;
  88
  89     ImmutableCallSite CS(U);
  90
  91     for (const auto &OI : U->operands()) {
  92       const User *Operand = dyn_cast<User>(OI);
  93       if (!Operand)
  94         continue;
  95       if (isa<BlockAddress>(Operand))
  96         continue;
  97       if (auto *GV = dyn_cast<GlobalValue>(Operand)) {
  98         // We have a reference to a global value. This should be added to
  99         // the reference set unless it is a callee. Callees are handled
 100         // specially by WriteFunction and are added to a separate list.
 101         if (!(CS && CS.isCallee(&OI)))
 102           RefEdges.insert(Index.getOrInsertValueInfo(GV));
 103         continue;
 104       }
 105       Worklist.push_back(Operand);
 106     }
 107   }
 108 }
 109
 110 static CalleeInfo::HotnessType getHotness(uint64_t ProfileCount,
 111                                           ProfileSummaryInfo *PSI) {
 112   if (!PSI)
 113     return CalleeInfo::HotnessType::Unknown;
 114   if (PSI->isHotCount(ProfileCount))
 115     return CalleeInfo::HotnessType::Hot;
 116   if (PSI->isColdCount(ProfileCount))
 117     return CalleeInfo::HotnessType::Cold;
 118   return CalleeInfo::HotnessType::None;
 119 }
 120
 121 static bool isNonRenamableLocal(const GlobalValue &GV) {
 122   return GV.hasSection() && GV.hasLocalLinkage();
 123 }
 124
 125 /// Determine whether this call has all constant integer arguments (excluding
 126 /// "this") and summarize it to VCalls or ConstVCalls as appropriate.
 127 static void addVCallToSet(DevirtCallSite Call, GlobalValue::GUID Guid,
 128                           SetVector<FunctionSummary::VFuncId> &VCalls,
 129                           SetVector<FunctionSummary::ConstVCall> &ConstVCalls) {
 130   std::vector<uint64_t> Args;
 131   // Start from the second argument to skip the "this" pointer.
 132   for (auto &Arg : make_range(Call.CS.arg_begin() + 1, Call.CS.arg_end())) {
 133     auto *CI = dyn_cast<ConstantInt>(Arg);
 134     if (!CI || CI->getBitWidth() > 64) {
 135       VCalls.insert({Guid, Call.Offset});
 136       return;
 137     }
 138     Args.push_back(CI->getZExtValue());
 139   }
 140   ConstVCalls.insert({{Guid, Call.Offset}, std::move(Args)});
 141 }
 142
 143 /// If this intrinsic call requires that we add information to the function
 144 /// summary, do so via the non-constant reference arguments.
 145 static void addIntrinsicToSummary(
 146     const CallInst *CI, SetVector<GlobalValue::GUID> &TypeTests,
 147     SetVector<FunctionSummary::VFuncId> &TypeTestAssumeVCalls,
 148     SetVector<FunctionSummary::VFuncId> &TypeCheckedLoadVCalls,
 149     SetVector<FunctionSummary::ConstVCall> &TypeTestAssumeConstVCalls,
 150     SetVector<FunctionSummary::ConstVCall> &TypeCheckedLoadConstVCalls) {
 151   switch (CI->getCalledFunction()->getIntrinsicID()) {
 152   case Intrinsic::type_test: {
 153     auto *TypeMDVal = cast<MetadataAsValue>(CI->getArgOperand(1));
 154     auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata());
 155     if (!TypeId)
 156       break;
 157     GlobalValue::GUID Guid = GlobalValue::getGUID(TypeId->getString());
 158
 159     // Produce a summary from type.test intrinsics. We only summarize type.test
 160     // intrinsics that are used other than by an llvm.assume intrinsic.
 161     // Intrinsics that are assumed are relevant only to the devirtualization
 162     // pass, not the type test lowering pass.
 163     bool HasNonAssumeUses = llvm::any_of(CI->uses(), [](const Use &CIU) {
 164       auto *AssumeCI = dyn_cast<CallInst>(CIU.getUser());
 165       if (!AssumeCI)
 166         return true;
 167       Function *F = AssumeCI->getCalledFunction();
 168       return !F || F->getIntrinsicID() != Intrinsic::assume;
 169     });
 170     if (HasNonAssumeUses)
 171       TypeTests.insert(Guid);
 172
 173     SmallVector<DevirtCallSite, 4> DevirtCalls;
 174     SmallVector<CallInst *, 4> Assumes;
 175     findDevirtualizableCallsForTypeTest(DevirtCalls, Assumes, CI);
 176     for (auto &Call : DevirtCalls)
 177       addVCallToSet(Call, Guid, TypeTestAssumeVCalls,
 178                     TypeTestAssumeConstVCalls);
 179
 180     break;
 181   }
 182
 183   case Intrinsic::type_checked_load: {
 184     auto *TypeMDVal = cast<MetadataAsValue>(CI->getArgOperand(2));
 185     auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata());
 186     if (!TypeId)
 187       break;
 188     GlobalValue::GUID Guid = GlobalValue::getGUID(TypeId->getString());
 189
 190     SmallVector<DevirtCallSite, 4> DevirtCalls;
 191     SmallVector<Instruction *, 4> LoadedPtrs;
 192     SmallVector<Instruction *, 4> Preds;
 193     bool HasNonCallUses = false;
 194     findDevirtualizableCallsForTypeCheckedLoad(DevirtCalls, LoadedPtrs, Preds,
 195                                                HasNonCallUses, CI);
 196     // Any non-call uses of the result of llvm.type.checked.load will
 197     // prevent us from optimizing away the llvm.type.test.
 198     if (HasNonCallUses)
 199       TypeTests.insert(Guid);
 200     for (auto &Call : DevirtCalls)
 201       addVCallToSet(Call, Guid, TypeCheckedLoadVCalls,
 202                     TypeCheckedLoadConstVCalls);
 203
 204     break;
 205   }
 206   default:
 207     break;
 208   }
 209 }
 210
 211 static void
 212 computeFunctionSummary(ModuleSummaryIndex &Index, const Module &M,
 213                        const Function &F, BlockFrequencyInfo *BFI,
 214                        ProfileSummaryInfo *PSI, bool HasLocalsInUsedOrAsm,
 215                        DenseSet<GlobalValue::GUID> &CantBePromoted) {
 216   // Summary not currently supported for anonymous functions, they should
 217   // have been named.
 218   assert(F.hasName());
 219
 220   unsigned NumInsts = 0;
 221   // Map from callee ValueId to profile count. Used to accumulate profile
 222   // counts for all static calls to a given callee.
 223   MapVector<ValueInfo, CalleeInfo> CallGraphEdges;
 224   SetVector<ValueInfo> RefEdges;
 225   SetVector<GlobalValue::GUID> TypeTests;
 226   SetVector<FunctionSummary::VFuncId> TypeTestAssumeVCalls,
 227       TypeCheckedLoadVCalls;
 228   SetVector<FunctionSummary::ConstVCall> TypeTestAssumeConstVCalls,
 229       TypeCheckedLoadConstVCalls;
 230   ICallPromotionAnalysis ICallAnalysis;
 231   SmallPtrSet<const User *, 8> Visited;
 232
 233   // Add personality function, prefix data and prologue data to function's ref
 234   // list.
 235   findRefEdges(Index, &F, RefEdges, Visited);
 236
 237   bool HasInlineAsmMaybeReferencingInternal = false;
 238   for (const BasicBlock &BB : F)
 239     for (const Instruction &I : BB) {
 240       if (isa<DbgInfoIntrinsic>(I))
 241         continue;
 242       ++NumInsts;
 243       findRefEdges(Index, &I, RefEdges, Visited);
 244       auto CS = ImmutableCallSite(&I);
 245       if (!CS)
 246         continue;
 247
 248       const auto *CI = dyn_cast<CallInst>(&I);
 249       // Since we don't know exactly which local values are referenced in inline
 250       // assembly, conservatively mark the function as possibly referencing
 251       // a local value from inline assembly to ensure we don't export a
 252       // reference (which would require renaming and promotion of the
 253       // referenced value).
 254       if (HasLocalsInUsedOrAsm && CI && CI->isInlineAsm())
 255         HasInlineAsmMaybeReferencingInternal = true;
 256
 257       auto *CalledValue = CS.getCalledValue();
 258       auto *CalledFunction = CS.getCalledFunction();
 259       if (CalledValue && !CalledFunction) {
 260         CalledValue = CalledValue->stripPointerCastsNoFollowAliases();
 261         // Stripping pointer casts can reveal a called function.
 262         CalledFunction = dyn_cast<Function>(CalledValue);
 263       }
 264       // Check if this is an alias to a function. If so, get the
 265       // called aliasee for the checks below.
 266       if (auto *GA = dyn_cast<GlobalAlias>(CalledValue)) {
 267         assert(!CalledFunction && "Expected null called function in callsite for alias");
 268         CalledFunction = dyn_cast<Function>(GA->getBaseObject());
 269       }
 270       // Check if this is a direct call to a known function or a known
 271       // intrinsic, or an indirect call with profile data.
 272       if (CalledFunction) {
 273         if (CI && CalledFunction->isIntrinsic()) {
 274           addIntrinsicToSummary(
 275               CI, TypeTests, TypeTestAssumeVCalls, TypeCheckedLoadVCalls,
 276               TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls);
 277           continue;
 278         }
 279         // We should have named any anonymous globals
 280         assert(CalledFunction->hasName());
 281         auto ScaledCount = PSI->getProfileCount(&I, BFI);
 282         auto Hotness = ScaledCount ? getHotness(ScaledCount.getValue(), PSI)
 283                                    : CalleeInfo::HotnessType::Unknown;
 284         if (ForceSummaryEdgesCold != FunctionSummary::FSHT_None)
 285           Hotness = CalleeInfo::HotnessType::Cold;
 286
 287         // Use the original CalledValue, in case it was an alias. We want
 288         // to record the call edge to the alias in that case. Eventually
 289         // an alias summary will be created to associate the alias and
 290         // aliasee.
 291         auto &ValueInfo = CallGraphEdges[Index.getOrInsertValueInfo(
 292             cast<GlobalValue>(CalledValue))];
 293         ValueInfo.updateHotness(Hotness);
 294         // Add the relative block frequency to CalleeInfo if there is no profile
 295         // information.
 296         if (BFI != nullptr && Hotness == CalleeInfo::HotnessType::Unknown) {
 297           uint64_t BBFreq = BFI->getBlockFreq(&BB).getFrequency();
 298           uint64_t EntryFreq = BFI->getEntryFreq();
 299           ValueInfo.updateRelBlockFreq(BBFreq, EntryFreq);
 300         }
 301       } else {
 302         // Skip inline assembly calls.
 303         if (CI && CI->isInlineAsm())
 304           continue;
 305         // Skip direct calls.
 306         if (!CalledValue || isa<Constant>(CalledValue))
 307           continue;
 308
 309         // Check if the instruction has a callees metadata. If so, add callees
 310         // to CallGraphEdges to reflect the references from the metadata, and
 311         // to enable importing for subsequent indirect call promotion and
 312         // inlining.
 313         if (auto *MD = I.getMetadata(LLVMContext::MD_callees)) {
 314           for (auto &Op : MD->operands()) {
 315             Function *Callee = mdconst::extract_or_null<Function>(Op);
 316             if (Callee)
 317               CallGraphEdges[Index.getOrInsertValueInfo(Callee)];
 318           }
 319         }
 320
 321         uint32_t NumVals, NumCandidates;
 322         uint64_t TotalCount;
 323         auto CandidateProfileData =
 324             ICallAnalysis.getPromotionCandidatesForInstruction(
 325                 &I, NumVals, TotalCount, NumCandidates);
 326         for (auto &Candidate : CandidateProfileData)
 327           CallGraphEdges[Index.getOrInsertValueInfo(Candidate.Value)]
 328               .updateHotness(getHotness(Candidate.Count, PSI));
 329       }
 330     }
 331
 332   // Explicit add hot edges to enforce importing for designated GUIDs for
 333   // sample PGO, to enable the same inlines as the profiled optimized binary.
 334   for (auto &I : F.getImportGUIDs())
 335     CallGraphEdges[Index.getOrInsertValueInfo(I)].updateHotness(
 336         ForceSummaryEdgesCold == FunctionSummary::FSHT_All
 337             ? CalleeInfo::HotnessType::Cold
 338             : CalleeInfo::HotnessType::Critical);
 339
 340   bool NonRenamableLocal = isNonRenamableLocal(F);
 341   bool NotEligibleForImport =
 342       NonRenamableLocal || HasInlineAsmMaybeReferencingInternal ||
 343       // Inliner doesn't handle variadic functions.
 344       // FIXME: refactor this to use the same code that inliner is using.
 345       F.isVarArg() ||
 346       // Don't try to import functions with noinline attribute.
 347       F.getAttributes().hasFnAttribute(Attribute::NoInline);
 348   GlobalValueSummary::GVFlags Flags(F.getLinkage(), NotEligibleForImport,
 349                                     /* Live = */ false, F.isDSOLocal());
 350   FunctionSummary::FFlags FunFlags{
 351       F.hasFnAttribute(Attribute::ReadNone),
 352       F.hasFnAttribute(Attribute::ReadOnly),
 353       F.hasFnAttribute(Attribute::NoRecurse),
 354       F.returnDoesNotAlias(),
 355   };
 356   auto FuncSummary = llvm::make_unique<FunctionSummary>(
 357       Flags, NumInsts, FunFlags, RefEdges.takeVector(),
 358       CallGraphEdges.takeVector(), TypeTests.takeVector(),
 359       TypeTestAssumeVCalls.takeVector(), TypeCheckedLoadVCalls.takeVector(),
 360       TypeTestAssumeConstVCalls.takeVector(),
 361       TypeCheckedLoadConstVCalls.takeVector());
 362   if (NonRenamableLocal)
 363     CantBePromoted.insert(F.getGUID());
 364   Index.addGlobalValueSummary(F, std::move(FuncSummary));
 365 }
 366
 367 static void
 368 computeVariableSummary(ModuleSummaryIndex &Index, const GlobalVariable &V,
 369                        DenseSet<GlobalValue::GUID> &CantBePromoted) {
 370   SetVector<ValueInfo> RefEdges;
 371   SmallPtrSet<const User *, 8> Visited;
 372   findRefEdges(Index, &V, RefEdges, Visited);
 373   bool NonRenamableLocal = isNonRenamableLocal(V);
 374   GlobalValueSummary::GVFlags Flags(V.getLinkage(), NonRenamableLocal,
 375                                     /* Live = */ false, V.isDSOLocal());
 376   auto GVarSummary =
 377       llvm::make_unique<GlobalVarSummary>(Flags, RefEdges.takeVector());
 378   if (NonRenamableLocal)
 379     CantBePromoted.insert(V.getGUID());
 380   Index.addGlobalValueSummary(V, std::move(GVarSummary));
 381 }
 382
 383 static void
 384 computeAliasSummary(ModuleSummaryIndex &Index, const GlobalAlias &A,
 385                     DenseSet<GlobalValue::GUID> &CantBePromoted) {
 386   bool NonRenamableLocal = isNonRenamableLocal(A);
 387   GlobalValueSummary::GVFlags Flags(A.getLinkage(), NonRenamableLocal,
 388                                     /* Live = */ false, A.isDSOLocal());
 389   auto AS = llvm::make_unique<AliasSummary>(Flags);
 390   auto *Aliasee = A.getBaseObject();
 391   auto *AliaseeSummary = Index.getGlobalValueSummary(*Aliasee);
 392   assert(AliaseeSummary && "Alias expects aliasee summary to be parsed");
 393   AS->setAliasee(AliaseeSummary);
 394   if (NonRenamableLocal)
 395     CantBePromoted.insert(A.getGUID());
 396   Index.addGlobalValueSummary(A, std::move(AS));
 397 }
 398
 399 // Set LiveRoot flag on entries matching the given value name.
 400 static void setLiveRoot(ModuleSummaryIndex &Index, StringRef Name) {
 401   if (ValueInfo VI = Index.getValueInfo(GlobalValue::getGUID(Name)))
 402     for (auto &Summary : VI.getSummaryList())
 403       Summary->setLive(true);
 404 }
 405
 406 ModuleSummaryIndex llvm::buildModuleSummaryIndex(
 407     const Module &M,
 408     std::function<BlockFrequencyInfo *(const Function &F)> GetBFICallback,
 409     ProfileSummaryInfo *PSI) {
 410   assert(PSI);
 411   ModuleSummaryIndex Index(/*HaveGVs=*/true);
 412
 413   // Identify the local values in the llvm.used and llvm.compiler.used sets,
 414   // which should not be exported as they would then require renaming and
 415   // promotion, but we may have opaque uses e.g. in inline asm. We collect them
 416   // here because we use this information to mark functions containing inline
 417   // assembly calls as not importable.
 418   SmallPtrSet<GlobalValue *, 8> LocalsUsed;
 419   SmallPtrSet<GlobalValue *, 8> Used;
 420   // First collect those in the llvm.used set.
 421   collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ false);
 422   // Next collect those in the llvm.compiler.used set.
 423   collectUsedGlobalVariables(M, Used, /*CompilerUsed*/ true);
 424   DenseSet<GlobalValue::GUID> CantBePromoted;
 425   for (auto *V : Used) {
 426     if (V->hasLocalLinkage()) {
 427       LocalsUsed.insert(V);
 428       CantBePromoted.insert(V->getGUID());
 429     }
 430   }
 431
 432   bool HasLocalInlineAsmSymbol = false;
 433   if (!M.getModuleInlineAsm().empty()) {
 434     // Collect the local values defined by module level asm, and set up
 435     // summaries for these symbols so that they can be marked as NoRename,
 436     // to prevent export of any use of them in regular IR that would require
 437     // renaming within the module level asm. Note we don't need to create a
 438     // summary for weak or global defs, as they don't need to be flagged as
 439     // NoRename, and defs in module level asm can't be imported anyway.
 440     // Also, any values used but not defined within module level asm should
 441     // be listed on the llvm.used or llvm.compiler.used global and marked as
 442     // referenced from there.
 443     ModuleSymbolTable::CollectAsmSymbols(
 444         M, [&](StringRef Name, object::BasicSymbolRef::Flags Flags) {
 445           // Symbols not marked as Weak or Global are local definitions.
 446           if (Flags & (object::BasicSymbolRef::SF_Weak |
 447                        object::BasicSymbolRef::SF_Global))
 448             return;
 449           HasLocalInlineAsmSymbol = true;
 450           GlobalValue *GV = M.getNamedValue(Name);
 451           if (!GV)
 452             return;
 453           assert(GV->isDeclaration() && "Def in module asm already has definition");
 454           GlobalValueSummary::GVFlags GVFlags(GlobalValue::InternalLinkage,
 455                                               /* NotEligibleToImport = */ true,
 456                                               /* Live = */ true,
 457                                               /* Local */ GV->isDSOLocal());
 458           CantBePromoted.insert(GV->getGUID());
 459           // Create the appropriate summary type.
 460           if (Function *F = dyn_cast<Function>(GV)) {
 461             std::unique_ptr<FunctionSummary> Summary =
 462                 llvm::make_unique<FunctionSummary>(
 463                     GVFlags, 0,
 464                     FunctionSummary::FFlags{
 465                         F->hasFnAttribute(Attribute::ReadNone),
 466                         F->hasFnAttribute(Attribute::ReadOnly),
 467                         F->hasFnAttribute(Attribute::NoRecurse),
 468                         F->returnDoesNotAlias()},
 469                     ArrayRef<ValueInfo>{}, ArrayRef<FunctionSummary::EdgeTy>{},
 470                     ArrayRef<GlobalValue::GUID>{},
 471                     ArrayRef<FunctionSummary::VFuncId>{},
 472                     ArrayRef<FunctionSummary::VFuncId>{},
 473                     ArrayRef<FunctionSummary::ConstVCall>{},
 474                     ArrayRef<FunctionSummary::ConstVCall>{});
 475             Index.addGlobalValueSummary(*GV, std::move(Summary));
 476           } else {
 477             std::unique_ptr<GlobalVarSummary> Summary =
 478                 llvm::make_unique<GlobalVarSummary>(GVFlags,
 479                                                     ArrayRef<ValueInfo>{});
 480             Index.addGlobalValueSummary(*GV, std::move(Summary));
 481           }
 482         });
 483   }
 484
 485   // Compute summaries for all functions defined in module, and save in the
 486   // index.
 487   for (auto &F : M) {
 488     if (F.isDeclaration())
 489       continue;
 490
 491     BlockFrequencyInfo *BFI = nullptr;
 492     std::unique_ptr<BlockFrequencyInfo> BFIPtr;
 493     if (GetBFICallback)
 494       BFI = GetBFICallback(F);
 495     else if (F.hasProfileData()) {
 496       LoopInfo LI{DominatorTree(const_cast<Function &>(F))};
 497       BranchProbabilityInfo BPI{F, LI};
 498       BFIPtr = llvm::make_unique<BlockFrequencyInfo>(F, BPI, LI);
 499       BFI = BFIPtr.get();
 500     }
 501
 502     computeFunctionSummary(Index, M, F, BFI, PSI,
 503                            !LocalsUsed.empty() || HasLocalInlineAsmSymbol,
 504                            CantBePromoted);
 505   }
 506
 507   // Compute summaries for all variables defined in module, and save in the
 508   // index.
 509   for (const GlobalVariable &G : M.globals()) {
 510     if (G.isDeclaration())
 511       continue;
 512     computeVariableSummary(Index, G, CantBePromoted);
 513   }
 514
 515   // Compute summaries for all aliases defined in module, and save in the
 516   // index.
 517   for (const GlobalAlias &A : M.aliases())
 518     computeAliasSummary(Index, A, CantBePromoted);
 519
 520   for (auto *V : LocalsUsed) {
 521     auto *Summary = Index.getGlobalValueSummary(*V);
 522     assert(Summary && "Missing summary for global value");
 523     Summary->setNotEligibleToImport();
 524   }
 525
 526   // The linker doesn't know about these LLVM produced values, so we need
 527   // to flag them as live in the index to ensure index-based dead value
 528   // analysis treats them as live roots of the analysis.
 529   setLiveRoot(Index, "llvm.used");
 530   setLiveRoot(Index, "llvm.compiler.used");
 531   setLiveRoot(Index, "llvm.global_ctors");
 532   setLiveRoot(Index, "llvm.global_dtors");
 533   setLiveRoot(Index, "llvm.global.annotations");
 534
 535   bool IsThinLTO = true;
 536   if (auto *MD =
 537           mdconst::extract_or_null<ConstantInt>(M.getModuleFlag("ThinLTO")))
 538     IsThinLTO = MD->getZExtValue();
 539
 540   for (auto &GlobalList : Index) {
 541     // Ignore entries for references that are undefined in the current module.
 542     if (GlobalList.second.SummaryList.empty())
 543       continue;
 544
 545     assert(GlobalList.second.SummaryList.size() == 1 &&
 546            "Expected module's index to have one summary per GUID");
 547     auto &Summary = GlobalList.second.SummaryList[0];
 548     if (!IsThinLTO) {
 549       Summary->setNotEligibleToImport();
 550       continue;
 551     }
 552
 553     bool AllRefsCanBeExternallyReferenced =
 554         llvm::all_of(Summary->refs(), [&](const ValueInfo &VI) {
 555           return !CantBePromoted.count(VI.getGUID());
 556         });
 557     if (!AllRefsCanBeExternallyReferenced) {
 558       Summary->setNotEligibleToImport();
 559       continue;
 560     }
 561
 562     if (auto *FuncSummary = dyn_cast<FunctionSummary>(Summary.get())) {
 563       bool AllCallsCanBeExternallyReferenced = llvm::all_of(
 564           FuncSummary->calls(), [&](const FunctionSummary::EdgeTy &Edge) {
 565             return !CantBePromoted.count(Edge.first.getGUID());
 566           });
 567       if (!AllCallsCanBeExternallyReferenced)
 568         Summary->setNotEligibleToImport();
 569     }
 570   }
 571
 572   return Index;
 573 }
 574
 575 AnalysisKey ModuleSummaryIndexAnalysis::Key;
 576
 577 ModuleSummaryIndex
 578 ModuleSummaryIndexAnalysis::run(Module &M, ModuleAnalysisManager &AM) {
 579   ProfileSummaryInfo &PSI = AM.getResult<ProfileSummaryAnalysis>(M);
 580   auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
 581   return buildModuleSummaryIndex(
 582       M,
 583       [&FAM](const Function &F) {
 584         return &FAM.getResult<BlockFrequencyAnalysis>(
 585             *const_cast<Function *>(&F));
 586       },
 587       &PSI);
 588 }
 589
 590 char ModuleSummaryIndexWrapperPass::ID = 0;
 591
 592 INITIALIZE_PASS_BEGIN(ModuleSummaryIndexWrapperPass, "module-summary-analysis",
 593                       "Module Summary Analysis", false, true)
 594 INITIALIZE_PASS_DEPENDENCY(BlockFrequencyInfoWrapperPass)
 595 INITIALIZE_PASS_DEPENDENCY(ProfileSummaryInfoWrapperPass)
 596 INITIALIZE_PASS_END(ModuleSummaryIndexWrapperPass, "module-summary-analysis",
 597                     "Module Summary Analysis", false, true)
 598
 599 ModulePass *llvm::createModuleSummaryIndexWrapperPass() {
 600   return new ModuleSummaryIndexWrapperPass();
 601 }
 602
 603 ModuleSummaryIndexWrapperPass::ModuleSummaryIndexWrapperPass()
 604     : ModulePass(ID) {
 605   initializeModuleSummaryIndexWrapperPassPass(*PassRegistry::getPassRegistry());
 606 }
 607
 608 bool ModuleSummaryIndexWrapperPass::runOnModule(Module &M) {
 609   auto &PSI = *getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
 610   Index.emplace(buildModuleSummaryIndex(
 611       M,
 612       [this](const Function &F) {
 613         return &(this->getAnalysis<BlockFrequencyInfoWrapperPass>(
 614                          *const_cast<Function *>(&F))
 615                      .getBFI());
 616       },
 617       &PSI));
 618   return false;
 619 }
 620
 621 bool ModuleSummaryIndexWrapperPass::doFinalization(Module &M) {
 622   Index.reset();
 623   return false;
 624 }
 625
 626 void ModuleSummaryIndexWrapperPass::getAnalysisUsage(AnalysisUsage &AU) const {
 627   AU.setPreservesAll();
 628   AU.addRequired<BlockFrequencyInfoWrapperPass>();
 629   AU.addRequired<ProfileSummaryInfoWrapperPass>();
 630 }