LLVM  15.0.0git
ThinLTOBitcodeWriter.cpp
Go to the documentation of this file.
1 //===- ThinLTOBitcodeWriter.cpp - Bitcode writing pass for ThinLTO --------===//
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 
15 #include "llvm/IR/Constants.h"
16 #include "llvm/IR/DebugInfo.h"
17 #include "llvm/IR/Instructions.h"
18 #include "llvm/IR/Intrinsics.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/IR/PassManager.h"
21 #include "llvm/InitializePasses.h"
23 #include "llvm/Pass.h"
25 #include "llvm/Transforms/IPO.h"
31 using namespace llvm;
32 
33 namespace {
34 
35 // Determine if a promotion alias should be created for a symbol name.
36 static bool allowPromotionAlias(const std::string &Name) {
37  // Promotion aliases are used only in inline assembly. It's safe to
38  // simply skip unusual names. Subset of MCAsmInfo::isAcceptableChar()
39  // and MCAsmInfoXCOFF::isAcceptableChar().
40  for (const char &C : Name) {
41  if (isAlnum(C) || C == '_' || C == '.')
42  continue;
43  return false;
44  }
45  return true;
46 }
47 
48 // Promote each local-linkage entity defined by ExportM and used by ImportM by
49 // changing visibility and appending the given ModuleId.
50 void promoteInternals(Module &ExportM, Module &ImportM, StringRef ModuleId,
51  SetVector<GlobalValue *> &PromoteExtra) {
53  for (auto &ExportGV : ExportM.global_values()) {
54  if (!ExportGV.hasLocalLinkage())
55  continue;
56 
57  auto Name = ExportGV.getName();
58  GlobalValue *ImportGV = nullptr;
59  if (!PromoteExtra.count(&ExportGV)) {
60  ImportGV = ImportM.getNamedValue(Name);
61  if (!ImportGV)
62  continue;
63  ImportGV->removeDeadConstantUsers();
64  if (ImportGV->use_empty()) {
65  ImportGV->eraseFromParent();
66  continue;
67  }
68  }
69 
70  std::string OldName = Name.str();
71  std::string NewName = (Name + ModuleId).str();
72 
73  if (const auto *C = ExportGV.getComdat())
74  if (C->getName() == Name)
75  RenamedComdats.try_emplace(C, ExportM.getOrInsertComdat(NewName));
76 
77  ExportGV.setName(NewName);
78  ExportGV.setLinkage(GlobalValue::ExternalLinkage);
79  ExportGV.setVisibility(GlobalValue::HiddenVisibility);
80 
81  if (ImportGV) {
82  ImportGV->setName(NewName);
84  }
85 
86  if (isa<Function>(&ExportGV) && allowPromotionAlias(OldName)) {
87  // Create a local alias with the original name to avoid breaking
88  // references from inline assembly.
89  std::string Alias =
90  ".lto_set_conditional " + OldName + "," + NewName + "\n";
91  ExportM.appendModuleInlineAsm(Alias);
92  }
93  }
94 
95  if (!RenamedComdats.empty())
96  for (auto &GO : ExportM.global_objects())
97  if (auto *C = GO.getComdat()) {
98  auto Replacement = RenamedComdats.find(C);
99  if (Replacement != RenamedComdats.end())
100  GO.setComdat(Replacement->second);
101  }
102 }
103 
104 // Promote all internal (i.e. distinct) type ids used by the module by replacing
105 // them with external type ids formed using the module id.
106 //
107 // Note that this needs to be done before we clone the module because each clone
108 // will receive its own set of distinct metadata nodes.
109 void promoteTypeIds(Module &M, StringRef ModuleId) {
110  DenseMap<Metadata *, Metadata *> LocalToGlobal;
111  auto ExternalizeTypeId = [&](CallInst *CI, unsigned ArgNo) {
112  Metadata *MD =
113  cast<MetadataAsValue>(CI->getArgOperand(ArgNo))->getMetadata();
114 
115  if (isa<MDNode>(MD) && cast<MDNode>(MD)->isDistinct()) {
116  Metadata *&GlobalMD = LocalToGlobal[MD];
117  if (!GlobalMD) {
118  std::string NewName = (Twine(LocalToGlobal.size()) + ModuleId).str();
119  GlobalMD = MDString::get(M.getContext(), NewName);
120  }
121 
122  CI->setArgOperand(ArgNo,
123  MetadataAsValue::get(M.getContext(), GlobalMD));
124  }
125  };
126 
127  if (Function *TypeTestFunc =
128  M.getFunction(Intrinsic::getName(Intrinsic::type_test))) {
129  for (const Use &U : TypeTestFunc->uses()) {
130  auto CI = cast<CallInst>(U.getUser());
131  ExternalizeTypeId(CI, 1);
132  }
133  }
134 
135  if (Function *TypeCheckedLoadFunc =
136  M.getFunction(Intrinsic::getName(Intrinsic::type_checked_load))) {
137  for (const Use &U : TypeCheckedLoadFunc->uses()) {
138  auto CI = cast<CallInst>(U.getUser());
139  ExternalizeTypeId(CI, 2);
140  }
141  }
142 
143  for (GlobalObject &GO : M.global_objects()) {
145  GO.getMetadata(LLVMContext::MD_type, MDs);
146 
147  GO.eraseMetadata(LLVMContext::MD_type);
148  for (auto MD : MDs) {
149  auto I = LocalToGlobal.find(MD->getOperand(1));
150  if (I == LocalToGlobal.end()) {
151  GO.addMetadata(LLVMContext::MD_type, *MD);
152  continue;
153  }
154  GO.addMetadata(
155  LLVMContext::MD_type,
156  *MDNode::get(M.getContext(), {MD->getOperand(0), I->second}));
157  }
158  }
159 }
160 
161 // Drop unused globals, and drop type information from function declarations.
162 // FIXME: If we made functions typeless then there would be no need to do this.
163 void simplifyExternals(Module &M) {
164  FunctionType *EmptyFT =
165  FunctionType::get(Type::getVoidTy(M.getContext()), false);
166 
168  if (F.isDeclaration() && F.use_empty()) {
169  F.eraseFromParent();
170  continue;
171  }
172 
173  if (!F.isDeclaration() || F.getFunctionType() == EmptyFT ||
174  // Changing the type of an intrinsic may invalidate the IR.
175  F.getName().startswith("llvm."))
176  continue;
177 
178  Function *NewF =
180  F.getAddressSpace(), "", &M);
181  NewF->copyAttributesFrom(&F);
182  // Only copy function attribtues.
183  NewF->setAttributes(AttributeList::get(M.getContext(),
185  F.getAttributes().getFnAttrs()));
186  NewF->takeName(&F);
187  F.replaceAllUsesWith(ConstantExpr::getBitCast(NewF, F.getType()));
188  F.eraseFromParent();
189  }
190 
191  for (GlobalVariable &GV : llvm::make_early_inc_range(M.globals())) {
192  if (GV.isDeclaration() && GV.use_empty()) {
193  GV.eraseFromParent();
194  continue;
195  }
196  }
197 }
198 
199 static void
200 filterModule(Module *M,
201  function_ref<bool(const GlobalValue *)> ShouldKeepDefinition) {
202  std::vector<GlobalValue *> V;
203  for (GlobalValue &GV : M->global_values())
204  if (!ShouldKeepDefinition(&GV))
205  V.push_back(&GV);
206 
207  for (GlobalValue *GV : V)
208  if (!convertToDeclaration(*GV))
209  GV->eraseFromParent();
210 }
211 
212 void forEachVirtualFunction(Constant *C, function_ref<void(Function *)> Fn) {
213  if (auto *F = dyn_cast<Function>(C))
214  return Fn(F);
215  if (isa<GlobalValue>(C))
216  return;
217  for (Value *Op : C->operands())
218  forEachVirtualFunction(cast<Constant>(Op), Fn);
219 }
220 
221 // Clone any @llvm[.compiler].used over to the new module and append
222 // values whose defs were cloned into that module.
223 static void cloneUsedGlobalVariables(const Module &SrcM, Module &DestM,
224  bool CompilerUsed) {
226  // First collect those in the llvm[.compiler].used set.
227  collectUsedGlobalVariables(SrcM, Used, CompilerUsed);
228  // Next build a set of the equivalent values defined in DestM.
229  for (auto *V : Used) {
230  auto *GV = DestM.getNamedValue(V->getName());
231  if (GV && !GV->isDeclaration())
232  NewUsed.push_back(GV);
233  }
234  // Finally, add them to a llvm[.compiler].used variable in DestM.
235  if (CompilerUsed)
236  appendToCompilerUsed(DestM, NewUsed);
237  else
238  appendToUsed(DestM, NewUsed);
239 }
240 
241 // If it's possible to split M into regular and thin LTO parts, do so and write
242 // a multi-module bitcode file with the two parts to OS. Otherwise, write only a
243 // regular LTO bitcode file to OS.
244 void splitAndWriteThinLTOBitcode(
245  raw_ostream &OS, raw_ostream *ThinLinkOS,
246  function_ref<AAResults &(Function &)> AARGetter, Module &M) {
247  std::string ModuleId = getUniqueModuleId(&M);
248  if (ModuleId.empty()) {
249  // We couldn't generate a module ID for this module, write it out as a
250  // regular LTO module with an index for summary-based dead stripping.
251  ProfileSummaryInfo PSI(M);
252  M.addModuleFlag(Module::Error, "ThinLTO", uint32_t(0));
254  WriteBitcodeToFile(M, OS, /*ShouldPreserveUseListOrder=*/false, &Index);
255 
256  if (ThinLinkOS)
257  // We don't have a ThinLTO part, but still write the module to the
258  // ThinLinkOS if requested so that the expected output file is produced.
259  WriteBitcodeToFile(M, *ThinLinkOS, /*ShouldPreserveUseListOrder=*/false,
260  &Index);
261 
262  return;
263  }
264 
265  promoteTypeIds(M, ModuleId);
266 
267  // Returns whether a global or its associated global has attached type
268  // metadata. The former may participate in CFI or whole-program
269  // devirtualization, so they need to appear in the merged module instead of
270  // the thin LTO module. Similarly, globals that are associated with globals
271  // with type metadata need to appear in the merged module because they will
272  // reference the global's section directly.
273  auto HasTypeMetadata = [](const GlobalObject *GO) {
274  if (MDNode *MD = GO->getMetadata(LLVMContext::MD_associated))
275  if (auto *AssocVM = dyn_cast_or_null<ValueAsMetadata>(MD->getOperand(0)))
276  if (auto *AssocGO = dyn_cast<GlobalObject>(AssocVM->getValue()))
277  if (AssocGO->hasMetadata(LLVMContext::MD_type))
278  return true;
279  return GO->hasMetadata(LLVMContext::MD_type);
280  };
281 
282  // Collect the set of virtual functions that are eligible for virtual constant
283  // propagation. Each eligible function must not access memory, must return
284  // an integer of width <=64 bits, must take at least one argument, must not
285  // use its first argument (assumed to be "this") and all arguments other than
286  // the first one must be of <=64 bit integer type.
287  //
288  // Note that we test whether this copy of the function is readnone, rather
289  // than testing function attributes, which must hold for any copy of the
290  // function, even a less optimized version substituted at link time. This is
291  // sound because the virtual constant propagation optimizations effectively
292  // inline all implementations of the virtual function into each call site,
293  // rather than using function attributes to perform local optimization.
294  DenseSet<const Function *> EligibleVirtualFns;
295  // If any member of a comdat lives in MergedM, put all members of that
296  // comdat in MergedM to keep the comdat together.
297  DenseSet<const Comdat *> MergedMComdats;
298  for (GlobalVariable &GV : M.globals())
299  if (HasTypeMetadata(&GV)) {
300  if (const auto *C = GV.getComdat())
301  MergedMComdats.insert(C);
302  forEachVirtualFunction(GV.getInitializer(), [&](Function *F) {
303  auto *RT = dyn_cast<IntegerType>(F->getReturnType());
304  if (!RT || RT->getBitWidth() > 64 || F->arg_empty() ||
305  !F->arg_begin()->use_empty())
306  return;
307  for (auto &Arg : drop_begin(F->args())) {
308  auto *ArgT = dyn_cast<IntegerType>(Arg.getType());
309  if (!ArgT || ArgT->getBitWidth() > 64)
310  return;
311  }
312  if (!F->isDeclaration() &&
313  computeFunctionBodyMemoryAccess(*F, AARGetter(*F)) ==
315  EligibleVirtualFns.insert(F);
316  });
317  }
318 
319  ValueToValueMapTy VMap;
320  std::unique_ptr<Module> MergedM(
321  CloneModule(M, VMap, [&](const GlobalValue *GV) -> bool {
322  if (const auto *C = GV->getComdat())
323  if (MergedMComdats.count(C))
324  return true;
325  if (auto *F = dyn_cast<Function>(GV))
326  return EligibleVirtualFns.count(F);
327  if (auto *GVar =
328  dyn_cast_or_null<GlobalVariable>(GV->getAliaseeObject()))
329  return HasTypeMetadata(GVar);
330  return false;
331  }));
332  StripDebugInfo(*MergedM);
333  MergedM->setModuleInlineAsm("");
334 
335  // Clone any llvm.*used globals to ensure the included values are
336  // not deleted.
337  cloneUsedGlobalVariables(M, *MergedM, /*CompilerUsed*/ false);
338  cloneUsedGlobalVariables(M, *MergedM, /*CompilerUsed*/ true);
339 
340  for (Function &F : *MergedM)
341  if (!F.isDeclaration()) {
342  // Reset the linkage of all functions eligible for virtual constant
343  // propagation. The canonical definitions live in the thin LTO module so
344  // that they can be imported.
346  F.setComdat(nullptr);
347  }
348 
349  SetVector<GlobalValue *> CfiFunctions;
350  for (auto &F : M)
351  if ((!F.hasLocalLinkage() || F.hasAddressTaken()) && HasTypeMetadata(&F))
352  CfiFunctions.insert(&F);
353 
354  // Remove all globals with type metadata, globals with comdats that live in
355  // MergedM, and aliases pointing to such globals from the thin LTO module.
356  filterModule(&M, [&](const GlobalValue *GV) {
357  if (auto *GVar = dyn_cast_or_null<GlobalVariable>(GV->getAliaseeObject()))
358  if (HasTypeMetadata(GVar))
359  return false;
360  if (const auto *C = GV->getComdat())
361  if (MergedMComdats.count(C))
362  return false;
363  return true;
364  });
365 
366  promoteInternals(*MergedM, M, ModuleId, CfiFunctions);
367  promoteInternals(M, *MergedM, ModuleId, CfiFunctions);
368 
369  auto &Ctx = MergedM->getContext();
370  SmallVector<MDNode *, 8> CfiFunctionMDs;
371  for (auto V : CfiFunctions) {
372  Function &F = *cast<Function>(V);
374  F.getMetadata(LLVMContext::MD_type, Types);
375 
377  Elts.push_back(MDString::get(Ctx, F.getName()));
381  else if (F.hasExternalWeakLinkage())
383  else
385  Elts.push_back(ConstantAsMetadata::get(
386  llvm::ConstantInt::get(Type::getInt8Ty(Ctx), Linkage)));
387  append_range(Elts, Types);
388  CfiFunctionMDs.push_back(MDTuple::get(Ctx, Elts));
389  }
390 
391  if(!CfiFunctionMDs.empty()) {
392  NamedMDNode *NMD = MergedM->getOrInsertNamedMetadata("cfi.functions");
393  for (auto MD : CfiFunctionMDs)
394  NMD->addOperand(MD);
395  }
396 
397  SmallVector<MDNode *, 8> FunctionAliases;
398  for (auto &A : M.aliases()) {
399  if (!isa<Function>(A.getAliasee()))
400  continue;
401 
402  auto *F = cast<Function>(A.getAliasee());
403 
404  Metadata *Elts[] = {
405  MDString::get(Ctx, A.getName()),
406  MDString::get(Ctx, F->getName()),
408  ConstantInt::get(Type::getInt8Ty(Ctx), A.getVisibility())),
410  ConstantInt::get(Type::getInt8Ty(Ctx), A.isWeakForLinker())),
411  };
412 
413  FunctionAliases.push_back(MDTuple::get(Ctx, Elts));
414  }
415 
416  if (!FunctionAliases.empty()) {
417  NamedMDNode *NMD = MergedM->getOrInsertNamedMetadata("aliases");
418  for (auto MD : FunctionAliases)
419  NMD->addOperand(MD);
420  }
421 
422  SmallVector<MDNode *, 8> Symvers;
424  Function *F = M.getFunction(Name);
425  if (!F || F->use_empty())
426  return;
427 
428  Symvers.push_back(MDTuple::get(
429  Ctx, {MDString::get(Ctx, Name), MDString::get(Ctx, Alias)}));
430  });
431 
432  if (!Symvers.empty()) {
433  NamedMDNode *NMD = MergedM->getOrInsertNamedMetadata("symvers");
434  for (auto MD : Symvers)
435  NMD->addOperand(MD);
436  }
437 
438  simplifyExternals(*MergedM);
439 
440  // FIXME: Try to re-use BSI and PFI from the original module here.
441  ProfileSummaryInfo PSI(M);
443 
444  // Mark the merged module as requiring full LTO. We still want an index for
445  // it though, so that it can participate in summary-based dead stripping.
446  MergedM->addModuleFlag(Module::Error, "ThinLTO", uint32_t(0));
447  ModuleSummaryIndex MergedMIndex =
448  buildModuleSummaryIndex(*MergedM, nullptr, &PSI);
449 
450  SmallVector<char, 0> Buffer;
451 
452  BitcodeWriter W(Buffer);
453  // Save the module hash produced for the full bitcode, which will
454  // be used in the backends, and use that in the minimized bitcode
455  // produced for the full link.
456  ModuleHash ModHash = {{0}};
457  W.writeModule(M, /*ShouldPreserveUseListOrder=*/false, &Index,
458  /*GenerateHash=*/true, &ModHash);
459  W.writeModule(*MergedM, /*ShouldPreserveUseListOrder=*/false, &MergedMIndex);
460  W.writeSymtab();
461  W.writeStrtab();
462  OS << Buffer;
463 
464  // If a minimized bitcode module was requested for the thin link, only
465  // the information that is needed by thin link will be written in the
466  // given OS (the merged module will be written as usual).
467  if (ThinLinkOS) {
468  Buffer.clear();
469  BitcodeWriter W2(Buffer);
470  StripDebugInfo(M);
471  W2.writeThinLinkBitcode(M, Index, ModHash);
472  W2.writeModule(*MergedM, /*ShouldPreserveUseListOrder=*/false,
473  &MergedMIndex);
474  W2.writeSymtab();
475  W2.writeStrtab();
476  *ThinLinkOS << Buffer;
477  }
478 }
479 
480 // Check if the LTO Unit splitting has been enabled.
481 bool enableSplitLTOUnit(Module &M) {
482  bool EnableSplitLTOUnit = false;
483  if (auto *MD = mdconst::extract_or_null<ConstantInt>(
484  M.getModuleFlag("EnableSplitLTOUnit")))
485  EnableSplitLTOUnit = MD->getZExtValue();
486  return EnableSplitLTOUnit;
487 }
488 
489 // Returns whether this module needs to be split because it uses type metadata.
490 bool hasTypeMetadata(Module &M) {
491  for (auto &GO : M.global_objects()) {
492  if (GO.hasMetadata(LLVMContext::MD_type))
493  return true;
494  }
495  return false;
496 }
497 
498 void writeThinLTOBitcode(raw_ostream &OS, raw_ostream *ThinLinkOS,
499  function_ref<AAResults &(Function &)> AARGetter,
500  Module &M, const ModuleSummaryIndex *Index) {
501  std::unique_ptr<ModuleSummaryIndex> NewIndex = nullptr;
502  // See if this module has any type metadata. If so, we try to split it
503  // or at least promote type ids to enable WPD.
504  if (hasTypeMetadata(M)) {
505  if (enableSplitLTOUnit(M))
506  return splitAndWriteThinLTOBitcode(OS, ThinLinkOS, AARGetter, M);
507  // Promote type ids as needed for index-based WPD.
508  std::string ModuleId = getUniqueModuleId(&M);
509  if (!ModuleId.empty()) {
510  promoteTypeIds(M, ModuleId);
511  // Need to rebuild the index so that it contains type metadata
512  // for the newly promoted type ids.
513  // FIXME: Probably should not bother building the index at all
514  // in the caller of writeThinLTOBitcode (which does so via the
515  // ModuleSummaryIndexAnalysis pass), since we have to rebuild it
516  // anyway whenever there is type metadata (here or in
517  // splitAndWriteThinLTOBitcode). Just always build it once via the
518  // buildModuleSummaryIndex when Module(s) are ready.
519  ProfileSummaryInfo PSI(M);
520  NewIndex = std::make_unique<ModuleSummaryIndex>(
521  buildModuleSummaryIndex(M, nullptr, &PSI));
522  Index = NewIndex.get();
523  }
524  }
525 
526  // Write it out as an unsplit ThinLTO module.
527 
528  // Save the module hash produced for the full bitcode, which will
529  // be used in the backends, and use that in the minimized bitcode
530  // produced for the full link.
531  ModuleHash ModHash = {{0}};
532  WriteBitcodeToFile(M, OS, /*ShouldPreserveUseListOrder=*/false, Index,
533  /*GenerateHash=*/true, &ModHash);
534  // If a minimized bitcode module was requested for the thin link, only
535  // the information that is needed by thin link will be written in the
536  // given OS.
537  if (ThinLinkOS && Index)
538  writeThinLinkBitcodeToFile(M, *ThinLinkOS, *Index, ModHash);
539 }
540 
541 class WriteThinLTOBitcode : public ModulePass {
542  raw_ostream &OS; // raw_ostream to print on
543  // The output stream on which to emit a minimized module for use
544  // just in the thin link, if requested.
545  raw_ostream *ThinLinkOS = nullptr;
546 
547 public:
548  static char ID; // Pass identification, replacement for typeid
549  WriteThinLTOBitcode() : ModulePass(ID), OS(dbgs()) {
551  }
552 
553  explicit WriteThinLTOBitcode(raw_ostream &o, raw_ostream *ThinLinkOS)
554  : ModulePass(ID), OS(o), ThinLinkOS(ThinLinkOS) {
556  }
557 
558  StringRef getPassName() const override { return "ThinLTO Bitcode Writer"; }
559 
560  bool runOnModule(Module &M) override {
561  const ModuleSummaryIndex *Index =
562  &(getAnalysis<ModuleSummaryIndexWrapperPass>().getIndex());
563  writeThinLTOBitcode(OS, ThinLinkOS, LegacyAARGetter(*this), M, Index);
564  return true;
565  }
566  void getAnalysisUsage(AnalysisUsage &AU) const override {
567  AU.setPreservesAll();
571  }
572 };
573 } // anonymous namespace
574 
575 char WriteThinLTOBitcode::ID = 0;
576 INITIALIZE_PASS_BEGIN(WriteThinLTOBitcode, "write-thinlto-bitcode",
577  "Write ThinLTO Bitcode", false, true)
581 INITIALIZE_PASS_END(WriteThinLTOBitcode, "write-thinlto-bitcode",
582  "Write ThinLTO Bitcode", false, true)
583 
585  raw_ostream *ThinLinkOS) {
586  return new WriteThinLTOBitcode(Str, ThinLinkOS);
587 }
588 
593  writeThinLTOBitcode(OS, ThinLinkOS,
594  [&FAM](Function &F) -> AAResults & {
595  return FAM.getResult<AAManager>(F);
596  },
598  return PreservedAnalyses::all();
599 }
llvm::Module::global_values
iterator_range< global_value_iterator > global_values()
Definition: Module.cpp:421
llvm::PreservedAnalyses
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:152
llvm::Module::appendModuleInlineAsm
void appendModuleInlineAsm(StringRef Asm)
Append to the module-scope inline assembly blocks.
Definition: Module.h:313
llvm::AAManager
A manager for alias analyses.
Definition: AliasAnalysis.h:1303
ThinLTOBitcodeWriter.h
llvm::StripDebugInfo
bool StripDebugInfo(Module &M)
Strip debug info in the module if it exists.
Definition: DebugInfo.cpp:474
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:17
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::NamedMDNode
A tuple of MDNodes.
Definition: Metadata.h:1572
llvm::ModulePass
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:248
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:780
INITIALIZE_PASS_BEGIN
INITIALIZE_PASS_BEGIN(WriteThinLTOBitcode, "write-thinlto-bitcode", "Write ThinLTO Bitcode", false, true) INITIALIZE_PASS_END(WriteThinLTOBitcode
llvm::GlobalValue::HiddenVisibility
@ HiddenVisibility
The GV is hidden.
Definition: GlobalValue.h:64
llvm::Function
Definition: Function.h:60
Pass.h
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1185
llvm::RISCVFenceField::W
@ W
Definition: RISCVBaseInfo.h:242
FunctionImport.h
llvm::ModuleSummaryIndexAnalysis
Analysis pass to provide the ModuleSummaryIndex object.
Definition: ModuleSummaryAnalysis.h:44
llvm::Intrinsic::getName
StringRef getName(ID id)
Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
Definition: Function.cpp:880
llvm::GlobalVariable
Definition: GlobalVariable.h:39
llvm::ConstantExpr::getBitCast
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:2257
llvm::FunctionType::get
static FunctionType * get(Type *Result, ArrayRef< Type * > Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:361
llvm::AttributeList::get
static AttributeList get(LLVMContext &C, ArrayRef< std::pair< unsigned, Attribute >> Attrs)
Create an AttributeList with the specified parameters in it.
Definition: Attributes.cpp:1050
FAM
FunctionAnalysisManager FAM
Definition: PassBuilderBindings.cpp:59
llvm::CFL_Definition
@ CFL_Definition
Definition: TypeMetadataUtils.h:32
true
basic Basic Alias true
Definition: BasicAliasAnalysis.cpp:1886
llvm::ZeroCallUsedRegs::ZeroCallUsedRegsKind::Used
@ Used
Module.h
llvm::ConstantAsMetadata::get
static ConstantAsMetadata * get(Constant *C)
Definition: Metadata.h:420
llvm::Module::global_objects
iterator_range< global_object_iterator > global_objects()
Definition: Module.cpp:413
ModuleSummaryAnalysis.h
llvm::detail::DenseSetImpl< ValueT, DenseMap< ValueT, detail::DenseSetEmpty, DenseMapInfo< ValueT >, detail::DenseSetPair< ValueT > >, DenseMapInfo< ValueT > >::insert
std::pair< iterator, bool > insert(const ValueT &V)
Definition: DenseSet.h:206
BasicAliasAnalysis.h
llvm::detail::DenseSetImpl< ValueT, DenseMap< ValueT, detail::DenseSetEmpty, DenseMapInfo< ValueT >, detail::DenseSetPair< ValueT > >, DenseMapInfo< ValueT > >::count
size_type count(const_arg_type_t< ValueT > V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:97
llvm::Type::getInt8Ty
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:237
llvm::MDNode::get
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1384
F
#define F(x, y, z)
Definition: MD5.cpp:55
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:786
llvm::dbgs
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
llvm::NamedMDNode::addOperand
void addOperand(MDNode *M)
Definition: Metadata.cpp:1228
llvm::initializeWriteThinLTOBitcodePass
void initializeWriteThinLTOBitcodePass(PassRegistry &)
llvm::PassRegistry::getPassRegistry
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
Definition: PassRegistry.cpp:31
llvm::ThinLTOBitcodeWriterPass::run
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
Definition: ThinLTOBitcodeWriter.cpp:590
Constants.h
llvm::AAResults
Definition: AliasAnalysis.h:511
BitcodeWriter.h
Intrinsics.h
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::ARM_PROC::A
@ A
Definition: ARMBaseInfo.h:34
llvm::GlobalObject
Definition: GlobalObject.h:27
TypeMetadataUtils.h
llvm::AnalysisUsage
Represent the analysis usage information of a pass.
Definition: PassAnalysisSupport.h:47
bitcode
write thinlto bitcode
Definition: ThinLTOBitcodeWriter.cpp:581
llvm::Value::uses
iterator_range< use_iterator > uses()
Definition: Value.h:376
false
Definition: StackSlotColoring.cpp:141
llvm::dwarf::Index
Index
Definition: Dwarf.h:472
llvm::appendToCompilerUsed
void appendToCompilerUsed(Module &M, ArrayRef< GlobalValue * > Values)
Adds global values to the llvm.compiler.used list.
Definition: ModuleUtils.cpp:109
llvm::CFL_WeakDeclaration
@ CFL_WeakDeclaration
Definition: TypeMetadataUtils.h:34
llvm::Function::copyAttributesFrom
void copyAttributesFrom(const Function *Src)
copyAttributesFrom - copy all additional attributes (those not needed to create a Function) from the ...
Definition: Function.cpp:712
llvm::raw_ostream
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:54
llvm::Value::setName
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:372
llvm::ConstantInt::get
static Constant * get(Type *Ty, uint64_t V, bool IsSigned=false)
If Ty is a vector type, return a Constant with a splat of the given value.
Definition: Constants.cpp:926
llvm::Metadata
Root of the metadata hierarchy.
Definition: Metadata.h:62
llvm::Value::use_empty
bool use_empty() const
Definition: Value.h:344
llvm::CallingConv::ID
unsigned ID
LLVM IR allows to use arbitrary numbers as calling convention identifiers.
Definition: CallingConv.h:24
INITIALIZE_PASS_END
#define INITIALIZE_PASS_END(passName, arg, name, cfg, analysis)
Definition: PassSupport.h:58
llvm::ProfileSummaryInfo
Analysis providing profile information.
Definition: ProfileSummaryInfo.h:39
llvm::convertToDeclaration
bool convertToDeclaration(GlobalValue &GV)
Converts value GV to declaration, or replaces with a declaration if it is an alias.
Definition: FunctionImport.cpp:1016
llvm::function_ref
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLFunctionalExtras.h:36
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::Constant
This is an important base class in LLVM.
Definition: Constant.h:41
llvm::TargetLibraryInfoWrapperPass
Definition: TargetLibraryInfo.h:468
ProfileSummaryInfo.h
INITIALIZE_PASS_DEPENDENCY
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
IPO.h
llvm::DenseMap
Definition: DenseMap.h:716
DebugInfo.h
I
#define I(x, y, z)
Definition: MD5.cpp:58
Cloning.h
llvm::appendToUsed
void appendToUsed(Module &M, ArrayRef< GlobalValue * > Values)
Adds global values to the llvm.used list.
Definition: ModuleUtils.cpp:105
llvm::make_early_inc_range
iterator_range< early_inc_iterator_impl< detail::IterOfRange< RangeT > > > make_early_inc_range(RangeT &&Range)
Make a range that does early increment to allow mutation of the underlying range without disrupting i...
Definition: STLExtras.h:618
llvm::Module::getOrInsertComdat
Comdat * getOrInsertComdat(StringRef Name)
Return the Comdat in the module with the specified name.
Definition: Module.cpp:582
llvm::MDString::get
static MDString * get(LLVMContext &Context, StringRef Str)
Definition: Metadata.cpp:497
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::find
iterator find(const_arg_type_t< KeyT > Val)
Definition: DenseMap.h:152
llvm::BitcodeWriter
Definition: BitcodeWriter.h:32
llvm::Function::Create
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:137
llvm::MDTuple::get
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata * > MDs)
Definition: Metadata.h:1341
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::MDNode
Metadata node.
Definition: Metadata.h:944
llvm::FMRB_DoesNotAccessMemory
@ FMRB_DoesNotAccessMemory
This function does not perform any non-local loads or stores to memory.
Definition: AliasAnalysis.h:268
llvm::computeFunctionBodyMemoryAccess
FunctionModRefBehavior computeFunctionBodyMemoryAccess(Function &F, AAResults &AAR)
Returns the memory access properties of this copy of the function.
Definition: FunctionAttrs.cpp:256
llvm::SetVector::insert
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:141
llvm::WriteBitcodeToFile
void WriteBitcodeToFile(const Module &M, raw_ostream &Out, bool ShouldPreserveUseListOrder=false, const ModuleSummaryIndex *Index=nullptr, bool GenerateHash=false, ModuleHash *ModHash=nullptr)
Write the specified module to the specified raw output stream.
Definition: BitcodeWriter.cpp:4687
ModuleSymbolTable.h
llvm::AssumptionCacheTracker
An immutable pass that tracks lazily created AssumptionCache objects.
Definition: AssumptionCache.h:202
llvm::Constant::removeDeadConstantUsers
void removeDeadConstantUsers() const
If there are any dead constant users dangling off of this constant, remove them.
Definition: Constants.cpp:749
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:58
if
if(llvm_vc STREQUAL "") set(fake_version_inc "$
Definition: CMakeLists.txt:14
uint32_t
llvm::append_range
void append_range(Container &C, Range &&R)
Wrapper function to append a range to a container.
Definition: STLExtras.h:1823
LowerTypeTests.h
llvm::GlobalValue::AvailableExternallyLinkage
@ AvailableExternallyLinkage
Available for inspection, not emission.
Definition: GlobalValue.h:49
llvm::GlobalValue::getAliaseeObject
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:352
llvm::Module::Error
@ Error
Emits an error if two values disagree, otherwise the resulting value is that of the operands.
Definition: Module.h:118
llvm::ValueMap< const Value *, WeakTrackingVH >
llvm::CallBase::setArgOperand
void setArgOperand(unsigned i, Value *v)
Definition: InstrTypes.h:1346
llvm::GlobalValue::eraseFromParent
void eraseFromParent()
This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:88
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::empty
LLVM_NODISCARD bool empty() const
Definition: DenseMap.h:98
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:83
llvm::GraphProgram::Name
Name
Definition: GraphWriter.h:50
llvm::AnalysisUsage::setPreservesAll
void setPreservesAll()
Set by analyses that do not transform their input at all.
Definition: PassAnalysisSupport.h:130
llvm::ModuleSymbolTable::CollectAsmSymvers
static void CollectAsmSymvers(const Module &M, function_ref< void(StringRef, StringRef)> AsmSymver)
Parse inline ASM and collect the symvers directives that are defined in the current module.
Definition: ModuleSymbolTable.cpp:167
llvm::MetadataAsValue::get
static MetadataAsValue * get(LLVMContext &Context, Metadata *MD)
Definition: Metadata.cpp:102
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::end
iterator end()
Definition: DenseMap.h:84
llvm::AMDGPU::SendMsg::Op
Op
Definition: SIDefines.h:348
llvm::PreservedAnalyses::all
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:158
llvm::GlobalValue::getComdat
const Comdat * getComdat() const
Definition: Globals.cpp:181
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::size
unsigned size() const
Definition: DenseMap.h:101
PassManager.h
llvm::SetVector::count
size_type count(const key_type &key) const
Count the number of elements of a given key in the SetVector.
Definition: SetVector.h:215
llvm::getUniqueModuleId
std::string getUniqueModuleId(Module *M)
Produce a unique identifier for this module by taking the MD5 sum of the names of the module's strong...
Definition: ModuleUtils.cpp:207
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:675
llvm::SmallVectorImpl::clear
void clear()
Definition: SmallVector.h:591
llvm::CfiFunctionLinkage
CfiFunctionLinkage
The type of CFI jumptable needed for a function.
Definition: TypeMetadataUtils.h:31
llvm::writeThinLinkBitcodeToFile
void writeThinLinkBitcodeToFile(const Module &M, raw_ostream &Out, const ModuleSummaryIndex &Index, const ModuleHash &ModHash)
Write the specified thin link bitcode file (i.e., the minimized bitcode file) to the given raw output...
Definition: BitcodeWriter.cpp:4892
llvm::GlobalValue::ExternalLinkage
@ ExternalLinkage
Externally visible function.
Definition: GlobalValue.h:48
llvm::AttributeList::FunctionIndex
@ FunctionIndex
Definition: Attributes.h:429
llvm::Type::getVoidTy
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:222
Instructions.h
llvm::ModuleSummaryIndex
Class to hold module path string table and global value map, and encapsulate methods for operating on...
Definition: ModuleSummaryIndex.h:1087
ModuleUtils.h
llvm::CloneModule
std::unique_ptr< Module > CloneModule(const Module &M)
Return an exact copy of the specified module.
Definition: CloneModule.cpp:37
llvm::CallBase::getArgOperand
Value * getArgOperand(unsigned i) const
Definition: InstrTypes.h:1341
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::try_emplace
std::pair< iterator, bool > try_emplace(KeyT &&Key, Ts &&... Args)
Definition: DenseMap.h:224
llvm::createWriteThinLTOBitcodePass
ModulePass * createWriteThinLTOBitcodePass(raw_ostream &Str, raw_ostream *ThinLinkOS=nullptr)
Write ThinLTO-ready bitcode to Str.
Definition: ThinLTOBitcodeWriter.cpp:584
llvm::AnalysisManager
A container for analyses that lazily runs them and caches their results.
Definition: InstructionSimplify.h:42
llvm::InnerAnalysisManagerProxy
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
Definition: PassManager.h:937
llvm::CallInst
This class represents a function call, abstracting a target machine's calling convention.
Definition: Instructions.h:1461
llvm::AnalysisUsage::addRequired
AnalysisUsage & addRequired()
Definition: PassAnalysisSupport.h:75
llvm::ModuleSummaryIndexWrapperPass
Legacy wrapper pass to provide the ModuleSummaryIndex object.
Definition: ModuleSummaryAnalysis.h:57
llvm::Value::takeName
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:378
raw_ostream.h
llvm::SetVector
A vector that has set insertion semantics.
Definition: SetVector.h:40
llvm::lowertypetests::isJumpTableCanonical
bool isJumpTableCanonical(Function *F)
Definition: LowerTypeTests.cpp:240
llvm::ModuleHash
std::array< uint32_t, 5 > ModuleHash
160 bits SHA1
Definition: ModuleSummaryIndex.h:1042
llvm::Function::setAttributes
void setAttributes(AttributeList Attrs)
Set the attribute list for this Function.
Definition: Function.h:317
llvm::LegacyAARGetter
This class is a functor to be used in legacy module or SCC passes for computing AA results for a func...
Definition: BasicAliasAnalysis.h:200
llvm::GlobalValue::setVisibility
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:240
InitializePasses.h
llvm::CFL_Declaration
@ CFL_Declaration
Definition: TypeMetadataUtils.h:33
llvm::Value
LLVM Value Representation.
Definition: Value.h:74
FunctionAttrs.h
llvm::Module::getNamedValue
GlobalValue * getNamedValue(StringRef Name) const
Return the global value in the module with the specified name, of arbitrary type.
Definition: Module.cpp:110
llvm::FunctionType
Class to represent function types.
Definition: DerivedTypes.h:103
llvm::Use
A Use represents the edge between a Value definition and its users.
Definition: Use.h:43
write
static void write(bool isBE, void *P, T V)
Definition: RuntimeDyldELF.cpp:37
Bitcode
write thinlto Write ThinLTO Bitcode
Definition: ThinLTOBitcodeWriter.cpp:582
llvm::Intrinsic::ID
unsigned ID
Definition: TargetTransformInfo.h:38