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