LLVM  13.0.0git
ModuleSummaryAnalysis.cpp
Go to the documentation of this file.
1 //===- ModuleSummaryAnalysis.cpp - Module summary index builder -----------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 //
9 // This pass builds a ModuleSummaryIndex object for the module, to be written
10 // to bitcode or LLVM assembly.
11 //
12 //===----------------------------------------------------------------------===//
13 
15 #include "llvm/ADT/ArrayRef.h"
16 #include "llvm/ADT/DenseSet.h"
17 #include "llvm/ADT/MapVector.h"
18 #include "llvm/ADT/STLExtras.h"
19 #include "llvm/ADT/SetVector.h"
20 #include "llvm/ADT/SmallPtrSet.h"
21 #include "llvm/ADT/SmallVector.h"
22 #include "llvm/ADT/StringRef.h"
26 #include "llvm/Analysis/LoopInfo.h"
30 #include "llvm/IR/Attributes.h"
31 #include "llvm/IR/BasicBlock.h"
32 #include "llvm/IR/Constant.h"
33 #include "llvm/IR/Constants.h"
34 #include "llvm/IR/Dominators.h"
35 #include "llvm/IR/Function.h"
36 #include "llvm/IR/GlobalAlias.h"
37 #include "llvm/IR/GlobalValue.h"
38 #include "llvm/IR/GlobalVariable.h"
39 #include "llvm/IR/Instructions.h"
40 #include "llvm/IR/IntrinsicInst.h"
41 #include "llvm/IR/Intrinsics.h"
42 #include "llvm/IR/Metadata.h"
43 #include "llvm/IR/Module.h"
45 #include "llvm/IR/Use.h"
46 #include "llvm/IR/User.h"
47 #include "llvm/InitializePasses.h"
50 #include "llvm/Pass.h"
51 #include "llvm/Support/Casting.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.
67  "force-summary-edges-cold", cl::Hidden, cl::location(ForceSummaryEdgesCold),
68  cl::desc("Force all edges in the function summary to cold"),
71  "all-non-critical", "All non-critical edges."),
72  clEnumValN(FunctionSummary::FSHT_All, "all", "All edges.")));
73 
75  "module-summary-dot-file", cl::init(""), cl::Hidden,
76  cl::value_desc("filename"),
77  cl::desc("File to emit dot graph of new summary into."));
78 
79 // Walk through the operands of a given User via worklist iteration and populate
80 // the set of GlobalValue references encountered. Invoked either on an
81 // Instruction or a GlobalVariable (which walks its initializer).
82 // Return true if any of the operands contains blockaddress. This is important
83 // to know when computing summary for global var, because if global variable
84 // references basic block address we can't import it separately from function
85 // containing that basic block. For simplicity we currently don't import such
86 // global vars at all. When importing function we aren't interested if any
87 // instruction in it takes an address of any basic block, because instruction
88 // can only take an address of basic block located in the same function.
89 static bool findRefEdges(ModuleSummaryIndex &Index, const User *CurUser,
90  SetVector<ValueInfo> &RefEdges,
92  bool HasBlockAddress = false;
94  if (Visited.insert(CurUser).second)
95  Worklist.push_back(CurUser);
96 
97  while (!Worklist.empty()) {
98  const User *U = Worklist.pop_back_val();
99  const auto *CB = dyn_cast<CallBase>(U);
100 
101  for (const auto &OI : U->operands()) {
102  const User *Operand = dyn_cast<User>(OI);
103  if (!Operand)
104  continue;
105  if (isa<BlockAddress>(Operand)) {
106  HasBlockAddress = true;
107  continue;
108  }
109  if (auto *GV = dyn_cast<GlobalValue>(Operand)) {
110  // We have a reference to a global value. This should be added to
111  // the reference set unless it is a callee. Callees are handled
112  // specially by WriteFunction and are added to a separate list.
113  if (!(CB && CB->isCallee(&OI)))
114  RefEdges.insert(Index.getOrInsertValueInfo(GV));
115  continue;
116  }
117  if (Visited.insert(Operand).second)
118  Worklist.push_back(Operand);
119  }
120  }
121  return HasBlockAddress;
122 }
123 
125  ProfileSummaryInfo *PSI) {
126  if (!PSI)
128  if (PSI->isHotCount(ProfileCount))
130  if (PSI->isColdCount(ProfileCount))
133 }
134 
135 static bool isNonRenamableLocal(const GlobalValue &GV) {
136  return GV.hasSection() && GV.hasLocalLinkage();
137 }
138 
139 /// Determine whether this call has all constant integer arguments (excluding
140 /// "this") and summarize it to VCalls or ConstVCalls as appropriate.
144  std::vector<uint64_t> Args;
145  // Start from the second argument to skip the "this" pointer.
146  for (auto &Arg : drop_begin(Call.CB.args())) {
147  auto *CI = dyn_cast<ConstantInt>(Arg);
148  if (!CI || CI->getBitWidth() > 64) {
149  VCalls.insert({Guid, Call.Offset});
150  return;
151  }
152  Args.push_back(CI->getZExtValue());
153  }
154  ConstVCalls.insert({{Guid, Call.Offset}, std::move(Args)});
155 }
156 
157 /// If this intrinsic call requires that we add information to the function
158 /// summary, do so via the non-constant reference arguments.
160  const CallInst *CI, SetVector<GlobalValue::GUID> &TypeTests,
161  SetVector<FunctionSummary::VFuncId> &TypeTestAssumeVCalls,
162  SetVector<FunctionSummary::VFuncId> &TypeCheckedLoadVCalls,
163  SetVector<FunctionSummary::ConstVCall> &TypeTestAssumeConstVCalls,
164  SetVector<FunctionSummary::ConstVCall> &TypeCheckedLoadConstVCalls,
165  DominatorTree &DT) {
166  switch (CI->getCalledFunction()->getIntrinsicID()) {
167  case Intrinsic::type_test: {
168  auto *TypeMDVal = cast<MetadataAsValue>(CI->getArgOperand(1));
169  auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata());
170  if (!TypeId)
171  break;
172  GlobalValue::GUID Guid = GlobalValue::getGUID(TypeId->getString());
173 
174  // Produce a summary from type.test intrinsics. We only summarize type.test
175  // intrinsics that are used other than by an llvm.assume intrinsic.
176  // Intrinsics that are assumed are relevant only to the devirtualization
177  // pass, not the type test lowering pass.
178  bool HasNonAssumeUses = llvm::any_of(CI->uses(), [](const Use &CIU) {
179  return !isa<AssumeInst>(CIU.getUser());
180  });
181  if (HasNonAssumeUses)
182  TypeTests.insert(Guid);
183 
184  SmallVector<DevirtCallSite, 4> DevirtCalls;
186  findDevirtualizableCallsForTypeTest(DevirtCalls, Assumes, CI, DT);
187  for (auto &Call : DevirtCalls)
188  addVCallToSet(Call, Guid, TypeTestAssumeVCalls,
189  TypeTestAssumeConstVCalls);
190 
191  break;
192  }
193 
194  case Intrinsic::type_checked_load: {
195  auto *TypeMDVal = cast<MetadataAsValue>(CI->getArgOperand(2));
196  auto *TypeId = dyn_cast<MDString>(TypeMDVal->getMetadata());
197  if (!TypeId)
198  break;
199  GlobalValue::GUID Guid = GlobalValue::getGUID(TypeId->getString());
200 
201  SmallVector<DevirtCallSite, 4> DevirtCalls;
204  bool HasNonCallUses = false;
205  findDevirtualizableCallsForTypeCheckedLoad(DevirtCalls, LoadedPtrs, Preds,
206  HasNonCallUses, CI, DT);
207  // Any non-call uses of the result of llvm.type.checked.load will
208  // prevent us from optimizing away the llvm.type.test.
209  if (HasNonCallUses)
210  TypeTests.insert(Guid);
211  for (auto &Call : DevirtCalls)
212  addVCallToSet(Call, Guid, TypeCheckedLoadVCalls,
213  TypeCheckedLoadConstVCalls);
214 
215  break;
216  }
217  default:
218  break;
219  }
220 }
221 
222 static bool isNonVolatileLoad(const Instruction *I) {
223  if (const auto *LI = dyn_cast<LoadInst>(I))
224  return !LI->isVolatile();
225 
226  return false;
227 }
228 
229 static bool isNonVolatileStore(const Instruction *I) {
230  if (const auto *SI = dyn_cast<StoreInst>(I))
231  return !SI->isVolatile();
232 
233  return false;
234 }
235 
237  ModuleSummaryIndex &Index, const Module &M, const Function &F,
239  bool HasLocalsInUsedOrAsm, DenseSet<GlobalValue::GUID> &CantBePromoted,
240  bool IsThinLTO,
241  std::function<const StackSafetyInfo *(const Function &F)> GetSSICallback) {
242  // Summary not currently supported for anonymous functions, they should
243  // have been named.
244  assert(F.hasName());
245 
246  unsigned NumInsts = 0;
247  // Map from callee ValueId to profile count. Used to accumulate profile
248  // counts for all static calls to a given callee.
249  MapVector<ValueInfo, CalleeInfo> CallGraphEdges;
250  SetVector<ValueInfo> RefEdges, LoadRefEdges, StoreRefEdges;
252  SetVector<FunctionSummary::VFuncId> TypeTestAssumeVCalls,
253  TypeCheckedLoadVCalls;
254  SetVector<FunctionSummary::ConstVCall> TypeTestAssumeConstVCalls,
255  TypeCheckedLoadConstVCalls;
256  ICallPromotionAnalysis ICallAnalysis;
258 
259  // Add personality function, prefix data and prologue data to function's ref
260  // list.
261  findRefEdges(Index, &F, RefEdges, Visited);
262  std::vector<const Instruction *> NonVolatileLoads;
263  std::vector<const Instruction *> NonVolatileStores;
264 
265  bool HasInlineAsmMaybeReferencingInternal = false;
266  for (const BasicBlock &BB : F)
267  for (const Instruction &I : BB) {
268  if (isa<DbgInfoIntrinsic>(I))
269  continue;
270  ++NumInsts;
271  // Regular LTO module doesn't participate in ThinLTO import,
272  // so no reference from it can be read/writeonly, since this
273  // would require importing variable as local copy
274  if (IsThinLTO) {
275  if (isNonVolatileLoad(&I)) {
276  // Postpone processing of non-volatile load instructions
277  // See comments below
278  Visited.insert(&I);
279  NonVolatileLoads.push_back(&I);
280  continue;
281  } else if (isNonVolatileStore(&I)) {
282  Visited.insert(&I);
283  NonVolatileStores.push_back(&I);
284  // All references from second operand of store (destination address)
285  // can be considered write-only if they're not referenced by any
286  // non-store instruction. References from first operand of store
287  // (stored value) can't be treated either as read- or as write-only
288  // so we add them to RefEdges as we do with all other instructions
289  // except non-volatile load.
290  Value *Stored = I.getOperand(0);
291  if (auto *GV = dyn_cast<GlobalValue>(Stored))
292  // findRefEdges will try to examine GV operands, so instead
293  // of calling it we should add GV to RefEdges directly.
294  RefEdges.insert(Index.getOrInsertValueInfo(GV));
295  else if (auto *U = dyn_cast<User>(Stored))
296  findRefEdges(Index, U, RefEdges, Visited);
297  continue;
298  }
299  }
300  findRefEdges(Index, &I, RefEdges, Visited);
301  const auto *CB = dyn_cast<CallBase>(&I);
302  if (!CB)
303  continue;
304 
305  const auto *CI = dyn_cast<CallInst>(&I);
306  // Since we don't know exactly which local values are referenced in inline
307  // assembly, conservatively mark the function as possibly referencing
308  // a local value from inline assembly to ensure we don't export a
309  // reference (which would require renaming and promotion of the
310  // referenced value).
311  if (HasLocalsInUsedOrAsm && CI && CI->isInlineAsm())
312  HasInlineAsmMaybeReferencingInternal = true;
313 
314  auto *CalledValue = CB->getCalledOperand();
315  auto *CalledFunction = CB->getCalledFunction();
316  if (CalledValue && !CalledFunction) {
317  CalledValue = CalledValue->stripPointerCasts();
318  // Stripping pointer casts can reveal a called function.
319  CalledFunction = dyn_cast<Function>(CalledValue);
320  }
321  // Check if this is an alias to a function. If so, get the
322  // called aliasee for the checks below.
323  if (auto *GA = dyn_cast<GlobalAlias>(CalledValue)) {
324  assert(!CalledFunction && "Expected null called function in callsite for alias");
325  CalledFunction = dyn_cast<Function>(GA->getBaseObject());
326  }
327  // Check if this is a direct call to a known function or a known
328  // intrinsic, or an indirect call with profile data.
329  if (CalledFunction) {
330  if (CI && CalledFunction->isIntrinsic()) {
332  CI, TypeTests, TypeTestAssumeVCalls, TypeCheckedLoadVCalls,
333  TypeTestAssumeConstVCalls, TypeCheckedLoadConstVCalls, DT);
334  continue;
335  }
336  // We should have named any anonymous globals
337  assert(CalledFunction->hasName());
338  auto ScaledCount = PSI->getProfileCount(*CB, BFI);
339  auto Hotness = ScaledCount ? getHotness(ScaledCount.getValue(), PSI)
343 
344  // Use the original CalledValue, in case it was an alias. We want
345  // to record the call edge to the alias in that case. Eventually
346  // an alias summary will be created to associate the alias and
347  // aliasee.
348  auto &ValueInfo = CallGraphEdges[Index.getOrInsertValueInfo(
349  cast<GlobalValue>(CalledValue))];
350  ValueInfo.updateHotness(Hotness);
351  // Add the relative block frequency to CalleeInfo if there is no profile
352  // information.
353  if (BFI != nullptr && Hotness == CalleeInfo::HotnessType::Unknown) {
354  uint64_t BBFreq = BFI->getBlockFreq(&BB).getFrequency();
355  uint64_t EntryFreq = BFI->getEntryFreq();
356  ValueInfo.updateRelBlockFreq(BBFreq, EntryFreq);
357  }
358  } else {
359  // Skip inline assembly calls.
360  if (CI && CI->isInlineAsm())
361  continue;
362  // Skip direct calls.
363  if (!CalledValue || isa<Constant>(CalledValue))
364  continue;
365 
366  // Check if the instruction has a callees metadata. If so, add callees
367  // to CallGraphEdges to reflect the references from the metadata, and
368  // to enable importing for subsequent indirect call promotion and
369  // inlining.
370  if (auto *MD = I.getMetadata(LLVMContext::MD_callees)) {
371  for (auto &Op : MD->operands()) {
372  Function *Callee = mdconst::extract_or_null<Function>(Op);
373  if (Callee)
374  CallGraphEdges[Index.getOrInsertValueInfo(Callee)];
375  }
376  }
377 
378  uint32_t NumVals, NumCandidates;
379  uint64_t TotalCount;
380  auto CandidateProfileData =
382  &I, NumVals, TotalCount, NumCandidates);
383  for (auto &Candidate : CandidateProfileData)
384  CallGraphEdges[Index.getOrInsertValueInfo(Candidate.Value)]
385  .updateHotness(getHotness(Candidate.Count, PSI));
386  }
387  }
388  Index.addBlockCount(F.size());
389 
390  std::vector<ValueInfo> Refs;
391  if (IsThinLTO) {
392  auto AddRefEdges = [&](const std::vector<const Instruction *> &Instrs,
393  SetVector<ValueInfo> &Edges,
395  for (const auto *I : Instrs) {
396  Cache.erase(I);
397  findRefEdges(Index, I, Edges, Cache);
398  }
399  };
400 
401  // By now we processed all instructions in a function, except
402  // non-volatile loads and non-volatile value stores. Let's find
403  // ref edges for both of instruction sets
404  AddRefEdges(NonVolatileLoads, LoadRefEdges, Visited);
405  // We can add some values to the Visited set when processing load
406  // instructions which are also used by stores in NonVolatileStores.
407  // For example this can happen if we have following code:
408  //
409  // store %Derived* @foo, %Derived** bitcast (%Base** @bar to %Derived**)
410  // %42 = load %Derived*, %Derived** bitcast (%Base** @bar to %Derived**)
411  //
412  // After processing loads we'll add bitcast to the Visited set, and if
413  // we use the same set while processing stores, we'll never see store
414  // to @bar and @bar will be mistakenly treated as readonly.
416  AddRefEdges(NonVolatileStores, StoreRefEdges, StoreCache);
417 
418  // If both load and store instruction reference the same variable
419  // we won't be able to optimize it. Add all such reference edges
420  // to RefEdges set.
421  for (auto &VI : StoreRefEdges)
422  if (LoadRefEdges.remove(VI))
423  RefEdges.insert(VI);
424 
425  unsigned RefCnt = RefEdges.size();
426  // All new reference edges inserted in two loops below are either
427  // read or write only. They will be grouped in the end of RefEdges
428  // vector, so we can use a single integer value to identify them.
429  for (auto &VI : LoadRefEdges)
430  RefEdges.insert(VI);
431 
432  unsigned FirstWORef = RefEdges.size();
433  for (auto &VI : StoreRefEdges)
434  RefEdges.insert(VI);
435 
436  Refs = RefEdges.takeVector();
437  for (; RefCnt < FirstWORef; ++RefCnt)
438  Refs[RefCnt].setReadOnly();
439 
440  for (; RefCnt < Refs.size(); ++RefCnt)
441  Refs[RefCnt].setWriteOnly();
442  } else {
443  Refs = RefEdges.takeVector();
444  }
445  // Explicit add hot edges to enforce importing for designated GUIDs for
446  // sample PGO, to enable the same inlines as the profiled optimized binary.
447  for (auto &I : F.getImportGUIDs())
448  CallGraphEdges[Index.getOrInsertValueInfo(I)].updateHotness(
452 
453  bool NonRenamableLocal = isNonRenamableLocal(F);
454  bool NotEligibleForImport =
455  NonRenamableLocal || HasInlineAsmMaybeReferencingInternal;
457  F.getLinkage(), F.getVisibility(), NotEligibleForImport,
458  /* Live = */ false, F.isDSOLocal(),
459  F.hasLinkOnceODRLinkage() && F.hasGlobalUnnamedAddr());
460  FunctionSummary::FFlags FunFlags{
461  F.hasFnAttribute(Attribute::ReadNone),
462  F.hasFnAttribute(Attribute::ReadOnly),
463  F.hasFnAttribute(Attribute::NoRecurse), F.returnDoesNotAlias(),
464  // FIXME: refactor this to use the same code that inliner is using.
465  // Don't try to import functions with noinline attribute.
466  F.getAttributes().hasFnAttribute(Attribute::NoInline),
467  F.hasFnAttribute(Attribute::AlwaysInline)};
468  std::vector<FunctionSummary::ParamAccess> ParamAccesses;
469  if (auto *SSI = GetSSICallback(F))
470  ParamAccesses = SSI->getParamAccesses(Index);
471  auto FuncSummary = std::make_unique<FunctionSummary>(
472  Flags, NumInsts, FunFlags, /*EntryCount=*/0, std::move(Refs),
473  CallGraphEdges.takeVector(), TypeTests.takeVector(),
474  TypeTestAssumeVCalls.takeVector(), TypeCheckedLoadVCalls.takeVector(),
475  TypeTestAssumeConstVCalls.takeVector(),
476  TypeCheckedLoadConstVCalls.takeVector(), std::move(ParamAccesses));
477  if (NonRenamableLocal)
478  CantBePromoted.insert(F.getGUID());
479  Index.addGlobalValueSummary(F, std::move(FuncSummary));
480 }
481 
482 /// Find function pointers referenced within the given vtable initializer
483 /// (or subset of an initializer) \p I. The starting offset of \p I within
484 /// the vtable initializer is \p StartingOffset. Any discovered function
485 /// pointers are added to \p VTableFuncs along with their cumulative offset
486 /// within the initializer.
487 static void findFuncPointers(const Constant *I, uint64_t StartingOffset,
488  const Module &M, ModuleSummaryIndex &Index,
489  VTableFuncList &VTableFuncs) {
490  // First check if this is a function pointer.
491  if (I->getType()->isPointerTy()) {
492  auto Fn = dyn_cast<Function>(I->stripPointerCasts());
493  // We can disregard __cxa_pure_virtual as a possible call target, as
494  // calls to pure virtuals are UB.
495  if (Fn && Fn->getName() != "__cxa_pure_virtual")
496  VTableFuncs.push_back({Index.getOrInsertValueInfo(Fn), StartingOffset});
497  return;
498  }
499 
500  // Walk through the elements in the constant struct or array and recursively
501  // look for virtual function pointers.
502  const DataLayout &DL = M.getDataLayout();
503  if (auto *C = dyn_cast<ConstantStruct>(I)) {
504  StructType *STy = dyn_cast<StructType>(C->getType());
505  assert(STy);
506  const StructLayout *SL = DL.getStructLayout(C->getType());
507 
508  for (auto EI : llvm::enumerate(STy->elements())) {
509  auto Offset = SL->getElementOffset(EI.index());
510  unsigned Op = SL->getElementContainingOffset(Offset);
511  findFuncPointers(cast<Constant>(I->getOperand(Op)),
512  StartingOffset + Offset, M, Index, VTableFuncs);
513  }
514  } else if (auto *C = dyn_cast<ConstantArray>(I)) {
515  ArrayType *ATy = C->getType();
516  Type *EltTy = ATy->getElementType();
517  uint64_t EltSize = DL.getTypeAllocSize(EltTy);
518  for (unsigned i = 0, e = ATy->getNumElements(); i != e; ++i) {
519  findFuncPointers(cast<Constant>(I->getOperand(i)),
520  StartingOffset + i * EltSize, M, Index, VTableFuncs);
521  }
522  }
523 }
524 
525 // Identify the function pointers referenced by vtable definition \p V.
527  const GlobalVariable &V, const Module &M,
528  VTableFuncList &VTableFuncs) {
529  if (!V.isConstant())
530  return;
531 
532  findFuncPointers(V.getInitializer(), /*StartingOffset=*/0, M, Index,
533  VTableFuncs);
534 
535 #ifndef NDEBUG
536  // Validate that the VTableFuncs list is ordered by offset.
537  uint64_t PrevOffset = 0;
538  for (auto &P : VTableFuncs) {
539  // The findVFuncPointers traversal should have encountered the
540  // functions in offset order. We need to use ">=" since PrevOffset
541  // starts at 0.
542  assert(P.VTableOffset >= PrevOffset);
543  PrevOffset = P.VTableOffset;
544  }
545 #endif
546 }
547 
548 /// Record vtable definition \p V for each type metadata it references.
549 static void
551  const GlobalVariable &V,
552  SmallVectorImpl<MDNode *> &Types) {
553  for (MDNode *Type : Types) {
554  auto TypeID = Type->getOperand(1).get();
555 
556  uint64_t Offset =
557  cast<ConstantInt>(
558  cast<ConstantAsMetadata>(Type->getOperand(0))->getValue())
559  ->getZExtValue();
560 
561  if (auto *TypeId = dyn_cast<MDString>(TypeID))
562  Index.getOrInsertTypeIdCompatibleVtableSummary(TypeId->getString())
563  .push_back({Offset, Index.getOrInsertValueInfo(&V)});
564  }
565 }
566 
568  const GlobalVariable &V,
569  DenseSet<GlobalValue::GUID> &CantBePromoted,
570  const Module &M,
571  SmallVectorImpl<MDNode *> &Types) {
572  SetVector<ValueInfo> RefEdges;
574  bool HasBlockAddress = findRefEdges(Index, &V, RefEdges, Visited);
575  bool NonRenamableLocal = isNonRenamableLocal(V);
577  V.getLinkage(), V.getVisibility(), NonRenamableLocal,
578  /* Live = */ false, V.isDSOLocal(),
580 
581  VTableFuncList VTableFuncs;
582  // If splitting is not enabled, then we compute the summary information
583  // necessary for index-based whole program devirtualization.
584  if (!Index.enableSplitLTOUnit()) {
585  Types.clear();
586  V.getMetadata(LLVMContext::MD_type, Types);
587  if (!Types.empty()) {
588  // Identify the function pointers referenced by this vtable definition.
589  computeVTableFuncs(Index, V, M, VTableFuncs);
590 
591  // Record this vtable definition for each type metadata it references.
593  }
594  }
595 
596  // Don't mark variables we won't be able to internalize as read/write-only.
597  bool CanBeInternalized =
598  !V.hasComdat() && !V.hasAppendingLinkage() && !V.isInterposable() &&
600  bool Constant = V.isConstant();
601  GlobalVarSummary::GVarFlags VarFlags(CanBeInternalized,
602  Constant ? false : CanBeInternalized,
604  auto GVarSummary = std::make_unique<GlobalVarSummary>(Flags, VarFlags,
605  RefEdges.takeVector());
606  if (NonRenamableLocal)
607  CantBePromoted.insert(V.getGUID());
608  if (HasBlockAddress)
609  GVarSummary->setNotEligibleToImport();
610  if (!VTableFuncs.empty())
611  GVarSummary->setVTableFuncs(VTableFuncs);
612  Index.addGlobalValueSummary(V, std::move(GVarSummary));
613 }
614 
615 static void
617  DenseSet<GlobalValue::GUID> &CantBePromoted) {
618  bool NonRenamableLocal = isNonRenamableLocal(A);
620  A.getLinkage(), A.getVisibility(), NonRenamableLocal,
621  /* Live = */ false, A.isDSOLocal(),
622  A.hasLinkOnceODRLinkage() && A.hasGlobalUnnamedAddr());
623  auto AS = std::make_unique<AliasSummary>(Flags);
624  auto *Aliasee = A.getBaseObject();
625  auto AliaseeVI = Index.getValueInfo(Aliasee->getGUID());
626  assert(AliaseeVI && "Alias expects aliasee summary to be available");
627  assert(AliaseeVI.getSummaryList().size() == 1 &&
628  "Expected a single entry per aliasee in per-module index");
629  AS->setAliasee(AliaseeVI, AliaseeVI.getSummaryList()[0].get());
630  if (NonRenamableLocal)
631  CantBePromoted.insert(A.getGUID());
632  Index.addGlobalValueSummary(A, std::move(AS));
633 }
634 
635 // Set LiveRoot flag on entries matching the given value name.
637  if (ValueInfo VI = Index.getValueInfo(GlobalValue::getGUID(Name)))
638  for (auto &Summary : VI.getSummaryList())
639  Summary->setLive(true);
640 }
641 
643  const Module &M,
644  std::function<BlockFrequencyInfo *(const Function &F)> GetBFICallback,
645  ProfileSummaryInfo *PSI,
646  std::function<const StackSafetyInfo *(const Function &F)> GetSSICallback) {
647  assert(PSI);
648  bool EnableSplitLTOUnit = false;
649  if (auto *MD = mdconst::extract_or_null<ConstantInt>(
650  M.getModuleFlag("EnableSplitLTOUnit")))
651  EnableSplitLTOUnit = MD->getZExtValue();
652  ModuleSummaryIndex Index(/*HaveGVs=*/true, EnableSplitLTOUnit);
653 
654  // Identify the local values in the llvm.used and llvm.compiler.used sets,
655  // which should not be exported as they would then require renaming and
656  // promotion, but we may have opaque uses e.g. in inline asm. We collect them
657  // here because we use this information to mark functions containing inline
658  // assembly calls as not importable.
661  // First collect those in the llvm.used set.
662  collectUsedGlobalVariables(M, Used, /*CompilerUsed=*/false);
663  // Next collect those in the llvm.compiler.used set.
664  collectUsedGlobalVariables(M, Used, /*CompilerUsed=*/true);
665  DenseSet<GlobalValue::GUID> CantBePromoted;
666  for (auto *V : Used) {
667  if (V->hasLocalLinkage()) {
668  LocalsUsed.insert(V);
669  CantBePromoted.insert(V->getGUID());
670  }
671  }
672 
673  bool HasLocalInlineAsmSymbol = false;
674  if (!M.getModuleInlineAsm().empty()) {
675  // Collect the local values defined by module level asm, and set up
676  // summaries for these symbols so that they can be marked as NoRename,
677  // to prevent export of any use of them in regular IR that would require
678  // renaming within the module level asm. Note we don't need to create a
679  // summary for weak or global defs, as they don't need to be flagged as
680  // NoRename, and defs in module level asm can't be imported anyway.
681  // Also, any values used but not defined within module level asm should
682  // be listed on the llvm.used or llvm.compiler.used global and marked as
683  // referenced from there.
686  // Symbols not marked as Weak or Global are local definitions.
687  if (Flags & (object::BasicSymbolRef::SF_Weak |
689  return;
690  HasLocalInlineAsmSymbol = true;
691  GlobalValue *GV = M.getNamedValue(Name);
692  if (!GV)
693  return;
694  assert(GV->isDeclaration() && "Def in module asm already has definition");
697  /* NotEligibleToImport = */ true,
698  /* Live = */ true,
699  /* Local */ GV->isDSOLocal(),
701  CantBePromoted.insert(GV->getGUID());
702  // Create the appropriate summary type.
703  if (Function *F = dyn_cast<Function>(GV)) {
704  std::unique_ptr<FunctionSummary> Summary =
705  std::make_unique<FunctionSummary>(
706  GVFlags, /*InstCount=*/0,
708  F->hasFnAttribute(Attribute::ReadNone),
709  F->hasFnAttribute(Attribute::ReadOnly),
710  F->hasFnAttribute(Attribute::NoRecurse),
711  F->returnDoesNotAlias(),
712  /* NoInline = */ false,
713  F->hasFnAttribute(Attribute::AlwaysInline)},
714  /*EntryCount=*/0, ArrayRef<ValueInfo>{},
722  Index.addGlobalValueSummary(*GV, std::move(Summary));
723  } else {
724  std::unique_ptr<GlobalVarSummary> Summary =
725  std::make_unique<GlobalVarSummary>(
726  GVFlags,
728  false, false, cast<GlobalVariable>(GV)->isConstant(),
731  Index.addGlobalValueSummary(*GV, std::move(Summary));
732  }
733  });
734  }
735 
736  bool IsThinLTO = true;
737  if (auto *MD =
738  mdconst::extract_or_null<ConstantInt>(M.getModuleFlag("ThinLTO")))
739  IsThinLTO = MD->getZExtValue();
740 
741  // Compute summaries for all functions defined in module, and save in the
742  // index.
743  for (auto &F : M) {
744  if (F.isDeclaration())
745  continue;
746 
747  DominatorTree DT(const_cast<Function &>(F));
748  BlockFrequencyInfo *BFI = nullptr;
749  std::unique_ptr<BlockFrequencyInfo> BFIPtr;
750  if (GetBFICallback)
751  BFI = GetBFICallback(F);
752  else if (F.hasProfileData()) {
753  LoopInfo LI{DT};
754  BranchProbabilityInfo BPI{F, LI};
755  BFIPtr = std::make_unique<BlockFrequencyInfo>(F, BPI, LI);
756  BFI = BFIPtr.get();
757  }
758 
759  computeFunctionSummary(Index, M, F, BFI, PSI, DT,
760  !LocalsUsed.empty() || HasLocalInlineAsmSymbol,
761  CantBePromoted, IsThinLTO, GetSSICallback);
762  }
763 
764  // Compute summaries for all variables defined in module, and save in the
765  // index.
767  for (const GlobalVariable &G : M.globals()) {
768  if (G.isDeclaration())
769  continue;
770  computeVariableSummary(Index, G, CantBePromoted, M, Types);
771  }
772 
773  // Compute summaries for all aliases defined in module, and save in the
774  // index.
775  for (const GlobalAlias &A : M.aliases())
776  computeAliasSummary(Index, A, CantBePromoted);
777 
778  for (auto *V : LocalsUsed) {
779  auto *Summary = Index.getGlobalValueSummary(*V);
780  assert(Summary && "Missing summary for global value");
781  Summary->setNotEligibleToImport();
782  }
783 
784  // The linker doesn't know about these LLVM produced values, so we need
785  // to flag them as live in the index to ensure index-based dead value
786  // analysis treats them as live roots of the analysis.
787  setLiveRoot(Index, "llvm.used");
788  setLiveRoot(Index, "llvm.compiler.used");
789  setLiveRoot(Index, "llvm.global_ctors");
790  setLiveRoot(Index, "llvm.global_dtors");
791  setLiveRoot(Index, "llvm.global.annotations");
792 
793  for (auto &GlobalList : Index) {
794  // Ignore entries for references that are undefined in the current module.
795  if (GlobalList.second.SummaryList.empty())
796  continue;
797 
798  assert(GlobalList.second.SummaryList.size() == 1 &&
799  "Expected module's index to have one summary per GUID");
800  auto &Summary = GlobalList.second.SummaryList[0];
801  if (!IsThinLTO) {
802  Summary->setNotEligibleToImport();
803  continue;
804  }
805 
806  bool AllRefsCanBeExternallyReferenced =
807  llvm::all_of(Summary->refs(), [&](const ValueInfo &VI) {
808  return !CantBePromoted.count(VI.getGUID());
809  });
810  if (!AllRefsCanBeExternallyReferenced) {
811  Summary->setNotEligibleToImport();
812  continue;
813  }
814 
815  if (auto *FuncSummary = dyn_cast<FunctionSummary>(Summary.get())) {
816  bool AllCallsCanBeExternallyReferenced = llvm::all_of(
817  FuncSummary->calls(), [&](const FunctionSummary::EdgeTy &Edge) {
818  return !CantBePromoted.count(Edge.first.getGUID());
819  });
820  if (!AllCallsCanBeExternallyReferenced)
821  Summary->setNotEligibleToImport();
822  }
823  }
824 
825  if (!ModuleSummaryDotFile.empty()) {
826  std::error_code EC;
828  if (EC)
829  report_fatal_error(Twine("Failed to open dot file ") +
830  ModuleSummaryDotFile + ": " + EC.message() + "\n");
831  Index.exportToDot(OSDot, {});
832  }
833 
834  return Index;
835 }
836 
837 AnalysisKey ModuleSummaryIndexAnalysis::Key;
838 
842  auto &FAM = AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
843  bool NeedSSI = needsParamAccessSummary(M);
845  M,
846  [&FAM](const Function &F) {
847  return &FAM.getResult<BlockFrequencyAnalysis>(
848  *const_cast<Function *>(&F));
849  },
850  &PSI,
851  [&FAM, NeedSSI](const Function &F) -> const StackSafetyInfo * {
852  return NeedSSI ? &FAM.getResult<StackSafetyAnalysis>(
853  const_cast<Function &>(F))
854  : nullptr;
855  });
856 }
857 
859 
860 INITIALIZE_PASS_BEGIN(ModuleSummaryIndexWrapperPass, "module-summary-analysis",
861  "Module Summary Analysis", false, true)
866  "Module Summary Analysis", false, true)
867 
869  return new ModuleSummaryIndexWrapperPass();
870 }
871 
873  : ModulePass(ID) {
875 }
876 
878  auto *PSI = &getAnalysis<ProfileSummaryInfoWrapperPass>().getPSI();
879  bool NeedSSI = needsParamAccessSummary(M);
880  Index.emplace(buildModuleSummaryIndex(
881  M,
882  [this](const Function &F) {
883  return &(this->getAnalysis<BlockFrequencyInfoWrapperPass>(
884  *const_cast<Function *>(&F))
885  .getBFI());
886  },
887  PSI,
888  [&](const Function &F) -> const StackSafetyInfo * {
889  return NeedSSI ? &getAnalysis<StackSafetyInfoWrapperPass>(
890  const_cast<Function &>(F))
891  .getResult()
892  : nullptr;
893  }));
894  return false;
895 }
896 
898  Index.reset();
899  return false;
900 }
901 
903  AU.setPreservesAll();
907 }
908 
910 
912  const ModuleSummaryIndex *Index)
913  : ImmutablePass(ID), Index(Index) {
916 }
917 
919  AnalysisUsage &AU) const {
920  AU.setPreservesAll();
921 }
922 
924  const ModuleSummaryIndex *Index) {
926 }
927 
929  "Module summary info", false, true)
llvm::GlobalValue::GUID
uint64_t GUID
Declare a type to represent a global unique identifier for a global value.
Definition: GlobalValue.h:503
i
i
Definition: README.txt:29
StackSafetyAnalysis.h
llvm
Definition: AllocatorList.h:23
M
We currently emits eax Perhaps this is what we really should generate is Is imull three or four cycles eax eax The current instruction priority is based on pattern complexity The former is more complex because it folds a load so the latter will not be emitted Perhaps we should use AddedComplexity to give LEA32r a higher priority We should always try to match LEA first since the LEA matching code does some estimate to determine whether the match is profitable if we care more about code then imull is better It s two bytes shorter than movl leal On a Pentium M
Definition: README.txt:252
llvm::drop_begin
auto drop_begin(T &&RangeOrContainer, size_t N=1)
Return a range covering RangeOrContainer with the first N elements excluded.
Definition: STLExtras.h:275
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:112
llvm::sys::fs::OF_None
@ OF_None
Definition: FileSystem.h:757
Metadata.h
llvm::User::operands
op_range operands()
Definition: User.h:242
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(ModuleSummaryIndexWrapperPass, "module-summary-analysis", "Module Summary Analysis", false, true) INITIALIZE_PASS_END(ModuleSummaryIndexWrapperPass
llvm::ModulePass
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:238
IntrinsicInst.h
llvm::ImmutablePass
ImmutablePass class - This class is used to provide information that does not need to be run.
Definition: Pass.h:269
llvm::AnalysisManager::getResult
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:785
llvm::GlobalValue::getLinkage
LinkageTypes getLinkage() const
Definition: GlobalValue.h:461
llvm::Function
Definition: Function.h:61
llvm::cl::location
LocationClass< Ty > location(Ty &L)
Definition: CommandLine.h:456
StringRef.h
P
This currently compiles esp xmm0 movsd esp eax eax esp ret We should use not the dag combiner This is because dagcombine2 needs to be able to see through the X86ISD::Wrapper which DAGCombine can t really do The code for turning x load into a single vector load is target independent and should be moved to the dag combiner The code for turning x load into a vector load can only handle a direct load from a global or a direct load from the stack It should be generalized to handle any load from P
Definition: README-SSE.txt:411
Pass.h
llvm::BlockFrequencyInfoWrapperPass
Legacy analysis pass which computes BlockFrequencyInfo.
Definition: BlockFrequencyInfo.h:138
llvm::SetVector::size
size_type size() const
Determine the number of elements in the SetVector.
Definition: SetVector.h:77
ModuleSummaryDotFile
cl::opt< std::string > ModuleSummaryDotFile("module-summary-dot-file", cl::init(""), cl::Hidden, cl::value_desc("filename"), cl::desc("File to emit dot graph of new summary into."))
llvm::ImmutableModuleSummaryIndexWrapperPass
Legacy wrapper pass to provide the ModuleSummaryIndex object.
Definition: ModuleSummaryAnalysis.h:82
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1168
llvm::enumerate
detail::enumerator< R > enumerate(R &&TheRange)
Given an input range, returns a new range whose values are are pair (A,B) such that A is the 0-based ...
Definition: STLExtras.h:1923
ForceSummaryEdgesCold
FunctionSummary::ForceSummaryHotnessType ForceSummaryEdgesCold
Definition: ModuleSummaryAnalysis.cpp:64
llvm::CalleeInfo::HotnessType::Cold
@ Cold
MapVector.h
llvm::GlobalVariable
Definition: GlobalVariable.h:40
llvm::GlobalObject::getMetadata
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
Definition: Metadata.cpp:1191
llvm::GlobalAlias
Definition: GlobalAlias.h:27
llvm::ModuleSummaryIndexWrapperPass::ModuleSummaryIndexWrapperPass
ModuleSummaryIndexWrapperPass()
Definition: ModuleSummaryAnalysis.cpp:872
llvm::DominatorTree
Concrete subclass of DominatorTreeBase that is used to compute a normal dominator tree.
Definition: Dominators.h:151
llvm::cl::Hidden
@ Hidden
Definition: CommandLine.h:140
llvm::Type
The instances of the Type class are immutable: once they are created, they are never changed.
Definition: Type.h:46
llvm::needsParamAccessSummary
bool needsParamAccessSummary(const Module &M)
Definition: StackSafetyAnalysis.cpp:995
Module.h
llvm::GlobalValue::hasSection
bool hasSection() const
Definition: GlobalValue.h:267
llvm::createImmutableModuleSummaryIndexWrapperPass
ImmutablePass * createImmutableModuleSummaryIndexWrapperPass(const ModuleSummaryIndex *Index)
Definition: ModuleSummaryAnalysis.cpp:923
llvm::object::BasicSymbolRef::Flags
Flags
Definition: SymbolicFile.h:106
llvm::ProfileSummaryInfo::getProfileCount
Optional< uint64_t > getProfileCount(const CallBase &CallInst, BlockFrequencyInfo *BFI, bool AllowSynthetic=false) const
Returns the profile count for CallInst.
Definition: ProfileSummaryInfo.cpp:113
llvm::GlobalValue::DefaultVisibility
@ DefaultVisibility
The GV is visible.
Definition: GlobalValue.h:63
Offset
uint64_t Offset
Definition: ELFObjHandler.cpp:81
llvm::MapVector
This class implements a map that also provides access to all stored values in a deterministic order.
Definition: MapVector.h:37
llvm::SmallPtrSet
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:449
llvm::FunctionSummary::FSHT_AllNonCritical
@ FSHT_AllNonCritical
Definition: ModuleSummaryIndex.h:519
STLExtras.h
llvm::SmallVectorImpl::pop_back_val
LLVM_NODISCARD T pop_back_val()
Definition: SmallVector.h:635
ModuleSummaryAnalysis.h
llvm::ArrayType
Class to represent array types.
Definition: DerivedTypes.h:359
llvm::object::BasicSymbolRef::SF_Weak
@ SF_Weak
Definition: SymbolicFile.h:110
SymbolicFile.h
llvm::detail::DenseSetImpl::insert
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:206
addIntrinsicToSummary
static void addIntrinsicToSummary(const CallInst *CI, SetVector< GlobalValue::GUID > &TypeTests, SetVector< FunctionSummary::VFuncId > &TypeTestAssumeVCalls, SetVector< FunctionSummary::VFuncId > &TypeCheckedLoadVCalls, SetVector< FunctionSummary::ConstVCall > &TypeTestAssumeConstVCalls, SetVector< FunctionSummary::ConstVCall > &TypeCheckedLoadConstVCalls, DominatorTree &DT)
If this intrinsic call requires that we add information to the function summary, do so via the non-co...
Definition: ModuleSummaryAnalysis.cpp:159
INITIALIZE_PASS_END
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
Definition: RegBankSelect.cpp:69
Use.h
ModuleSummaryIndex.h
llvm::ICallPromotionAnalysis
Definition: IndirectCallPromotionAnalysis.h:24
llvm::StackSafetyAnalysis
StackSafetyInfo wrapper for the new pass manager.
Definition: StackSafetyAnalysis.h:84
F
#define F(x, y, z)
Definition: MD5.cpp:56
llvm::collectUsedGlobalVariables
GlobalVariable * collectUsedGlobalVariables(const Module &M, SmallVectorImpl< GlobalValue * > &Vec, bool CompilerUsed)
Given "llvm.used" or "llvm.compiler.used" as a global name, collect the initializer elements of that ...
Definition: Module.cpp:711
findRefEdges
static bool findRefEdges(ModuleSummaryIndex &Index, const User *CurUser, SetVector< ValueInfo > &RefEdges, SmallPtrSet< const User *, 8 > &Visited)
Definition: ModuleSummaryAnalysis.cpp:89
llvm::BasicBlock
LLVM Basic Block Representation.
Definition: BasicBlock.h:58
llvm::GlobalValueSummary::GVFlags
Group flags (Linkage, NotEligibleToImport, etc.) as a bitfield.
Definition: ModuleSummaryIndex.h:294
IndirectCallPromotionAnalysis.h
computeVTableFuncs
static void computeVTableFuncs(ModuleSummaryIndex &Index, const GlobalVariable &V, const Module &M, VTableFuncList &VTableFuncs)
Definition: ModuleSummaryAnalysis.cpp:526
computeFunctionSummary
static void computeFunctionSummary(ModuleSummaryIndex &Index, const Module &M, const Function &F, BlockFrequencyInfo *BFI, ProfileSummaryInfo *PSI, DominatorTree &DT, bool HasLocalsInUsedOrAsm, DenseSet< GlobalValue::GUID > &CantBePromoted, bool IsThinLTO, std::function< const StackSafetyInfo *(const Function &F)> GetSSICallback)
Definition: ModuleSummaryAnalysis.cpp:236
Arg
amdgpu Simplify well known AMD library false FunctionCallee Value * Arg
Definition: AMDGPULibCalls.cpp:205
CommandLine.h
llvm::ImmutableModuleSummaryIndexWrapperPass::ID
static char ID
Definition: ModuleSummaryAnalysis.h:86
llvm::SetVector::remove
bool remove(const value_type &X)
Remove an item from the set vector.
Definition: SetVector.h:157
llvm::all_of
bool all_of(R &&range, UnaryPredicate P)
Provide wrappers to std::all_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1505
llvm::BlockFrequencyInfo
BlockFrequencyInfo pass uses BlockFrequencyInfoImpl implementation to estimate IR basic block frequen...
Definition: BlockFrequencyInfo.h:37
llvm::ProfileSummaryInfo::isColdCount
bool isColdCount(uint64_t C) const
Returns true if count C is considered cold.
Definition: ProfileSummaryInfo.cpp:334
GlobalValue.h
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
llvm::GlobalValue::isDeclaration
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:228
llvm::ArrayType::getNumElements
uint64_t getNumElements() const
Definition: DerivedTypes.h:371
llvm::GlobalVarSummary::GVarFlags
Definition: ModuleSummaryIndex.h:839
llvm::GlobalValue::hasAppendingLinkage
bool hasAppendingLinkage() const
Definition: GlobalValue.h:442
getHotness
static CalleeInfo::HotnessType getHotness(uint64_t ProfileCount, ProfileSummaryInfo *PSI)
Definition: ModuleSummaryAnalysis.cpp:124
Constants.h
llvm::FunctionSummary::EdgeTy
std::pair< ValueInfo, CalleeInfo > EdgeTy
<CalleeValueInfo, CalleeInfo> call edge pair.
Definition: ModuleSummaryIndex.h:514
llvm::User
Definition: User.h:44
Intrinsics.h
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::CallBase::getCalledFunction
Function * getCalledFunction() const
Returns the function called, or null if this is an indirect function invocation.
Definition: InstrTypes.h:1396
llvm::BranchProbabilityInfo
Analysis providing branch probability information.
Definition: BranchProbabilityInfo.h:115
INITIALIZE_PASS
#define INITIALIZE_PASS(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:37
SI
@ SI
Definition: SIInstrInfo.cpp:7342
TypeMetadataUtils.h
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
llvm::FunctionSummary::ForceSummaryHotnessType
ForceSummaryHotnessType
Types for -force-summary-edges-cold debugging option.
Definition: ModuleSummaryIndex.h:517
llvm::Value::uses
iterator_range< use_iterator > uses()
Definition: Value.h:389
DenseSet.h
false
Definition: StackSlotColoring.cpp:142
llvm::CalleeInfo::HotnessType
HotnessType
Definition: ModuleSummaryIndex.h:56
llvm::ModuleSummaryIndexAnalysis::run
Result run(Module &M, ModuleAnalysisManager &AM)
Definition: ModuleSummaryAnalysis.cpp:840
llvm::ImmutableModuleSummaryIndexWrapperPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: ModuleSummaryAnalysis.cpp:918
llvm::Instruction
Definition: Instruction.h:45
llvm::report_fatal_error
LLVM_ATTRIBUTE_NORETURN void report_fatal_error(Error Err, bool gen_crash_diag=true)
Report a serious error, calling any installed error handler.
Definition: Error.cpp:140
addVCallToSet
static void addVCallToSet(DevirtCallSite Call, GlobalValue::GUID Guid, SetVector< FunctionSummary::VFuncId > &VCalls, SetVector< FunctionSummary::ConstVCall > &ConstVCalls)
Determine whether this call has all constant integer arguments (excluding "this") and summarize it to...
Definition: ModuleSummaryAnalysis.cpp:141
llvm::GlobalObject::VCallVisibilityPublic
@ VCallVisibilityPublic
Definition: GlobalObject.h:37
SmallPtrSet.h
llvm::ImmutableModuleSummaryIndexWrapperPass::ImmutableModuleSummaryIndexWrapperPass
ImmutableModuleSummaryIndexWrapperPass(const ModuleSummaryIndex *Index=nullptr)
Definition: ModuleSummaryAnalysis.cpp:911
llvm::GlobalValue::hasGlobalUnnamedAddr
bool hasGlobalUnnamedAddr() const
Definition: GlobalValue.h:196
llvm::GlobalValue::InternalLinkage
@ InternalLinkage
Rename collisions when linking (static functions).
Definition: GlobalValue.h:55
llvm::BlockFrequencyAnalysis
Analysis pass which computes BlockFrequencyInfo.
Definition: BlockFrequencyInfo.h:112
llvm::GlobalValue::getGUID
static GUID getGUID(StringRef GlobalName)
Return a 64-bit global unique ID constructed from global value name (i.e.
Definition: GlobalValue.h:507
isNonRenamableLocal
static bool isNonRenamableLocal(const GlobalValue &GV)
Definition: ModuleSummaryAnalysis.cpp:135
llvm::ValueInfo
Struct that holds a reference to a particular GUID in a global value summary.
Definition: ModuleSummaryIndex.h:166
llvm::CalleeInfo::HotnessType::None
@ None
LoopInfo.h
llvm::ProfileSummaryInfo
Analysis providing profile information.
Definition: ProfileSummaryInfo.h:39
G
const DataFlowGraph & G
Definition: RDFGraph.cpp:202
llvm::DenseSet< GlobalValue::GUID >
FSEC
cl::opt< FunctionSummary::ForceSummaryHotnessType, true > FSEC("force-summary-edges-cold", cl::Hidden, cl::location(ForceSummaryEdgesCold), cl::desc("Force all edges in the function summary to cold"), cl::values(clEnumValN(FunctionSummary::FSHT_None, "none", "None."), clEnumValN(FunctionSummary::FSHT_AllNonCritical, "all-non-critical", "All non-critical edges."), clEnumValN(FunctionSummary::FSHT_All, "all", "All edges.")))
BasicBlock.h
llvm::cl::opt
Definition: CommandLine.h:1419
llvm::GlobalValue::hasAvailableExternallyLinkage
bool hasAvailableExternallyLinkage() const
Definition: GlobalValue.h:432
llvm::CalleeInfo::HotnessType::Hot
@ Hot
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::GlobalVariable::getInitializer
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
Definition: GlobalVariable.h:136
VI
@ VI
Definition: SIInstrInfo.cpp:7343
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::cl::values
ValuesClass values(OptsTy... Options)
Helper to build a ValuesClass by forwarding a variable number of arguments as an initializer list to ...
Definition: CommandLine.h:696
BranchProbabilityInfo.h
llvm::ProfileSummaryInfo::isHotCount
bool isHotCount(uint64_t C) const
Returns true if count C is considered hot.
Definition: ProfileSummaryInfo.cpp:330
Index
uint32_t Index
Definition: ELFObjHandler.cpp:84
llvm::StructLayout
Used to lazily calculate structure layout information for a target machine, based on the DataLayout s...
Definition: DataLayout.h:623
ProfileSummaryInfo.h
llvm::GlobalValue::getVisibility
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:229
INITIALIZE_PASS_DEPENDENCY
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
move
compiles ldr LCPI1_0 ldr ldr mov lsr tst moveq r1 ldr LCPI1_1 and r0 bx lr It would be better to do something like to fold the shift into the conditional move
Definition: README.txt:546
llvm::ModuleSummaryIndexWrapperPass::ID
static char ID
Definition: ModuleSummaryAnalysis.h:61
analysis
module summary analysis
Definition: ModuleSummaryAnalysis.cpp:865
isConstant
static bool isConstant(const MachineInstr &MI)
Definition: AMDGPUInstructionSelector.cpp:2267
llvm::numbers::e
constexpr double e
Definition: MathExtras.h:57
llvm::AnalysisKey
A special type used by analysis passes to provide an address that identifies that particular analysis...
Definition: PassManager.h:72
llvm::VTableFuncList
std::vector< VirtFuncOffset > VTableFuncList
List of functions referenced by a particular vtable definition.
Definition: ModuleSummaryIndex.h:821
I
#define I(x, y, z)
Definition: MD5.cpp:59
llvm::cl::init
initializer< Ty > init(const Ty &Val)
Definition: CommandLine.h:440
llvm::ProfileSummaryInfoWrapperPass
An analysis pass based on legacy pass manager to deliver ProfileSummaryInfo.
Definition: ProfileSummaryInfo.h:188
llvm::StructLayout::getElementContainingOffset
unsigned getElementContainingOffset(uint64_t Offset) const
Given a valid byte offset into the structure, returns the structure index that contains it.
Definition: DataLayout.cpp:82
ArrayRef.h
computeVariableSummary
static void computeVariableSummary(ModuleSummaryIndex &Index, const GlobalVariable &V, DenseSet< GlobalValue::GUID > &CantBePromoted, const Module &M, SmallVectorImpl< MDNode * > &Types)
Definition: ModuleSummaryAnalysis.cpp:567
llvm::DevirtCallSite
A call site that could be devirtualized.
Definition: TypeMetadataUtils.h:37
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::GlobalValue::hasLocalLinkage
bool hasLocalLinkage() const
Definition: GlobalValue.h:445
llvm::MapVector::takeVector
VectorType takeVector()
Clear the MapVector and return the underlying vector.
Definition: MapVector.h:55
llvm::initializeModuleSummaryIndexWrapperPassPass
void initializeModuleSummaryIndexWrapperPassPass(PassRegistry &)
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:83
llvm::initializeImmutableModuleSummaryIndexWrapperPassPass
void initializeImmutableModuleSummaryIndexWrapperPassPass(PassRegistry &)
setLiveRoot
static void setLiveRoot(ModuleSummaryIndex &Index, StringRef Name)
Definition: ModuleSummaryAnalysis.cpp:636
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:67
llvm::MDNode
Metadata node.
Definition: Metadata.h:897
isNonVolatileStore
static bool isNonVolatileStore(const Instruction *I)
Definition: ModuleSummaryAnalysis.cpp:229
llvm::StackSafetyInfo
Interface to access stack safety analysis results for single function.
Definition: StackSafetyAnalysis.h:26
llvm::FunctionSummary::FFlags
Flags specific to function summaries.
Definition: ModuleSummaryIndex.h:561
llvm::GlobalObject::hasComdat
bool hasComdat() const
Definition: GlobalObject.h:124
llvm::SetVector::insert
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:141
llvm::Function::getIntrinsicID
Intrinsic::ID getIntrinsicID() const LLVM_READONLY
getIntrinsicID - This method returns the ID number of the specified function, or Intrinsic::not_intri...
Definition: Function.h:195
llvm::ProfileSummaryAnalysis
An analysis pass based on the new PM to deliver ProfileSummaryInfo.
Definition: ProfileSummaryInfo.h:206
ModuleSymbolTable.h
llvm::StackSafetyInfoWrapperPass
StackSafetyInfo wrapper for the legacy pass manager.
Definition: StackSafetyAnalysis.h:103
llvm::ArrayRef
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: APInt.h:33
llvm::LoopInfo
Definition: LoopInfo.h:1080
llvm::CalleeInfo::HotnessType::Unknown
@ Unknown
llvm::any_of
bool any_of(R &&range, UnaryPredicate P)
Provide wrappers to std::any_of which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1512
llvm::StructType
Class to represent struct types.
Definition: DerivedTypes.h:212
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:57
findFuncPointers
static void findFuncPointers(const Constant *I, uint64_t StartingOffset, const Module &M, ModuleSummaryIndex &Index, VTableFuncList &VTableFuncs)
Find function pointers referenced within the given vtable initializer (or subset of an initializer) I...
Definition: ModuleSummaryAnalysis.cpp:487
llvm::ModuleSummaryIndexWrapperPass::doFinalization
bool doFinalization(Module &M) override
doFinalization - Virtual method overriden by subclasses to do any necessary clean up after all passes...
Definition: ModuleSummaryAnalysis.cpp:897
uint32_t
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
clEnumValN
#define clEnumValN(ENUMVAL, FLAGNAME, DESC)
Definition: CommandLine.h:671
recordTypeIdCompatibleVtableReferences
static void recordTypeIdCompatibleVtableReferences(ModuleSummaryIndex &Index, const GlobalVariable &V, SmallVectorImpl< MDNode * > &Types)
Record vtable definition V for each type metadata it references.
Definition: ModuleSummaryAnalysis.cpp:550
BlockFrequencyInfo.h
llvm::FunctionSummary::FSHT_None
@ FSHT_None
Definition: ModuleSummaryIndex.h:518
llvm::AMDGPUISD::BFI
@ BFI
Definition: AMDGPUISelLowering.h:419
llvm::ICallPromotionAnalysis::getPromotionCandidatesForInstruction
ArrayRef< InstrProfValueData > getPromotionCandidatesForInstruction(const Instruction *I, uint32_t &NumVals, uint64_t &TotalCount, uint32_t &NumCandidates)
Returns reference to array of InstrProfValueData for the given instruction I.
Definition: IndirectCallPromotionAnalysis.cpp:92
llvm::raw_fd_ostream
A raw_ostream that writes to a file descriptor.
Definition: raw_ostream.h:432
Callee
amdgpu Simplify well known AMD library false FunctionCallee Callee
Definition: AMDGPULibCalls.cpp:205
llvm::GlobalValue::isInterposable
bool isInterposable() const
Return true if this global's definition can be substituted with an arbitrary definition at link time ...
Definition: Globals.cpp:98
llvm::CalleeInfo::HotnessType::Critical
@ Critical
Attributes.h
Constant.h
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:80
llvm::GlobalValue::hasLinkOnceODRLinkage
bool hasLinkOnceODRLinkage() const
Definition: GlobalValue.h:436
llvm::createModuleSummaryIndexWrapperPass
ModulePass * createModuleSummaryIndexWrapperPass()
Definition: ModuleSummaryAnalysis.cpp:868
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:52
llvm::AnalysisUsage::setPreservesAll
void setPreservesAll()
Set by analyses that do not transform their input at all.
Definition: PassAnalysisSupport.h:130
llvm::GlobalValue::hasDLLExportStorageClass
bool hasDLLExportStorageClass() const
Definition: GlobalValue.h:262
llvm::findDevirtualizableCallsForTypeCheckedLoad
void findDevirtualizableCallsForTypeCheckedLoad(SmallVectorImpl< DevirtCallSite > &DevirtCalls, SmallVectorImpl< Instruction * > &LoadedPtrs, SmallVectorImpl< Instruction * > &Preds, bool &HasNonCallUses, const CallInst *CI, DominatorTree &DT)
Given a call to the intrinsic @llvm.type.checked.load, find all devirtualizable call sites based on t...
Definition: TypeMetadataUtils.cpp:95
llvm::StructType::elements
ArrayRef< Type * > elements() const
Definition: DerivedTypes.h:321
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:314
llvm::StructLayout::getElementOffset
uint64_t getElementOffset(unsigned Idx) const
Definition: DataLayout.h:653
GlobalVariable.h
llvm::GlobalValue::getGUID
GUID getGUID() const
Return a 64-bit global unique ID constructed from global value name (i.e.
Definition: GlobalValue.h:511
Casting.h
Function.h
llvm::buildModuleSummaryIndex
ModuleSummaryIndex buildModuleSummaryIndex(const Module &M, std::function< BlockFrequencyInfo *(const Function &F)> GetBFICallback, ProfileSummaryInfo *PSI, std::function< const StackSafetyInfo *(const Function &F)> GetSSICallback=[](const Function &F) -> const StackSafetyInfo *{ return nullptr;})
Direct function to compute a ModuleSummaryIndex from a given module.
Definition: ModuleSummaryAnalysis.cpp:642
llvm::cl::value_desc
Definition: CommandLine.h:421
llvm::orc::ReadOnly
static constexpr sys::Memory::ProtectionFlags ReadOnly
Definition: DebugObjectManagerPlugin.cpp:111
llvm::SmallVectorImpl::clear
void clear()
Definition: SmallVector.h:585
GlobalAlias.h
Instructions.h
llvm::ModuleSummaryIndexWrapperPass::runOnModule
bool runOnModule(Module &M) override
runOnModule - Virtual method overriden by subclasses to process the module being operated on.
Definition: ModuleSummaryAnalysis.cpp:877
SmallVector.h
isNonVolatileLoad
static bool isNonVolatileLoad(const Instruction *I)
Definition: ModuleSummaryAnalysis.cpp:222
User.h
llvm::ModuleSummaryIndex
Class to hold module path string table and global value map, and encapsulate methods for operating on...
Definition: ModuleSummaryIndex.h:1026
llvm::GlobalVariable::isConstant
bool isConstant() const
If the value is a global constant, its value is immutable throughout the runtime execution of the pro...
Definition: GlobalVariable.h:153
Dominators.h
llvm::FunctionSummary::FSHT_All
@ FSHT_All
Definition: ModuleSummaryIndex.h:520
llvm::CallBase::getArgOperand
Value * getArgOperand(unsigned i) const
Definition: InstrTypes.h:1341
llvm::SmallPtrSetImplBase::empty
LLVM_NODISCARD bool empty() const
Definition: SmallPtrSet.h:91
llvm::object::BasicSymbolRef::SF_Global
@ SF_Global
Definition: SymbolicFile.h:109
llvm::GlobalObject::getVCallVisibility
VCallVisibility getVCallVisibility() const
Definition: Metadata.cpp:1511
llvm::ModuleSummaryIndexWrapperPass::getAnalysisUsage
void getAnalysisUsage(AnalysisUsage &AU) const override
getAnalysisUsage - This function should be overriden by passes that need analysis information to do t...
Definition: ModuleSummaryAnalysis.cpp:902
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:43
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:44
llvm::InnerAnalysisManagerProxy
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
Definition: PassManager.h:945
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1450
BB
Common register allocation spilling lr str ldr sxth r3 ldr mla r4 can lr mov lr str ldr sxth r3 mla r4 and then merge mul and lr str ldr sxth r3 mla r4 It also increase the likelihood the store may become dead bb27 Successors according to LLVM BB
Definition: README.txt:39
llvm::SetVector::takeVector
Vector takeVector()
Clear the SetVector and return the underlying vector.
Definition: SetVector.h:66
llvm::AnalysisUsage::addRequired
AnalysisUsage & addRequired()
Definition: PassAnalysisSupport.h:75
llvm::ModuleSummaryIndexWrapperPass
Legacy wrapper pass to provide the ModuleSummaryIndex object.
Definition: ModuleSummaryAnalysis.h:57
llvm::Type::TypeID
TypeID
Definitions of all of the base types for the Type system.
Definition: Type.h:55
llvm::AMDGPU::HSAMD::Kernel::Key::Args
constexpr char Args[]
Key for Kernel::Metadata::mArgs.
Definition: AMDGPUMetadata.h:389
llvm::Function::ProfileCount
Class to represent profile counts.
Definition: Function.h:282
llvm::cl::desc
Definition: CommandLine.h:411
llvm::SetVector
A vector that has set insertion semantics.
Definition: SetVector.h:40
llvm::GlobalValue::isDSOLocal
bool isDSOLocal() const
Definition: GlobalValue.h:282
true
basic Basic Alias true
Definition: BasicAliasAnalysis.cpp:1789
InitializePasses.h
llvm::Value
LLVM Value Representation.
Definition: Value.h:75
llvm::ArrayType::getElementType
Type * getElementType() const
Definition: DerivedTypes.h:372
llvm::findDevirtualizableCallsForTypeTest
void findDevirtualizableCallsForTypeTest(SmallVectorImpl< DevirtCallSite > &DevirtCalls, SmallVectorImpl< CallInst * > &Assumes, const CallInst *CI, DominatorTree &DT)
Given a call to the intrinsic @llvm.type.test, find all devirtualizable call sites based on the call ...
Definition: TypeMetadataUtils.cpp:75
SetVector.h
computeAliasSummary
static void computeAliasSummary(ModuleSummaryIndex &Index, const GlobalAlias &A, DenseSet< GlobalValue::GUID > &CantBePromoted)
Definition: ModuleSummaryAnalysis.cpp:616
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:44
llvm::SmallPtrSetImpl::insert
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
Definition: SmallPtrSet.h:364
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38
llvm::ModuleSymbolTable::CollectAsmSymbols
static void CollectAsmSymbols(const Module &M, function_ref< void(StringRef, object::BasicSymbolRef::Flags)> AsmSymbol)
Parse inline ASM and collect the symbols that are defined or referenced in the current module.
Definition: ModuleSymbolTable.cpp:131