LLVM  8.0.0svn
ThinLTOBitcodeWriter.cpp
Go to the documentation of this file.
1 //===- ThinLTOBitcodeWriter.cpp - Bitcode writing pass for ThinLTO --------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
16 #include "llvm/IR/Constants.h"
17 #include "llvm/IR/DebugInfo.h"
18 #include "llvm/IR/Intrinsics.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/IR/PassManager.h"
22 #include "llvm/Pass.h"
25 #include "llvm/Transforms/IPO.h"
30 using namespace llvm;
31 
32 namespace {
33 
34 // Promote each local-linkage entity defined by ExportM and used by ImportM by
35 // changing visibility and appending the given ModuleId.
36 void promoteInternals(Module &ExportM, Module &ImportM, StringRef ModuleId,
37  SetVector<GlobalValue *> &PromoteExtra) {
39  for (auto &ExportGV : ExportM.global_values()) {
40  if (!ExportGV.hasLocalLinkage())
41  continue;
42 
43  auto Name = ExportGV.getName();
44  GlobalValue *ImportGV = nullptr;
45  if (!PromoteExtra.count(&ExportGV)) {
46  ImportGV = ImportM.getNamedValue(Name);
47  if (!ImportGV)
48  continue;
49  ImportGV->removeDeadConstantUsers();
50  if (ImportGV->use_empty()) {
51  ImportGV->eraseFromParent();
52  continue;
53  }
54  }
55 
56  std::string NewName = (Name + ModuleId).str();
57 
58  if (const auto *C = ExportGV.getComdat())
59  if (C->getName() == Name)
60  RenamedComdats.try_emplace(C, ExportM.getOrInsertComdat(NewName));
61 
62  ExportGV.setName(NewName);
63  ExportGV.setLinkage(GlobalValue::ExternalLinkage);
64  ExportGV.setVisibility(GlobalValue::HiddenVisibility);
65 
66  if (ImportGV) {
67  ImportGV->setName(NewName);
69  }
70  }
71 
72  if (!RenamedComdats.empty())
73  for (auto &GO : ExportM.global_objects())
74  if (auto *C = GO.getComdat()) {
75  auto Replacement = RenamedComdats.find(C);
76  if (Replacement != RenamedComdats.end())
77  GO.setComdat(Replacement->second);
78  }
79 }
80 
81 // Promote all internal (i.e. distinct) type ids used by the module by replacing
82 // them with external type ids formed using the module id.
83 //
84 // Note that this needs to be done before we clone the module because each clone
85 // will receive its own set of distinct metadata nodes.
86 void promoteTypeIds(Module &M, StringRef ModuleId) {
88  auto ExternalizeTypeId = [&](CallInst *CI, unsigned ArgNo) {
89  Metadata *MD =
90  cast<MetadataAsValue>(CI->getArgOperand(ArgNo))->getMetadata();
91 
92  if (isa<MDNode>(MD) && cast<MDNode>(MD)->isDistinct()) {
93  Metadata *&GlobalMD = LocalToGlobal[MD];
94  if (!GlobalMD) {
95  std::string NewName = (Twine(LocalToGlobal.size()) + ModuleId).str();
96  GlobalMD = MDString::get(M.getContext(), NewName);
97  }
98 
99  CI->setArgOperand(ArgNo,
100  MetadataAsValue::get(M.getContext(), GlobalMD));
101  }
102  };
103 
104  if (Function *TypeTestFunc =
105  M.getFunction(Intrinsic::getName(Intrinsic::type_test))) {
106  for (const Use &U : TypeTestFunc->uses()) {
107  auto CI = cast<CallInst>(U.getUser());
108  ExternalizeTypeId(CI, 1);
109  }
110  }
111 
112  if (Function *TypeCheckedLoadFunc =
113  M.getFunction(Intrinsic::getName(Intrinsic::type_checked_load))) {
114  for (const Use &U : TypeCheckedLoadFunc->uses()) {
115  auto CI = cast<CallInst>(U.getUser());
116  ExternalizeTypeId(CI, 2);
117  }
118  }
119 
120  for (GlobalObject &GO : M.global_objects()) {
122  GO.getMetadata(LLVMContext::MD_type, MDs);
123 
124  GO.eraseMetadata(LLVMContext::MD_type);
125  for (auto MD : MDs) {
126  auto I = LocalToGlobal.find(MD->getOperand(1));
127  if (I == LocalToGlobal.end()) {
128  GO.addMetadata(LLVMContext::MD_type, *MD);
129  continue;
130  }
131  GO.addMetadata(
133  *MDNode::get(M.getContext(), {MD->getOperand(0), I->second}));
134  }
135  }
136 }
137 
138 // Drop unused globals, and drop type information from function declarations.
139 // FIXME: If we made functions typeless then there would be no need to do this.
140 void simplifyExternals(Module &M) {
141  FunctionType *EmptyFT =
143 
144  for (auto I = M.begin(), E = M.end(); I != E;) {
145  Function &F = *I++;
146  if (F.isDeclaration() && F.use_empty()) {
147  F.eraseFromParent();
148  continue;
149  }
150 
151  if (!F.isDeclaration() || F.getFunctionType() == EmptyFT ||
152  // Changing the type of an intrinsic may invalidate the IR.
153  F.getName().startswith("llvm."))
154  continue;
155 
156  Function *NewF =
158  NewF->setVisibility(F.getVisibility());
159  NewF->takeName(&F);
161  F.eraseFromParent();
162  }
163 
164  for (auto I = M.global_begin(), E = M.global_end(); I != E;) {
165  GlobalVariable &GV = *I++;
166  if (GV.isDeclaration() && GV.use_empty()) {
167  GV.eraseFromParent();
168  continue;
169  }
170  }
171 }
172 
173 static void
174 filterModule(Module *M,
175  function_ref<bool(const GlobalValue *)> ShouldKeepDefinition) {
176  std::vector<GlobalValue *> V;
177  for (GlobalValue &GV : M->global_values())
178  if (!ShouldKeepDefinition(&GV))
179  V.push_back(&GV);
180 
181  for (GlobalValue *GV : V)
182  if (!convertToDeclaration(*GV))
183  GV->eraseFromParent();
184 }
185 
186 void forEachVirtualFunction(Constant *C, function_ref<void(Function *)> Fn) {
187  if (auto *F = dyn_cast<Function>(C))
188  return Fn(F);
189  if (isa<GlobalValue>(C))
190  return;
191  for (Value *Op : C->operands())
192  forEachVirtualFunction(cast<Constant>(Op), Fn);
193 }
194 
195 // If it's possible to split M into regular and thin LTO parts, do so and write
196 // a multi-module bitcode file with the two parts to OS. Otherwise, write only a
197 // regular LTO bitcode file to OS.
198 void splitAndWriteThinLTOBitcode(
199  raw_ostream &OS, raw_ostream *ThinLinkOS,
200  function_ref<AAResults &(Function &)> AARGetter, Module &M) {
201  std::string ModuleId = getUniqueModuleId(&M);
202  if (ModuleId.empty()) {
203  // We couldn't generate a module ID for this module, write it out as a
204  // regular LTO module with an index for summary-based dead stripping.
205  ProfileSummaryInfo PSI(M);
206  M.addModuleFlag(Module::Error, "ThinLTO", uint32_t(0));
208  WriteBitcodeToFile(M, OS, /*ShouldPreserveUseListOrder=*/false, &Index);
209 
210  if (ThinLinkOS)
211  // We don't have a ThinLTO part, but still write the module to the
212  // ThinLinkOS if requested so that the expected output file is produced.
213  WriteBitcodeToFile(M, *ThinLinkOS, /*ShouldPreserveUseListOrder=*/false,
214  &Index);
215 
216  return;
217  }
218 
219  promoteTypeIds(M, ModuleId);
220 
221  // Returns whether a global has attached type metadata. Such globals may
222  // participate in CFI or whole-program devirtualization, so they need to
223  // appear in the merged module instead of the thin LTO module.
224  auto HasTypeMetadata = [](const GlobalObject *GO) {
225  return GO->hasMetadata(LLVMContext::MD_type);
226  };
227 
228  // Collect the set of virtual functions that are eligible for virtual constant
229  // propagation. Each eligible function must not access memory, must return
230  // an integer of width <=64 bits, must take at least one argument, must not
231  // use its first argument (assumed to be "this") and all arguments other than
232  // the first one must be of <=64 bit integer type.
233  //
234  // Note that we test whether this copy of the function is readnone, rather
235  // than testing function attributes, which must hold for any copy of the
236  // function, even a less optimized version substituted at link time. This is
237  // sound because the virtual constant propagation optimizations effectively
238  // inline all implementations of the virtual function into each call site,
239  // rather than using function attributes to perform local optimization.
240  DenseSet<const Function *> EligibleVirtualFns;
241  // If any member of a comdat lives in MergedM, put all members of that
242  // comdat in MergedM to keep the comdat together.
243  DenseSet<const Comdat *> MergedMComdats;
244  for (GlobalVariable &GV : M.globals())
245  if (HasTypeMetadata(&GV)) {
246  if (const auto *C = GV.getComdat())
247  MergedMComdats.insert(C);
248  forEachVirtualFunction(GV.getInitializer(), [&](Function *F) {
249  auto *RT = dyn_cast<IntegerType>(F->getReturnType());
250  if (!RT || RT->getBitWidth() > 64 || F->arg_empty() ||
251  !F->arg_begin()->use_empty())
252  return;
253  for (auto &Arg : make_range(std::next(F->arg_begin()), F->arg_end())) {
254  auto *ArgT = dyn_cast<IntegerType>(Arg.getType());
255  if (!ArgT || ArgT->getBitWidth() > 64)
256  return;
257  }
258  if (!F->isDeclaration() &&
259  computeFunctionBodyMemoryAccess(*F, AARGetter(*F)) == MAK_ReadNone)
260  EligibleVirtualFns.insert(F);
261  });
262  }
263 
264  ValueToValueMapTy VMap;
265  std::unique_ptr<Module> MergedM(
266  CloneModule(M, VMap, [&](const GlobalValue *GV) -> bool {
267  if (const auto *C = GV->getComdat())
268  if (MergedMComdats.count(C))
269  return true;
270  if (auto *F = dyn_cast<Function>(GV))
271  return EligibleVirtualFns.count(F);
272  if (auto *GVar = dyn_cast_or_null<GlobalVariable>(GV->getBaseObject()))
273  return HasTypeMetadata(GVar);
274  return false;
275  }));
276  StripDebugInfo(*MergedM);
277  MergedM->setModuleInlineAsm("");
278 
279  for (Function &F : *MergedM)
280  if (!F.isDeclaration()) {
281  // Reset the linkage of all functions eligible for virtual constant
282  // propagation. The canonical definitions live in the thin LTO module so
283  // that they can be imported.
285  F.setComdat(nullptr);
286  }
287 
288  SetVector<GlobalValue *> CfiFunctions;
289  for (auto &F : M)
290  if ((!F.hasLocalLinkage() || F.hasAddressTaken()) && HasTypeMetadata(&F))
291  CfiFunctions.insert(&F);
292 
293  // Remove all globals with type metadata, globals with comdats that live in
294  // MergedM, and aliases pointing to such globals from the thin LTO module.
295  filterModule(&M, [&](const GlobalValue *GV) {
296  if (auto *GVar = dyn_cast_or_null<GlobalVariable>(GV->getBaseObject()))
297  if (HasTypeMetadata(GVar))
298  return false;
299  if (const auto *C = GV->getComdat())
300  if (MergedMComdats.count(C))
301  return false;
302  return true;
303  });
304 
305  promoteInternals(*MergedM, M, ModuleId, CfiFunctions);
306  promoteInternals(M, *MergedM, ModuleId, CfiFunctions);
307 
308  auto &Ctx = MergedM->getContext();
309  SmallVector<MDNode *, 8> CfiFunctionMDs;
310  for (auto V : CfiFunctions) {
311  Function &F = *cast<Function>(V);
314 
316  Elts.push_back(MDString::get(Ctx, F.getName()));
317  CfiFunctionLinkage Linkage;
318  if (!F.isDeclarationForLinker())
319  Linkage = CFL_Definition;
320  else if (F.isWeakForLinker())
321  Linkage = CFL_WeakDeclaration;
322  else
323  Linkage = CFL_Declaration;
325  llvm::ConstantInt::get(Type::getInt8Ty(Ctx), Linkage)));
326  for (auto Type : Types)
327  Elts.push_back(Type);
328  CfiFunctionMDs.push_back(MDTuple::get(Ctx, Elts));
329  }
330 
331  if(!CfiFunctionMDs.empty()) {
332  NamedMDNode *NMD = MergedM->getOrInsertNamedMetadata("cfi.functions");
333  for (auto MD : CfiFunctionMDs)
334  NMD->addOperand(MD);
335  }
336 
337  SmallVector<MDNode *, 8> FunctionAliases;
338  for (auto &A : M.aliases()) {
339  if (!isa<Function>(A.getAliasee()))
340  continue;
341 
342  auto *F = cast<Function>(A.getAliasee());
343 
344  Metadata *Elts[] = {
345  MDString::get(Ctx, A.getName()),
346  MDString::get(Ctx, F->getName()),
348  ConstantInt::get(Type::getInt8Ty(Ctx), A.getVisibility())),
350  ConstantInt::get(Type::getInt8Ty(Ctx), A.isWeakForLinker())),
351  };
352 
353  FunctionAliases.push_back(MDTuple::get(Ctx, Elts));
354  }
355 
356  if (!FunctionAliases.empty()) {
357  NamedMDNode *NMD = MergedM->getOrInsertNamedMetadata("aliases");
358  for (auto MD : FunctionAliases)
359  NMD->addOperand(MD);
360  }
361 
362  SmallVector<MDNode *, 8> Symvers;
364  Function *F = M.getFunction(Name);
365  if (!F || F->use_empty())
366  return;
367 
368  Symvers.push_back(MDTuple::get(
369  Ctx, {MDString::get(Ctx, Name), MDString::get(Ctx, Alias)}));
370  });
371 
372  if (!Symvers.empty()) {
373  NamedMDNode *NMD = MergedM->getOrInsertNamedMetadata("symvers");
374  for (auto MD : Symvers)
375  NMD->addOperand(MD);
376  }
377 
378  simplifyExternals(*MergedM);
379 
380  // FIXME: Try to re-use BSI and PFI from the original module here.
381  ProfileSummaryInfo PSI(M);
382  ModuleSummaryIndex Index = buildModuleSummaryIndex(M, nullptr, &PSI);
383 
384  // Mark the merged module as requiring full LTO. We still want an index for
385  // it though, so that it can participate in summary-based dead stripping.
386  MergedM->addModuleFlag(Module::Error, "ThinLTO", uint32_t(0));
387  ModuleSummaryIndex MergedMIndex =
388  buildModuleSummaryIndex(*MergedM, nullptr, &PSI);
389 
390  SmallVector<char, 0> Buffer;
391 
392  BitcodeWriter W(Buffer);
393  // Save the module hash produced for the full bitcode, which will
394  // be used in the backends, and use that in the minimized bitcode
395  // produced for the full link.
396  ModuleHash ModHash = {{0}};
397  W.writeModule(M, /*ShouldPreserveUseListOrder=*/false, &Index,
398  /*GenerateHash=*/true, &ModHash);
399  W.writeModule(*MergedM, /*ShouldPreserveUseListOrder=*/false, &MergedMIndex);
400  W.writeSymtab();
401  W.writeStrtab();
402  OS << Buffer;
403 
404  // If a minimized bitcode module was requested for the thin link, only
405  // the information that is needed by thin link will be written in the
406  // given OS (the merged module will be written as usual).
407  if (ThinLinkOS) {
408  Buffer.clear();
409  BitcodeWriter W2(Buffer);
410  StripDebugInfo(M);
411  W2.writeThinLinkBitcode(M, Index, ModHash);
412  W2.writeModule(*MergedM, /*ShouldPreserveUseListOrder=*/false,
413  &MergedMIndex);
414  W2.writeSymtab();
415  W2.writeStrtab();
416  *ThinLinkOS << Buffer;
417  }
418 }
419 
420 // Returns whether this module needs to be split because it uses type metadata.
421 bool requiresSplit(Module &M) {
422  for (auto &GO : M.global_objects()) {
423  if (GO.hasMetadata(LLVMContext::MD_type))
424  return true;
425  }
426 
427  return false;
428 }
429 
430 void writeThinLTOBitcode(raw_ostream &OS, raw_ostream *ThinLinkOS,
431  function_ref<AAResults &(Function &)> AARGetter,
432  Module &M, const ModuleSummaryIndex *Index) {
433  // See if this module has any type metadata. If so, we need to split it.
434  if (requiresSplit(M))
435  return splitAndWriteThinLTOBitcode(OS, ThinLinkOS, AARGetter, M);
436 
437  // Otherwise we can just write it out as a regular module.
438 
439  // Save the module hash produced for the full bitcode, which will
440  // be used in the backends, and use that in the minimized bitcode
441  // produced for the full link.
442  ModuleHash ModHash = {{0}};
443  WriteBitcodeToFile(M, OS, /*ShouldPreserveUseListOrder=*/false, Index,
444  /*GenerateHash=*/true, &ModHash);
445  // If a minimized bitcode module was requested for the thin link, only
446  // the information that is needed by thin link will be written in the
447  // given OS.
448  if (ThinLinkOS && Index)
449  WriteThinLinkBitcodeToFile(M, *ThinLinkOS, *Index, ModHash);
450 }
451 
452 class WriteThinLTOBitcode : public ModulePass {
453  raw_ostream &OS; // raw_ostream to print on
454  // The output stream on which to emit a minimized module for use
455  // just in the thin link, if requested.
456  raw_ostream *ThinLinkOS;
457 
458 public:
459  static char ID; // Pass identification, replacement for typeid
460  WriteThinLTOBitcode() : ModulePass(ID), OS(dbgs()), ThinLinkOS(nullptr) {
462  }
463 
464  explicit WriteThinLTOBitcode(raw_ostream &o, raw_ostream *ThinLinkOS)
465  : ModulePass(ID), OS(o), ThinLinkOS(ThinLinkOS) {
467  }
468 
469  StringRef getPassName() const override { return "ThinLTO Bitcode Writer"; }
470 
471  bool runOnModule(Module &M) override {
472  const ModuleSummaryIndex *Index =
473  &(getAnalysis<ModuleSummaryIndexWrapperPass>().getIndex());
474  writeThinLTOBitcode(OS, ThinLinkOS, LegacyAARGetter(*this), M, Index);
475  return true;
476  }
477  void getAnalysisUsage(AnalysisUsage &AU) const override {
478  AU.setPreservesAll();
482  }
483 };
484 } // anonymous namespace
485 
486 char WriteThinLTOBitcode::ID = 0;
487 INITIALIZE_PASS_BEGIN(WriteThinLTOBitcode, "write-thinlto-bitcode",
488  "Write ThinLTO Bitcode", false, true)
492 INITIALIZE_PASS_END(WriteThinLTOBitcode, "write-thinlto-bitcode",
493  "Write ThinLTO Bitcode", false, true)
494 
496  raw_ostream *ThinLinkOS) {
497  return new WriteThinLTOBitcode(Str, ThinLinkOS);
498 }
499 
503  AM.getResult<FunctionAnalysisManagerModuleProxy>(M).getManager();
504  writeThinLTOBitcode(OS, ThinLinkOS,
505  [&FAM](Function &F) -> AAResults & {
506  return FAM.getResult<AAManager>(F);
507  },
509  return PreservedAnalyses::all();
510 }
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:239
const Function & getFunction() const
Definition: Function.h:134
bool isDeclarationForLinker() const
Definition: GlobalValue.h:524
uint64_t CallInst * C
ModulePass * createWriteThinLTOBitcodePass(raw_ostream &Str, raw_ostream *ThinLinkOS=nullptr)
Write ThinLTO-ready bitcode to Str.
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1133
iterator_range< use_iterator > uses()
Definition: Value.h:355
bool hasLocalLinkage() const
Definition: GlobalValue.h:436
static PassRegistry * getPassRegistry()
getPassRegistry - Access the global registry object, which is automatically initialized at applicatio...
PassT::Result & getResult(IRUnitT &IR, ExtraArgTs... ExtraArgs)
Get the result of an analysis pass for a given IR unit.
Definition: PassManager.h:770
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
Compute iterated dominance frontiers using a linear time algorithm.
Definition: AllocatorList.h:24
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:64
static MDString * get(LLVMContext &Context, StringRef Str)
Definition: Metadata.cpp:454
This is the interface to build a ModuleSummaryIndex for a module.
Implements a dense probed hash-table based set.
Definition: DenseSet.h:250
Available for inspection, not emission.
Definition: GlobalValue.h:50
Analysis providing profile information.
void addOperand(MDNode *M)
Definition: Metadata.cpp:1087
This class represents a function call, abstracting a target machine&#39;s calling convention.
write thinlto bitcode
An immutable pass that tracks lazily created AssumptionCache objects.
bool convertToDeclaration(GlobalValue &GV)
Converts value GV to declaration, or replaces with a declaration if it is an alias.
An efficient, type-erasing, non-owning reference to a callable.
Definition: STLExtras.h:107
CfiFunctionLinkage
The type of CFI jumptable needed for a function.
Externally visible function.
Definition: GlobalValue.h:49
arg_iterator arg_end()
Definition: Function.h:680
F(f)
block Block Frequency true
MemoryAccessKind computeFunctionBodyMemoryAccess(Function &F, AAResults &AAR)
Returns the memory access properties of this copy of the function.
Analysis pass to provide the ModuleSummaryIndex object.
ModuleSummaryIndex buildModuleSummaryIndex(const Module &M, std::function< BlockFrequencyInfo *(const Function &F)> GetBFICallback, ProfileSummaryInfo *PSI)
Direct function to compute a ModuleSummaryIndex from a given module.
iterator_range< global_object_iterator > global_objects()
Definition: Module.h:649
AnalysisUsage & addRequired()
#define INITIALIZE_PASS_DEPENDENCY(depName)
Definition: PassSupport.h:51
A tuple of MDNodes.
Definition: Metadata.h:1326
amdgpu Simplify well known AMD library false Value Value const Twine & Name
StringRef getName(ID id)
Return the LLVM name for an intrinsic, such as "llvm.ppc.altivec.lvx".
Definition: Function.cpp:627
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:243
A Use represents the edge between a Value definition and its users.
Definition: Use.h:56
This class is a functor to be used in legacy module or SCC passes for computing AA results for a func...
MDNode * getMetadata(unsigned KindID) const
Get the current metadata attachments for the given kind, if any.
Definition: Metadata.cpp:1444
std::array< uint32_t, 5 > ModuleHash
160 bits SHA1
void setName(const Twine &Name)
Change the name of the value.
Definition: Value.cpp:295
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...
global_iterator global_begin()
Definition: Module.h:568
LLVM_NODISCARD LLVM_ATTRIBUTE_ALWAYS_INLINE bool startswith(StringRef Prefix) const
Check if this string starts with the given Prefix.
Definition: StringRef.h:267
Class to represent function types.
Definition: DerivedTypes.h:103
Type * getType() const
All values are typed, get the type of this value.
Definition: Value.h:245
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:142
bool arg_empty() const
Definition: Function.h:699
void setComdat(Comdat *C)
Definition: GlobalObject.h:103
bool StripDebugInfo(Module &M)
Strip debug info in the module if it exists.
Definition: DebugInfo.cpp:351
GlobalValue * getNamedValue(StringRef Name) const
Return the global value in the module with the specified name, of arbitrary type. ...
Definition: Module.cpp:113
void replaceAllUsesWith(Value *V)
Change all uses of this to point to a new Value.
Definition: Value.cpp:439
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:301
Class to hold module path string table and global value map, and encapsulate methods for operating on...
static ConstantAsMetadata * get(Constant *C)
Definition: Metadata.h:410
size_type count(const key_type &key) const
Count the number of elements of a given key in the SetVector.
Definition: SetVector.h:211
void removeDeadConstantUsers() const
If there are any dead constant users dangling off of this constant, remove them.
Definition: Constants.cpp:536
static bool isWeakForLinker(LinkageTypes Linkage)
Whether the definition of this global may be replaced at link time.
Definition: GlobalValue.h:370
static MetadataAsValue * get(LLVMContext &Context, Metadata *MD)
Definition: Metadata.cpp:106
static Constant * getBitCast(Constant *C, Type *Ty, bool OnlyIfReduced=false)
Definition: Constants.cpp:1750
std::unique_ptr< Module > CloneModule(const Module &M)
Return an exact copy of the specified module.
Definition: CloneModule.cpp:35
static MDTuple * get(LLVMContext &Context, ArrayRef< Metadata *> MDs)
Definition: Metadata.h:1166
Type * getReturnType() const
Returns the type of the ret val.
Definition: Function.h:169
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:136
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...
Emits an error if two values disagree, otherwise the resulting value is that of the operands...
Definition: Module.h:115
A set of analyses that are preserved following a run of a transformation pass.
Definition: PassManager.h:154
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:233
write thinlto Write ThinLTO Bitcode
The instances of the Type class are immutable: once they are created, they are never changed...
Definition: Type.h:46
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
This is an important base class in LLVM.
Definition: Constant.h:42
This file contains the declarations for the subclasses of Constant, which represent the different fla...
A manager for alias analyses.
PreservedAnalyses run(Module &M, ModuleAnalysisManager &AM)
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.
void eraseFromParent()
eraseFromParent - This method unlinks &#39;this&#39; from the containing module and deletes it...
Definition: Globals.cpp:359
Represent the analysis usage information of a pass.
static Type * getVoidTy(LLVMContext &C)
Definition: Type.cpp:161
void addModuleFlag(ModFlagBehavior Behavior, StringRef Key, Metadata *Val)
Add a module-level flag to the module-level flags metadata.
Definition: Module.cpp:332
static FunctionType * get(Type *Result, ArrayRef< Type *> Params, bool isVarArg)
This static method is the primary way of constructing a FunctionType.
Definition: Type.cpp:297
void setArgOperand(unsigned i, Value *v)
op_range operands()
Definition: User.h:238
arg_iterator arg_begin()
Definition: Function.h:671
Class to represent integer types.
Definition: DerivedTypes.h:40
std::string getUniqueModuleId(Module *M)
Produce a unique identifier for this module by taking the MD5 sum of the names of the module&#39;s strong...
static void write(bool isBE, void *P, T V)
Comdat * getOrInsertComdat(StringRef Name)
Return the Comdat in the module with the specified name.
Definition: Module.cpp:477
static PreservedAnalyses all()
Construct a special preserved set that preserves all passes.
Definition: PassManager.h:160
INITIALIZE_PASS_END(RegBankSelect, DEBUG_TYPE, "Assign register bank of generic virtual registers", false, false) RegBankSelect
global_iterator global_end()
Definition: Module.h:570
iterator_range< T > make_range(T x, T y)
Convenience function for iterating over sub-ranges.
void initializeWriteThinLTOBitcodePass(PassRegistry &)
This is a &#39;vector&#39; (really, a variable-sized array), optimized for the case when the array is small...
Definition: SmallVector.h:847
Module.h This file contains the declarations for the Module class.
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:621
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:445
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:133
Function * getFunction(StringRef Name) const
Look up the specified function in the module symbol table.
Definition: Module.cpp:175
FunctionType * getFunctionType() const
Returns the FunctionType for me.
Definition: Function.h:164
const Comdat * getComdat() const
Definition: Globals.cpp:171
void setPreservesAll()
Set by analyses that do not transform their input at all.
amdgpu Simplify well known AMD library false Value Value * Arg
const Comdat * getComdat() const
Definition: GlobalObject.h:101
void eraseFromParent()
This method unlinks &#39;this&#39; from the containing module and deletes it.
Definition: Globals.cpp:85
iterator end()
Definition: Module.h:587
LLVM_NODISCARD bool empty() const
Definition: SmallVector.h:56
StringRef getName() const
Return a constant reference to the value&#39;s name.
Definition: Value.cpp:224
#define I(x, y, z)
Definition: MD5.cpp:58
ModulePass class - This class is used to implement unstructured interprocedural optimizations and ana...
Definition: Pass.h:225
iterator begin()
Definition: Module.h:585
LLVM_NODISCARD std::enable_if<!is_simple_type< Y >::value, typename cast_retty< X, const Y >::ret_type >::type dyn_cast(const Y &Val)
Definition: Casting.h:323
void eraseFromParent()
eraseFromParent - This method unlinks &#39;this&#39; from the containing module and deletes it...
Definition: Function.cpp:215
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:92
Provides passes for computing function attributes based on interprocedural analyses.
const GlobalObject * getBaseObject() const
Definition: Globals.cpp:261
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:206
bool hasAddressTaken(const User **=nullptr) const
hasAddressTaken - returns true if there are any uses of this function other than direct calls or invo...
Definition: Function.cpp:1255
Value * getArgOperand(unsigned i) const
getArgOperand/setArgOperand - Return/set the i-th call argument.
LLVM Value Representation.
Definition: Value.h:73
A vector that has set insertion semantics.
Definition: SetVector.h:41
This class implements an extremely fast bulk output stream that can only output to a stream...
Definition: raw_ostream.h:46
iterator_range< global_iterator > globals()
Definition: Module.h:574
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:49
This is the interface for LLVM&#39;s primary stateless and local alias analysis.
A container for analyses that lazily runs them and caches their results.
This header defines various interfaces for pass management in LLVM.
INITIALIZE_PASS_BEGIN(WriteThinLTOBitcode, "write-thinlto-bitcode", "Write ThinLTO Bitcode", false, true) INITIALIZE_PASS_END(WriteThinLTOBitcode
iterator_range< global_value_iterator > global_values()
Definition: Module.h:675
Root of the metadata hierarchy.
Definition: Metadata.h:58
static IntegerType * getInt8Ty(LLVMContext &C)
Definition: Type.cpp:174
bool use_empty() const
Definition: Value.h:323
PointerType * getType() const
Global values are always pointers.
Definition: GlobalValue.h:274
Legacy wrapper pass to provide the ModuleSummaryIndex object.
An analysis over an "outer" IR unit that provides access to an analysis manager over an "inner" IR un...
Definition: PassManager.h:1038