LLVM  17.0.0git
LinkModules.cpp
Go to the documentation of this file.
1 //===- lib/Linker/LinkModules.cpp - Module Linker Implementation ----------===//
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 file implements the LLVM module linker.
10 //
11 //===----------------------------------------------------------------------===//
12 
13 #include "LinkDiagnosticInfo.h"
14 #include "llvm-c/Linker.h"
15 #include "llvm/ADT/SetVector.h"
16 #include "llvm/IR/Comdat.h"
17 #include "llvm/IR/GlobalValue.h"
18 #include "llvm/IR/LLVMContext.h"
19 #include "llvm/IR/Module.h"
20 #include "llvm/Linker/Linker.h"
21 #include "llvm/Support/Error.h"
22 using namespace llvm;
23 
24 namespace {
25 
26 enum class LinkFrom { Dst, Src, Both };
27 
28 /// This is an implementation class for the LinkModules function, which is the
29 /// entrypoint for this file.
30 class ModuleLinker {
31  IRMover &Mover;
32  std::unique_ptr<Module> SrcM;
33 
34  SetVector<GlobalValue *> ValuesToLink;
35 
36  /// For symbol clashes, prefer those from Src.
37  unsigned Flags;
38 
39  /// List of global value names that should be internalized.
40  StringSet<> Internalize;
41 
42  /// Function that will perform the actual internalization. The reason for a
43  /// callback is that the linker cannot call internalizeModule without
44  /// creating a circular dependency between IPO and the linker.
45  std::function<void(Module &, const StringSet<> &)> InternalizeCallback;
46 
47  /// Used as the callback for lazy linking.
48  /// The mover has just hit GV and we have to decide if it, and other members
49  /// of the same comdat, should be linked. Every member to be linked is passed
50  /// to Add.
51  void addLazyFor(GlobalValue &GV, const IRMover::ValueAdder &Add);
52 
53  bool shouldOverrideFromSrc() { return Flags & Linker::OverrideFromSrc; }
54  bool shouldLinkOnlyNeeded() { return Flags & Linker::LinkOnlyNeeded; }
55 
56  bool shouldLinkFromSource(bool &LinkFromSrc, const GlobalValue &Dest,
57  const GlobalValue &Src);
58 
59  /// Should we have mover and linker error diag info?
60  bool emitError(const Twine &Message) {
61  SrcM->getContext().diagnose(LinkDiagnosticInfo(DS_Error, Message));
62  return true;
63  }
64 
65  bool getComdatLeader(Module &M, StringRef ComdatName,
66  const GlobalVariable *&GVar);
67  bool computeResultingSelectionKind(StringRef ComdatName,
70  Comdat::SelectionKind &Result,
71  LinkFrom &From);
73  ComdatsChosen;
74  bool getComdatResult(const Comdat *SrcC, Comdat::SelectionKind &SK,
75  LinkFrom &From);
76  // Keep track of the lazy linked global members of each comdat in source.
78 
79  /// Given a global in the source module, return the global in the
80  /// destination module that is being linked to, if any.
81  GlobalValue *getLinkedToGlobal(const GlobalValue *SrcGV) {
82  Module &DstM = Mover.getModule();
83  // If the source has no name it can't link. If it has local linkage,
84  // there is no name match-up going on.
85  if (!SrcGV->hasName() || GlobalValue::isLocalLinkage(SrcGV->getLinkage()))
86  return nullptr;
87 
88  // Otherwise see if we have a match in the destination module's symtab.
89  GlobalValue *DGV = DstM.getNamedValue(SrcGV->getName());
90  if (!DGV)
91  return nullptr;
92 
93  // If we found a global with the same name in the dest module, but it has
94  // internal linkage, we are really not doing any linkage here.
95  if (DGV->hasLocalLinkage())
96  return nullptr;
97 
98  // Otherwise, we do in fact link to the destination global.
99  return DGV;
100  }
101 
102  /// Drop GV if it is a member of a comdat that we are dropping.
103  /// This can happen with COFF's largest selection kind.
104  void dropReplacedComdat(GlobalValue &GV,
105  const DenseSet<const Comdat *> &ReplacedDstComdats);
106 
107  bool linkIfNeeded(GlobalValue &GV, SmallVectorImpl<GlobalValue *> &GVToClone);
108 
109 public:
110  ModuleLinker(IRMover &Mover, std::unique_ptr<Module> SrcM, unsigned Flags,
111  std::function<void(Module &, const StringSet<> &)>
112  InternalizeCallback = {})
113  : Mover(Mover), SrcM(std::move(SrcM)), Flags(Flags),
114  InternalizeCallback(std::move(InternalizeCallback)) {}
115 
116  bool run();
117 };
118 } // namespace
119 
129 }
130 
131 bool ModuleLinker::getComdatLeader(Module &M, StringRef ComdatName,
132  const GlobalVariable *&GVar) {
133  const GlobalValue *GVal = M.getNamedValue(ComdatName);
134  if (const auto *GA = dyn_cast_or_null<GlobalAlias>(GVal)) {
135  GVal = GA->getAliaseeObject();
136  if (!GVal)
137  // We cannot resolve the size of the aliasee yet.
138  return emitError("Linking COMDATs named '" + ComdatName +
139  "': COMDAT key involves incomputable alias size.");
140  }
141 
142  GVar = dyn_cast_or_null<GlobalVariable>(GVal);
143  if (!GVar)
144  return emitError(
145  "Linking COMDATs named '" + ComdatName +
146  "': GlobalVariable required for data dependent selection!");
147 
148  return false;
149 }
150 
151 bool ModuleLinker::computeResultingSelectionKind(StringRef ComdatName,
154  Comdat::SelectionKind &Result,
155  LinkFrom &From) {
156  Module &DstM = Mover.getModule();
157  // The ability to mix Comdat::SelectionKind::Any with
158  // Comdat::SelectionKind::Largest is a behavior that comes from COFF.
159  bool DstAnyOrLargest = Dst == Comdat::SelectionKind::Any ||
160  Dst == Comdat::SelectionKind::Largest;
161  bool SrcAnyOrLargest = Src == Comdat::SelectionKind::Any ||
162  Src == Comdat::SelectionKind::Largest;
163  if (DstAnyOrLargest && SrcAnyOrLargest) {
164  if (Dst == Comdat::SelectionKind::Largest ||
165  Src == Comdat::SelectionKind::Largest)
166  Result = Comdat::SelectionKind::Largest;
167  else
169  } else if (Src == Dst) {
170  Result = Dst;
171  } else {
172  return emitError("Linking COMDATs named '" + ComdatName +
173  "': invalid selection kinds!");
174  }
175 
176  switch (Result) {
178  // Go with Dst.
179  From = LinkFrom::Dst;
180  break;
181  case Comdat::SelectionKind::NoDeduplicate:
182  From = LinkFrom::Both;
183  break;
184  case Comdat::SelectionKind::ExactMatch:
185  case Comdat::SelectionKind::Largest:
186  case Comdat::SelectionKind::SameSize: {
187  const GlobalVariable *DstGV;
188  const GlobalVariable *SrcGV;
189  if (getComdatLeader(DstM, ComdatName, DstGV) ||
190  getComdatLeader(*SrcM, ComdatName, SrcGV))
191  return true;
192 
193  const DataLayout &DstDL = DstM.getDataLayout();
194  const DataLayout &SrcDL = SrcM->getDataLayout();
195  uint64_t DstSize = DstDL.getTypeAllocSize(DstGV->getValueType());
196  uint64_t SrcSize = SrcDL.getTypeAllocSize(SrcGV->getValueType());
197  if (Result == Comdat::SelectionKind::ExactMatch) {
198  if (SrcGV->getInitializer() != DstGV->getInitializer())
199  return emitError("Linking COMDATs named '" + ComdatName +
200  "': ExactMatch violated!");
201  From = LinkFrom::Dst;
202  } else if (Result == Comdat::SelectionKind::Largest) {
203  From = SrcSize > DstSize ? LinkFrom::Src : LinkFrom::Dst;
204  } else if (Result == Comdat::SelectionKind::SameSize) {
205  if (SrcSize != DstSize)
206  return emitError("Linking COMDATs named '" + ComdatName +
207  "': SameSize violated!");
208  From = LinkFrom::Dst;
209  } else {
210  llvm_unreachable("unknown selection kind");
211  }
212  break;
213  }
214  }
215 
216  return false;
217 }
218 
219 bool ModuleLinker::getComdatResult(const Comdat *SrcC,
220  Comdat::SelectionKind &Result,
221  LinkFrom &From) {
222  Module &DstM = Mover.getModule();
224  StringRef ComdatName = SrcC->getName();
225  Module::ComdatSymTabType &ComdatSymTab = DstM.getComdatSymbolTable();
226  Module::ComdatSymTabType::iterator DstCI = ComdatSymTab.find(ComdatName);
227 
228  if (DstCI == ComdatSymTab.end()) {
229  // Use the comdat if it is only available in one of the modules.
230  From = LinkFrom::Src;
231  Result = SSK;
232  return false;
233  }
234 
235  const Comdat *DstC = &DstCI->second;
237  return computeResultingSelectionKind(ComdatName, SSK, DSK, Result, From);
238 }
239 
240 bool ModuleLinker::shouldLinkFromSource(bool &LinkFromSrc,
241  const GlobalValue &Dest,
242  const GlobalValue &Src) {
243 
244  // Should we unconditionally use the Src?
245  if (shouldOverrideFromSrc()) {
246  LinkFromSrc = true;
247  return false;
248  }
249 
250  // We always have to add Src if it has appending linkage.
251  if (Src.hasAppendingLinkage() || Dest.hasAppendingLinkage()) {
252  LinkFromSrc = true;
253  return false;
254  }
255 
256  bool SrcIsDeclaration = Src.isDeclarationForLinker();
257  bool DestIsDeclaration = Dest.isDeclarationForLinker();
258 
259  if (SrcIsDeclaration) {
260  // If Src is external or if both Src & Dest are external.. Just link the
261  // external globals, we aren't adding anything.
262  if (Src.hasDLLImportStorageClass()) {
263  // If one of GVs is marked as DLLImport, result should be dllimport'ed.
264  LinkFromSrc = DestIsDeclaration;
265  return false;
266  }
267  // If the Dest is weak, use the source linkage.
268  if (Dest.hasExternalWeakLinkage()) {
269  LinkFromSrc = true;
270  return false;
271  }
272  // Link an available_externally over a declaration.
273  LinkFromSrc = !Src.isDeclaration() && Dest.isDeclaration();
274  return false;
275  }
276 
277  if (DestIsDeclaration) {
278  // If Dest is external but Src is not:
279  LinkFromSrc = true;
280  return false;
281  }
282 
283  if (Src.hasCommonLinkage()) {
284  if (Dest.hasLinkOnceLinkage() || Dest.hasWeakLinkage()) {
285  LinkFromSrc = true;
286  return false;
287  }
288 
289  if (!Dest.hasCommonLinkage()) {
290  LinkFromSrc = false;
291  return false;
292  }
293 
294  const DataLayout &DL = Dest.getParent()->getDataLayout();
295  uint64_t DestSize = DL.getTypeAllocSize(Dest.getValueType());
296  uint64_t SrcSize = DL.getTypeAllocSize(Src.getValueType());
297  LinkFromSrc = SrcSize > DestSize;
298  return false;
299  }
300 
301  if (Src.isWeakForLinker()) {
304 
305  if (Dest.hasLinkOnceLinkage() && Src.hasWeakLinkage()) {
306  LinkFromSrc = true;
307  return false;
308  }
309 
310  LinkFromSrc = false;
311  return false;
312  }
313 
314  if (Dest.isWeakForLinker()) {
315  assert(Src.hasExternalLinkage());
316  LinkFromSrc = true;
317  return false;
318  }
319 
320  assert(!Src.hasExternalWeakLinkage());
322  assert(Dest.hasExternalLinkage() && Src.hasExternalLinkage() &&
323  "Unexpected linkage type!");
324  return emitError("Linking globals named '" + Src.getName() +
325  "': symbol multiply defined!");
326 }
327 
328 bool ModuleLinker::linkIfNeeded(GlobalValue &GV,
329  SmallVectorImpl<GlobalValue *> &GVToClone) {
330  GlobalValue *DGV = getLinkedToGlobal(&GV);
331 
332  if (shouldLinkOnlyNeeded()) {
333  // Always import variables with appending linkage.
334  if (!GV.hasAppendingLinkage()) {
335  // Don't import globals unless they are referenced by the destination
336  // module.
337  if (!DGV)
338  return false;
339  // Don't import globals that are already defined in the destination module
340  if (!DGV->isDeclaration())
341  return false;
342  }
343  }
344 
345  if (DGV && !GV.hasLocalLinkage() && !GV.hasAppendingLinkage()) {
346  auto *DGVar = dyn_cast<GlobalVariable>(DGV);
347  auto *SGVar = dyn_cast<GlobalVariable>(&GV);
348  if (DGVar && SGVar) {
349  if (DGVar->isDeclaration() && SGVar->isDeclaration() &&
350  (!DGVar->isConstant() || !SGVar->isConstant())) {
351  DGVar->setConstant(false);
352  SGVar->setConstant(false);
353  }
354  if (DGVar->hasCommonLinkage() && SGVar->hasCommonLinkage()) {
355  MaybeAlign DAlign = DGVar->getAlign();
356  MaybeAlign SAlign = SGVar->getAlign();
357  MaybeAlign Align = std::nullopt;
358  if (DAlign || SAlign)
359  Align = std::max(DAlign.valueOrOne(), SAlign.valueOrOne());
360 
361  SGVar->setAlignment(Align);
362  DGVar->setAlignment(Align);
363  }
364  }
365 
366  GlobalValue::VisibilityTypes Visibility =
368  DGV->setVisibility(Visibility);
369  GV.setVisibility(Visibility);
370 
372  DGV->getUnnamedAddr(), GV.getUnnamedAddr());
373  DGV->setUnnamedAddr(UnnamedAddr);
374  GV.setUnnamedAddr(UnnamedAddr);
375  }
376 
377  if (!DGV && !shouldOverrideFromSrc() &&
378  (GV.hasLocalLinkage() || GV.hasLinkOnceLinkage() ||
380  return false;
381 
382  if (GV.isDeclaration())
383  return false;
384 
385  LinkFrom ComdatFrom = LinkFrom::Dst;
386  if (const Comdat *SC = GV.getComdat()) {
387  std::tie(std::ignore, ComdatFrom) = ComdatsChosen[SC];
388  if (ComdatFrom == LinkFrom::Dst)
389  return false;
390  }
391 
392  bool LinkFromSrc = true;
393  if (DGV && shouldLinkFromSource(LinkFromSrc, *DGV, GV))
394  return true;
395  if (DGV && ComdatFrom == LinkFrom::Both)
396  GVToClone.push_back(LinkFromSrc ? DGV : &GV);
397  if (LinkFromSrc)
398  ValuesToLink.insert(&GV);
399  return false;
400 }
401 
402 void ModuleLinker::addLazyFor(GlobalValue &GV, const IRMover::ValueAdder &Add) {
403  // Add these to the internalize list
405  !shouldLinkOnlyNeeded())
406  return;
407 
408  if (InternalizeCallback)
409  Internalize.insert(GV.getName());
410  Add(GV);
411 
412  const Comdat *SC = GV.getComdat();
413  if (!SC)
414  return;
415  for (GlobalValue *GV2 : LazyComdatMembers[SC]) {
416  GlobalValue *DGV = getLinkedToGlobal(GV2);
417  bool LinkFromSrc = true;
418  if (DGV && shouldLinkFromSource(LinkFromSrc, *DGV, *GV2))
419  return;
420  if (!LinkFromSrc)
421  continue;
422  if (InternalizeCallback)
423  Internalize.insert(GV2->getName());
424  Add(*GV2);
425  }
426 }
427 
428 void ModuleLinker::dropReplacedComdat(
429  GlobalValue &GV, const DenseSet<const Comdat *> &ReplacedDstComdats) {
430  Comdat *C = GV.getComdat();
431  if (!C)
432  return;
433  if (!ReplacedDstComdats.count(C))
434  return;
435  if (GV.use_empty()) {
436  GV.eraseFromParent();
437  return;
438  }
439 
440  if (auto *F = dyn_cast<Function>(&GV)) {
441  F->deleteBody();
442  } else if (auto *Var = dyn_cast<GlobalVariable>(&GV)) {
443  Var->setInitializer(nullptr);
444  } else {
445  auto &Alias = cast<GlobalAlias>(GV);
446  Module &M = *Alias.getParent();
447  GlobalValue *Declaration;
448  if (auto *FTy = dyn_cast<FunctionType>(Alias.getValueType())) {
449  Declaration = Function::Create(FTy, GlobalValue::ExternalLinkage, "", &M);
450  } else {
451  Declaration =
452  new GlobalVariable(M, Alias.getValueType(), /*isConstant*/ false,
454  /*Initializer*/ nullptr);
455  }
456  Declaration->takeName(&Alias);
457  Alias.replaceAllUsesWith(Declaration);
458  Alias.eraseFromParent();
459  }
460 }
461 
462 bool ModuleLinker::run() {
463  Module &DstM = Mover.getModule();
464  DenseSet<const Comdat *> ReplacedDstComdats;
465 
466  for (const auto &SMEC : SrcM->getComdatSymbolTable()) {
467  const Comdat &C = SMEC.getValue();
468  if (ComdatsChosen.count(&C))
469  continue;
471  LinkFrom From;
472  if (getComdatResult(&C, SK, From))
473  return true;
474  ComdatsChosen[&C] = std::make_pair(SK, From);
475 
476  if (From != LinkFrom::Src)
477  continue;
478 
479  Module::ComdatSymTabType &ComdatSymTab = DstM.getComdatSymbolTable();
480  Module::ComdatSymTabType::iterator DstCI = ComdatSymTab.find(C.getName());
481  if (DstCI == ComdatSymTab.end())
482  continue;
483 
484  // The source comdat is replacing the dest one.
485  const Comdat *DstC = &DstCI->second;
486  ReplacedDstComdats.insert(DstC);
487  }
488 
489  // Alias have to go first, since we are not able to find their comdats
490  // otherwise.
492  dropReplacedComdat(GV, ReplacedDstComdats);
493 
495  dropReplacedComdat(GV, ReplacedDstComdats);
496 
497  for (Function &GV : llvm::make_early_inc_range(DstM))
498  dropReplacedComdat(GV, ReplacedDstComdats);
499 
500  for (GlobalVariable &GV : SrcM->globals())
501  if (GV.hasLinkOnceLinkage())
502  if (const Comdat *SC = GV.getComdat())
503  LazyComdatMembers[SC].push_back(&GV);
504 
505  for (Function &SF : *SrcM)
506  if (SF.hasLinkOnceLinkage())
507  if (const Comdat *SC = SF.getComdat())
508  LazyComdatMembers[SC].push_back(&SF);
509 
510  for (GlobalAlias &GA : SrcM->aliases())
511  if (GA.hasLinkOnceLinkage())
512  if (const Comdat *SC = GA.getComdat())
513  LazyComdatMembers[SC].push_back(&GA);
514 
515  // Insert all of the globals in src into the DstM module... without linking
516  // initializers (which could refer to functions not yet mapped over).
518  for (GlobalVariable &GV : SrcM->globals())
519  if (linkIfNeeded(GV, GVToClone))
520  return true;
521 
522  for (Function &SF : *SrcM)
523  if (linkIfNeeded(SF, GVToClone))
524  return true;
525 
526  for (GlobalAlias &GA : SrcM->aliases())
527  if (linkIfNeeded(GA, GVToClone))
528  return true;
529 
530  for (GlobalIFunc &GI : SrcM->ifuncs())
531  if (linkIfNeeded(GI, GVToClone))
532  return true;
533 
534  // For a variable in a comdat nodeduplicate, its initializer should be
535  // preserved (its content may be implicitly used by other members) even if
536  // symbol resolution does not pick it. Clone it into an unnamed private
537  // variable.
538  for (GlobalValue *GV : GVToClone) {
539  if (auto *Var = dyn_cast<GlobalVariable>(GV)) {
540  auto *NewVar = new GlobalVariable(*Var->getParent(), Var->getValueType(),
541  Var->isConstant(), Var->getLinkage(),
542  Var->getInitializer());
543  NewVar->copyAttributesFrom(Var);
544  NewVar->setVisibility(GlobalValue::DefaultVisibility);
545  NewVar->setLinkage(GlobalValue::PrivateLinkage);
546  NewVar->setDSOLocal(true);
547  NewVar->setComdat(Var->getComdat());
548  if (Var->getParent() != &Mover.getModule())
549  ValuesToLink.insert(NewVar);
550  } else {
551  emitError("linking '" + GV->getName() +
552  "': non-variables in comdat nodeduplicate are not handled");
553  }
554  }
555 
556  for (unsigned I = 0; I < ValuesToLink.size(); ++I) {
557  GlobalValue *GV = ValuesToLink[I];
558  const Comdat *SC = GV->getComdat();
559  if (!SC)
560  continue;
561  for (GlobalValue *GV2 : LazyComdatMembers[SC]) {
562  GlobalValue *DGV = getLinkedToGlobal(GV2);
563  bool LinkFromSrc = true;
564  if (DGV && shouldLinkFromSource(LinkFromSrc, *DGV, *GV2))
565  return true;
566  if (LinkFromSrc)
567  ValuesToLink.insert(GV2);
568  }
569  }
570 
571  if (InternalizeCallback) {
572  for (GlobalValue *GV : ValuesToLink)
573  Internalize.insert(GV->getName());
574  }
575 
576  // FIXME: Propagate Errors through to the caller instead of emitting
577  // diagnostics.
578  bool HasErrors = false;
579  if (Error E =
580  Mover.move(std::move(SrcM), ValuesToLink.getArrayRef(),
582  [this](GlobalValue &GV, IRMover::ValueAdder Add) {
583  addLazyFor(GV, Add);
584  }),
585  /* IsPerformingImport */ false)) {
587  DstM.getContext().diagnose(LinkDiagnosticInfo(DS_Error, EIB.message()));
588  HasErrors = true;
589  });
590  }
591  if (HasErrors)
592  return true;
593 
594  if (InternalizeCallback)
595  InternalizeCallback(DstM, Internalize);
596 
597  return false;
598 }
599 
600 Linker::Linker(Module &M) : Mover(M) {}
601 
603  std::unique_ptr<Module> Src, unsigned Flags,
604  std::function<void(Module &, const StringSet<> &)> InternalizeCallback) {
605  ModuleLinker ModLinker(Mover, std::move(Src), Flags,
606  std::move(InternalizeCallback));
607  return ModLinker.run();
608 }
609 
610 //===----------------------------------------------------------------------===//
611 // LinkModules entrypoint.
612 //===----------------------------------------------------------------------===//
613 
614 /// This function links two modules together, with the resulting Dest module
615 /// modified to be the composite of the two input modules. If an error occurs,
616 /// true is returned and ErrorMsg (if not null) is set to indicate the problem.
617 /// Upon failure, the Dest module could be in a modified state, and shouldn't be
618 /// relied on to be consistent.
620  Module &Dest, std::unique_ptr<Module> Src, unsigned Flags,
621  std::function<void(Module &, const StringSet<> &)> InternalizeCallback) {
622  Linker L(Dest);
623  return L.linkInModule(std::move(Src), Flags, std::move(InternalizeCallback));
624 }
625 
626 //===----------------------------------------------------------------------===//
627 // C API.
628 //===----------------------------------------------------------------------===//
629 
631  Module *D = unwrap(Dest);
632  std::unique_ptr<Module> M(unwrap(Src));
633  return Linker::linkModules(*D, std::move(M));
634 }
llvm::GlobalValue::UnnamedAddr
UnnamedAddr
Definition: GlobalValue.h:205
llvm
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
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
Comdat.h
llvm::Comdat::getName
StringRef getName() const
Definition: Comdat.cpp:28
llvm::GlobalValue::hasCommonLinkage
bool hasCommonLinkage() const
Definition: GlobalValue.h:527
llvm::DataLayout
A parsed version of the target data layout string in and methods for querying it.
Definition: DataLayout.h:114
llvm::GlobalValue::hasExternalLinkage
bool hasExternalLinkage() const
Definition: GlobalValue.h:506
llvm::unique_function
unique_function is a type-erasing functor similar to std::function.
Definition: FunctionExtras.h:56
llvm::GlobalValue::getLinkage
LinkageTypes getLinkage() const
Definition: GlobalValue.h:541
llvm::GlobalValue::HiddenVisibility
@ HiddenVisibility
The GV is hidden.
Definition: GlobalValue.h:64
llvm::Function
Definition: Function.h:59
llvm::SetVector::size
size_type size() const
Determine the number of elements in the SetVector.
Definition: SetVector.h:77
llvm::GlobalValue::hasWeakLinkage
bool hasWeakLinkage() const
Definition: GlobalValue.h:517
llvm::SmallVector
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1199
llvm::GlobalValue::isLocalLinkage
static bool isLocalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:404
llvm::Value::hasName
bool hasName() const
Definition: Value.h:261
llvm::GlobalVariable
Definition: GlobalVariable.h:39
llvm::GlobalAlias
Definition: GlobalAlias.h:28
Error.h
llvm::StringMap::end
iterator end()
Definition: StringMap.h:204
Module.h
llvm::MaybeAlign::valueOrOne
Align valueOrOne() const
For convenience, returns a valid alignment or 1 if undefined.
Definition: Alignment.h:141
llvm::DenseMapBase< DenseMap< KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >, KeyT, ValueT, DenseMapInfo< KeyT >, llvm::detail::DenseMapPair< KeyT, ValueT > >::count
size_type count(const_arg_type_t< KeyT > Val) const
Return 1 if the specified key is in the map, 0 otherwise.
Definition: DenseMap.h:145
llvm::GlobalValue::DefaultVisibility
@ DefaultVisibility
The GV is visible.
Definition: GlobalValue.h:63
llvm::max
Expected< ExpressionValue > max(const ExpressionValue &Lhs, const ExpressionValue &Rhs)
Definition: FileCheck.cpp:337
llvm::StringSet::insert
std::pair< typename Base::iterator, bool > insert(StringRef key)
Definition: StringSet.h:34
llvm::GlobalValue::setUnnamedAddr
void setUnnamedAddr(UnnamedAddr Val)
Definition: GlobalValue.h:227
llvm::StringMap::find
iterator find(StringRef Key)
Definition: StringMap.h:217
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
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::GlobalValue::hasExternalWeakLinkage
bool hasExternalWeakLinkage() const
Definition: GlobalValue.h:524
llvm::IRMover::getModule
Module & getModule()
Definition: IRMover.h:81
LLVMLinkModules2
LLVMBool LLVMLinkModules2(LLVMModuleRef Dest, LLVMModuleRef Src)
Definition: LinkModules.cpp:630
F
#define F(x, y, z)
Definition: MD5.cpp:55
llvm::Linker::LinkOnlyNeeded
@ LinkOnlyNeeded
Definition: Linker.h:29
GlobalValue.h
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:265
LinkDiagnosticInfo.h
llvm::PPCISD::SC
@ SC
CHAIN = SC CHAIN, Imm128 - System call.
Definition: PPCISelLowering.h:420
llvm::GlobalValue::VisibilityTypes
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Definition: GlobalValue.h:62
llvm::GlobalValue::hasAppendingLinkage
bool hasAppendingLinkage() const
Definition: GlobalValue.h:520
llvm::Module::globals
iterator_range< global_iterator > globals()
Definition: Module.h:614
E
static GCRegistry::Add< CoreCLRGC > E("coreclr", "CoreCLR-compatible GC")
Linker.h
llvm::Comdat::SelectionKind
SelectionKind
Definition: Comdat.h:35
C
(vector float) vec_cmpeq(*A, *B) C
Definition: README_ALTIVEC.txt:86
llvm::Linker::linkModules
static bool linkModules(Module &Dest, std::unique_ptr< Module > Src, unsigned Flags=Flags::None, std::function< void(Module &, const StringSet<> &)> InternalizeCallback={})
This function links two modules together, with the resulting Dest module modified to be the composite...
Definition: LinkModules.cpp:619
llvm::ms_demangle::QualifierMangleMode::Result
@ Result
llvm::MaybeAlign
This struct is a compact representation of a valid (power of two) or undefined (0) alignment.
Definition: Alignment.h:117
B
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
llvm::Module::getComdatSymbolTable
const ComdatSymTabType & getComdatSymbolTable() const
Get the Module's symbol table for COMDATs (constant).
Definition: Module.h:599
llvm::IRMover::move
Error move(std::unique_ptr< Module > Src, ArrayRef< GlobalValue * > ValuesToLink, LazyCallback AddLazyFor, bool IsPerformingImport)
Move in the provide values in ValuesToLink from Src.
Definition: IRMover.cpp:1785
llvm::unwrap
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:285
llvm::Align
This struct is a compact representation of a valid (non-zero power of two) alignment.
Definition: Alignment.h:39
llvm::Comdat
Definition: Comdat.h:33
llvm::ErrorInfoBase
Base class for error info classes.
Definition: Error.h:47
llvm::Value::use_empty
bool use_empty() const
Definition: Value.h:344
llvm::ErrorInfoBase::message
virtual std::string message() const
Return the error message as a string.
Definition: Error.h:55
llvm::StringMap< Comdat >
llvm::dxil::PointerTypeAnalysis::run
PointerTypeMap run(const Module &M)
Compute the PointerTypeMap for the module M.
Definition: PointerTypeAnalysis.cpp:189
llvm::DenseSet
Implements a dense probed hash-table based set.
Definition: DenseSet.h:268
llvm::Module::aliases
iterator_range< alias_iterator > aliases()
Definition: Module.h:654
llvm::GlobalValue::hasAvailableExternallyLinkage
bool hasAvailableExternallyLinkage() const
Definition: GlobalValue.h:507
llvm::IRMover
Definition: IRMover.h:26
llvm::GlobalValue
Definition: GlobalValue.h:44
llvm::GlobalVariable::getInitializer
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
Definition: GlobalVariable.h:135
llvm::StringMapIterator
Definition: StringMap.h:27
llvm::GlobalValue::isWeakForLinker
static bool isWeakForLinker(LinkageTypes Linkage)
Whether the definition of this global may be replaced at link time.
Definition: GlobalValue.h:453
uint64_t
llvm::GlobalValue::getVisibility
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:244
D
static GCRegistry::Add< StatepointGC > D("statepoint-example", "an example strategy for statepoint")
llvm::GlobalValue::getParent
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:652
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::DenseMap
Definition: DenseMap.h:714
llvm::IRMover::ValueAdder
std::function< void(GlobalValue &)> ValueAdder
Definition: IRMover.h:65
I
#define I(x, y, z)
Definition: MD5.cpp:58
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:721
llvm::Function::Create
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace, const Twine &N="", Module *M=nullptr)
Definition: Function.h:136
assert
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
llvm::GlobalValue::hasLocalLinkage
bool hasLocalLinkage() const
Definition: GlobalValue.h:523
function
print Print MemDeps of function
Definition: MemDepPrinter.cpp:82
getMinVisibility
static GlobalValue::VisibilityTypes getMinVisibility(GlobalValue::VisibilityTypes A, GlobalValue::VisibilityTypes B)
Definition: LinkModules.cpp:121
llvm::SystemZICMP::Any
@ Any
Definition: SystemZISelLowering.h:375
llvm::Module
A Module instance is used to store all the information related to an LLVM module.
Definition: Module.h:65
llvm::Linker
This class provides the core functionality of linking in LLVM.
Definition: Linker.h:22
llvm::SetVector::insert
bool insert(const value_type &X)
Insert a new element into the SetVector.
Definition: SetVector.h:141
llvm::Linker::Linker
Linker(Module &M)
Definition: LinkModules.cpp:600
llvm::StringSet
StringSet - A wrapper for StringMap that provides set-like functionality.
Definition: StringSet.h:23
llvm::StringRef
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
llvm_unreachable
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
Definition: ErrorHandling.h:143
DL
MachineBasicBlock MachineBasicBlock::iterator DebugLoc DL
Definition: AArch64SLSHardening.cpp:76
llvm::GlobalValue::getAliaseeObject
const GlobalObject * getAliaseeObject() const
Definition: Globals.cpp:359
llvm::Value::getName
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:308
llvm::GlobalValue::eraseFromParent
void eraseFromParent()
This method unlinks 'this' from the containing module and deletes it.
Definition: Globals.cpp:88
llvm::GlobalValue::getUnnamedAddr
UnnamedAddr getUnnamedAddr() const
Definition: GlobalValue.h:224
llvm::Twine
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
llvm::Linker::Flags
Flags
Definition: Linker.h:26
LLVMBool
int LLVMBool
Definition: Types.h:28
llvm::Linker::OverrideFromSrc
@ OverrideFromSrc
Definition: Linker.h:28
llvm::Error
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
llvm::Linker::linkInModule
bool linkInModule(std::unique_ptr< Module > Src, unsigned Flags=Flags::None, std::function< void(Module &, const StringSet<> &)> InternalizeCallback={})
Link Src into the composite.
Definition: LinkModules.cpp:602
llvm::GlobalValue::getComdat
const Comdat * getComdat() const
Definition: Globals.cpp:175
llvm::Module::getContext
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:262
llvm::GlobalValue::ProtectedVisibility
@ ProtectedVisibility
The GV is protected.
Definition: GlobalValue.h:65
llvm::MCID::Add
@ Add
Definition: MCInstrDesc.h:186
llvm::GlobalValue::ExternalLinkage
@ ExternalLinkage
Externally visible function.
Definition: GlobalValue.h:48
llvm::GlobalValue::PrivateLinkage
@ PrivateLinkage
Like Internal, but omit from symbol table.
Definition: GlobalValue.h:56
llvm::GlobalValue::isDeclarationForLinker
bool isDeclarationForLinker() const
Definition: GlobalValue.h:614
llvm::LinkDiagnosticInfo
Definition: LinkDiagnosticInfo.h:15
llvm::GlobalValue::hasLinkOnceLinkage
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:510
Linker.h
llvm::SmallVectorImpl
This class consists of common code factored out of the SmallVector class to reduce code duplication b...
Definition: APFloat.h:42
llvm::Module::getDataLayout
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:398
llvm::GlobalValue::getValueType
Type * getValueType() const
Definition: GlobalValue.h:292
llvm::omp::RTLDependInfoFields::Flags
@ Flags
LLVMContext.h
From
BlockVerifier::State From
Definition: BlockVerifier.cpp:55
llvm::Value::takeName
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:381
llvm::Comdat::getSelectionKind
SelectionKind getSelectionKind() const
Definition: Comdat.h:46
llvm::SetVector
A vector that has set insertion semantics.
Definition: SetVector.h:40
llvm::GlobalIFunc
Definition: GlobalIFunc.h:34
llvm::GlobalValue::setVisibility
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:250
llvm::handleAllErrors
void handleAllErrors(Error E, HandlerTs &&... Handlers)
Behaves the same as handleErrors, except that by contract all errors must be handled by the given han...
Definition: Error.h:966
llvm::DS_Error
@ DS_Error
Definition: DiagnosticInfo.h:50
llvm::GlobalValue::getMinUnnamedAddr
static UnnamedAddr getMinUnnamedAddr(UnnamedAddr A, UnnamedAddr B)
Definition: GlobalValue.h:229
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
SetVector.h
LLVMModuleRef
struct LLVMOpaqueModule * LLVMModuleRef
The top-level container for all other LLVM Intermediate Representation (IR) objects.
Definition: Types.h:61
llvm::DataLayout::getTypeAllocSize
TypeSize getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:507