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