LLVM  4.0.0
LinkModules.cpp
Go to the documentation of this file.
1 //===- lib/Linker/LinkModules.cpp - Module Linker Implementation ----------===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This file implements the LLVM module linker.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "LinkDiagnosticInfo.h"
15 #include "llvm-c/Linker.h"
16 #include "llvm/ADT/SetVector.h"
17 #include "llvm/ADT/StringSet.h"
19 #include "llvm/IR/LLVMContext.h"
20 #include "llvm/Linker/Linker.h"
21 #include "llvm/Support/Error.h"
23 using namespace llvm;
24 
25 namespace {
26 
27 /// This is an implementation class for the LinkModules function, which is the
28 /// entrypoint for this file.
29 class ModuleLinker {
30  IRMover &Mover;
31  std::unique_ptr<Module> SrcM;
32 
33  SetVector<GlobalValue *> ValuesToLink;
34  StringSet<> Internalize;
35 
36  /// For symbol clashes, prefer those from Src.
37  unsigned Flags;
38 
39  /// Functions to import from source module, all other functions are
40  /// imported as declarations instead of definitions.
41  DenseSet<const GlobalValue *> *GlobalsToImport;
42 
43  /// Used as the callback for lazy linking.
44  /// The mover has just hit GV and we have to decide if it, and other members
45  /// of the same comdat, should be linked. Every member to be linked is passed
46  /// to Add.
47  void addLazyFor(GlobalValue &GV, const IRMover::ValueAdder &Add);
48 
49  bool shouldLinkReferencedLinkOnce() {
51  }
52  bool shouldOverrideFromSrc() { return Flags & Linker::OverrideFromSrc; }
53  bool shouldLinkOnlyNeeded() { return Flags & Linker::LinkOnlyNeeded; }
54  bool shouldInternalizeLinkedSymbols() {
56  }
57 
58  bool shouldLinkFromSource(bool &LinkFromSrc, const GlobalValue &Dest,
59  const GlobalValue &Src);
60 
61  /// Should we have mover and linker error diag info?
62  bool emitError(const Twine &Message) {
63  SrcM->getContext().diagnose(LinkDiagnosticInfo(DS_Error, Message));
64  return true;
65  }
66 
67  bool getComdatLeader(Module &M, StringRef ComdatName,
68  const GlobalVariable *&GVar);
69  bool computeResultingSelectionKind(StringRef ComdatName,
72  Comdat::SelectionKind &Result,
73  bool &LinkFromSrc);
74  std::map<const Comdat *, std::pair<Comdat::SelectionKind, bool>>
75  ComdatsChosen;
76  bool getComdatResult(const Comdat *SrcC, Comdat::SelectionKind &SK,
77  bool &LinkFromSrc);
78  // Keep track of the lazy linked global members of each comdat in source.
80 
81  /// Given a global in the source module, return the global in the
82  /// destination module that is being linked to, if any.
83  GlobalValue *getLinkedToGlobal(const GlobalValue *SrcGV) {
84  Module &DstM = Mover.getModule();
85  // If the source has no name it can't link. If it has local linkage,
86  // there is no name match-up going on.
87  if (!SrcGV->hasName() || GlobalValue::isLocalLinkage(SrcGV->getLinkage()))
88  return nullptr;
89 
90  // Otherwise see if we have a match in the destination module's symtab.
91  GlobalValue *DGV = DstM.getNamedValue(SrcGV->getName());
92  if (!DGV)
93  return nullptr;
94 
95  // If we found a global with the same name in the dest module, but it has
96  // internal linkage, we are really not doing any linkage here.
97  if (DGV->hasLocalLinkage())
98  return nullptr;
99 
100  // Otherwise, we do in fact link to the destination global.
101  return DGV;
102  }
103 
104  /// Drop GV if it is a member of a comdat that we are dropping.
105  /// This can happen with COFF's largest selection kind.
106  void dropReplacedComdat(GlobalValue &GV,
107  const DenseSet<const Comdat *> &ReplacedDstComdats);
108 
109  bool linkIfNeeded(GlobalValue &GV);
110 
111  /// Helper method to check if we are importing from the current source
112  /// module.
113  bool isPerformingImport() const { return GlobalsToImport != nullptr; }
114 
115  /// If we are importing from the source module, checks if we should
116  /// import SGV as a definition, otherwise import as a declaration.
117  bool doImportAsDefinition(const GlobalValue *SGV);
118 
119 public:
120  ModuleLinker(IRMover &Mover, std::unique_ptr<Module> SrcM, unsigned Flags,
121  DenseSet<const GlobalValue *> *GlobalsToImport = nullptr)
122  : Mover(Mover), SrcM(std::move(SrcM)), Flags(Flags),
123  GlobalsToImport(GlobalsToImport) {}
124 
125  bool run();
126 };
127 }
128 
129 bool ModuleLinker::doImportAsDefinition(const GlobalValue *SGV) {
130  if (!isPerformingImport())
131  return false;
132  return FunctionImportGlobalProcessing::doImportAsDefinition(SGV,
133  GlobalsToImport);
134 }
135 
145 }
146 
147 bool ModuleLinker::getComdatLeader(Module &M, StringRef ComdatName,
148  const GlobalVariable *&GVar) {
149  const GlobalValue *GVal = M.getNamedValue(ComdatName);
150  if (const auto *GA = dyn_cast_or_null<GlobalAlias>(GVal)) {
151  GVal = GA->getBaseObject();
152  if (!GVal)
153  // We cannot resolve the size of the aliasee yet.
154  return emitError("Linking COMDATs named '" + ComdatName +
155  "': COMDAT key involves incomputable alias size.");
156  }
157 
158  GVar = dyn_cast_or_null<GlobalVariable>(GVal);
159  if (!GVar)
160  return emitError(
161  "Linking COMDATs named '" + ComdatName +
162  "': GlobalVariable required for data dependent selection!");
163 
164  return false;
165 }
166 
167 bool ModuleLinker::computeResultingSelectionKind(StringRef ComdatName,
170  Comdat::SelectionKind &Result,
171  bool &LinkFromSrc) {
172  Module &DstM = Mover.getModule();
173  // The ability to mix Comdat::SelectionKind::Any with
174  // Comdat::SelectionKind::Largest is a behavior that comes from COFF.
175  bool DstAnyOrLargest = Dst == Comdat::SelectionKind::Any ||
176  Dst == Comdat::SelectionKind::Largest;
177  bool SrcAnyOrLargest = Src == Comdat::SelectionKind::Any ||
178  Src == Comdat::SelectionKind::Largest;
179  if (DstAnyOrLargest && SrcAnyOrLargest) {
180  if (Dst == Comdat::SelectionKind::Largest ||
181  Src == Comdat::SelectionKind::Largest)
182  Result = Comdat::SelectionKind::Largest;
183  else
185  } else if (Src == Dst) {
186  Result = Dst;
187  } else {
188  return emitError("Linking COMDATs named '" + ComdatName +
189  "': invalid selection kinds!");
190  }
191 
192  switch (Result) {
194  // Go with Dst.
195  LinkFromSrc = false;
196  break;
197  case Comdat::SelectionKind::NoDuplicates:
198  return emitError("Linking COMDATs named '" + ComdatName +
199  "': noduplicates has been violated!");
200  case Comdat::SelectionKind::ExactMatch:
201  case Comdat::SelectionKind::Largest:
202  case Comdat::SelectionKind::SameSize: {
203  const GlobalVariable *DstGV;
204  const GlobalVariable *SrcGV;
205  if (getComdatLeader(DstM, ComdatName, DstGV) ||
206  getComdatLeader(*SrcM, ComdatName, SrcGV))
207  return true;
208 
209  const DataLayout &DstDL = DstM.getDataLayout();
210  const DataLayout &SrcDL = SrcM->getDataLayout();
211  uint64_t DstSize = DstDL.getTypeAllocSize(DstGV->getValueType());
212  uint64_t SrcSize = SrcDL.getTypeAllocSize(SrcGV->getValueType());
213  if (Result == Comdat::SelectionKind::ExactMatch) {
214  if (SrcGV->getInitializer() != DstGV->getInitializer())
215  return emitError("Linking COMDATs named '" + ComdatName +
216  "': ExactMatch violated!");
217  LinkFromSrc = false;
218  } else if (Result == Comdat::SelectionKind::Largest) {
219  LinkFromSrc = SrcSize > DstSize;
220  } else if (Result == Comdat::SelectionKind::SameSize) {
221  if (SrcSize != DstSize)
222  return emitError("Linking COMDATs named '" + ComdatName +
223  "': SameSize violated!");
224  LinkFromSrc = false;
225  } else {
226  llvm_unreachable("unknown selection kind");
227  }
228  break;
229  }
230  }
231 
232  return false;
233 }
234 
235 bool ModuleLinker::getComdatResult(const Comdat *SrcC,
236  Comdat::SelectionKind &Result,
237  bool &LinkFromSrc) {
238  Module &DstM = Mover.getModule();
240  StringRef ComdatName = SrcC->getName();
241  Module::ComdatSymTabType &ComdatSymTab = DstM.getComdatSymbolTable();
242  Module::ComdatSymTabType::iterator DstCI = ComdatSymTab.find(ComdatName);
243 
244  if (DstCI == ComdatSymTab.end()) {
245  // Use the comdat if it is only available in one of the modules.
246  LinkFromSrc = true;
247  Result = SSK;
248  return false;
249  }
250 
251  const Comdat *DstC = &DstCI->second;
253  return computeResultingSelectionKind(ComdatName, SSK, DSK, Result,
254  LinkFromSrc);
255 }
256 
257 bool ModuleLinker::shouldLinkFromSource(bool &LinkFromSrc,
258  const GlobalValue &Dest,
259  const GlobalValue &Src) {
260 
261  // Should we unconditionally use the Src?
262  if (shouldOverrideFromSrc()) {
263  LinkFromSrc = true;
264  return false;
265  }
266 
267  // We always have to add Src if it has appending linkage.
268  if (Src.hasAppendingLinkage()) {
269  // Should have prevented importing for appending linkage in linkIfNeeded.
270  assert(!isPerformingImport());
271  LinkFromSrc = true;
272  return false;
273  }
274 
275  if (isPerformingImport()) {
276  // LinkFromSrc iff this is a global requested for importing.
277  LinkFromSrc = GlobalsToImport->count(&Src);
278  return false;
279  }
280 
281  bool SrcIsDeclaration = Src.isDeclarationForLinker();
282  bool DestIsDeclaration = Dest.isDeclarationForLinker();
283 
284  if (SrcIsDeclaration) {
285  // If Src is external or if both Src & Dest are external.. Just link the
286  // external globals, we aren't adding anything.
287  if (Src.hasDLLImportStorageClass()) {
288  // If one of GVs is marked as DLLImport, result should be dllimport'ed.
289  LinkFromSrc = DestIsDeclaration;
290  return false;
291  }
292  // If the Dest is weak, use the source linkage.
293  if (Dest.hasExternalWeakLinkage()) {
294  LinkFromSrc = true;
295  return false;
296  }
297  // Link an available_externally over a declaration.
298  LinkFromSrc = !Src.isDeclaration() && Dest.isDeclaration();
299  return false;
300  }
301 
302  if (DestIsDeclaration) {
303  // If Dest is external but Src is not:
304  LinkFromSrc = true;
305  return false;
306  }
307 
308  if (Src.hasCommonLinkage()) {
309  if (Dest.hasLinkOnceLinkage() || Dest.hasWeakLinkage()) {
310  LinkFromSrc = true;
311  return false;
312  }
313 
314  if (!Dest.hasCommonLinkage()) {
315  LinkFromSrc = false;
316  return false;
317  }
318 
319  const DataLayout &DL = Dest.getParent()->getDataLayout();
320  uint64_t DestSize = DL.getTypeAllocSize(Dest.getValueType());
321  uint64_t SrcSize = DL.getTypeAllocSize(Src.getValueType());
322  LinkFromSrc = SrcSize > DestSize;
323  return false;
324  }
325 
326  if (Src.isWeakForLinker()) {
329 
330  if (Dest.hasLinkOnceLinkage() && Src.hasWeakLinkage()) {
331  LinkFromSrc = true;
332  return false;
333  }
334 
335  LinkFromSrc = false;
336  return false;
337  }
338 
339  if (Dest.isWeakForLinker()) {
340  assert(Src.hasExternalLinkage());
341  LinkFromSrc = true;
342  return false;
343  }
344 
347  assert(Dest.hasExternalLinkage() && Src.hasExternalLinkage() &&
348  "Unexpected linkage type!");
349  return emitError("Linking globals named '" + Src.getName() +
350  "': symbol multiply defined!");
351 }
352 
353 bool ModuleLinker::linkIfNeeded(GlobalValue &GV) {
354  GlobalValue *DGV = getLinkedToGlobal(&GV);
355 
356  if (shouldLinkOnlyNeeded() && !(DGV && DGV->isDeclaration()))
357  return false;
358 
359  if (DGV && !GV.hasLocalLinkage() && !GV.hasAppendingLinkage()) {
360  auto *DGVar = dyn_cast<GlobalVariable>(DGV);
361  auto *SGVar = dyn_cast<GlobalVariable>(&GV);
362  if (DGVar && SGVar) {
363  if (DGVar->isDeclaration() && SGVar->isDeclaration() &&
364  (!DGVar->isConstant() || !SGVar->isConstant())) {
365  DGVar->setConstant(false);
366  SGVar->setConstant(false);
367  }
368  if (DGVar->hasCommonLinkage() && SGVar->hasCommonLinkage()) {
369  unsigned Align = std::max(DGVar->getAlignment(), SGVar->getAlignment());
370  SGVar->setAlignment(Align);
371  DGVar->setAlignment(Align);
372  }
373  }
374 
377  DGV->setVisibility(Visibility);
378  GV.setVisibility(Visibility);
379 
381  DGV->getUnnamedAddr(), GV.getUnnamedAddr());
382  DGV->setUnnamedAddr(UnnamedAddr);
383  GV.setUnnamedAddr(UnnamedAddr);
384  }
385 
386  // Don't want to append to global_ctors list, for example, when we
387  // are importing for ThinLTO, otherwise the global ctors and dtors
388  // get executed multiple times for local variables (the latter causing
389  // double frees).
390  if (GV.hasAppendingLinkage() && isPerformingImport())
391  return false;
392 
393  if (isPerformingImport()) {
394  if (!doImportAsDefinition(&GV))
395  return false;
396  } else if (!DGV && !shouldOverrideFromSrc() &&
397  (GV.hasLocalLinkage() || GV.hasLinkOnceLinkage() ||
399  return false;
400 
401  if (GV.isDeclaration())
402  return false;
403 
404  if (const Comdat *SC = GV.getComdat()) {
405  bool LinkFromSrc;
407  std::tie(SK, LinkFromSrc) = ComdatsChosen[SC];
408  if (!LinkFromSrc)
409  return false;
410  }
411 
412  bool LinkFromSrc = true;
413  if (DGV && shouldLinkFromSource(LinkFromSrc, *DGV, GV))
414  return true;
415  if (LinkFromSrc)
416  ValuesToLink.insert(&GV);
417  return false;
418 }
419 
420 void ModuleLinker::addLazyFor(GlobalValue &GV, const IRMover::ValueAdder &Add) {
421  if (!shouldLinkReferencedLinkOnce())
422  // For ThinLTO we don't import more than what was required.
423  // The client has to guarantee that the linkonce will be availabe at link
424  // time (by promoting it to weak for instance).
425  return;
426 
427  // Add these to the internalize list
428  if (!GV.hasLinkOnceLinkage() && !shouldLinkOnlyNeeded())
429  return;
430 
431  if (shouldInternalizeLinkedSymbols())
432  Internalize.insert(GV.getName());
433  Add(GV);
434 
435  const Comdat *SC = GV.getComdat();
436  if (!SC)
437  return;
438  for (GlobalValue *GV2 : LazyComdatMembers[SC]) {
439  GlobalValue *DGV = getLinkedToGlobal(GV2);
440  bool LinkFromSrc = true;
441  if (DGV && shouldLinkFromSource(LinkFromSrc, *DGV, *GV2))
442  return;
443  if (!LinkFromSrc)
444  continue;
445  if (shouldInternalizeLinkedSymbols())
446  Internalize.insert(GV2->getName());
447  Add(*GV2);
448  }
449 }
450 
451 void ModuleLinker::dropReplacedComdat(
452  GlobalValue &GV, const DenseSet<const Comdat *> &ReplacedDstComdats) {
453  Comdat *C = GV.getComdat();
454  if (!C)
455  return;
456  if (!ReplacedDstComdats.count(C))
457  return;
458  if (GV.use_empty()) {
459  GV.eraseFromParent();
460  return;
461  }
462 
463  if (auto *F = dyn_cast<Function>(&GV)) {
464  F->deleteBody();
465  } else if (auto *Var = dyn_cast<GlobalVariable>(&GV)) {
466  Var->setInitializer(nullptr);
467  } else {
468  auto &Alias = cast<GlobalAlias>(GV);
469  Module &M = *Alias.getParent();
470  PointerType &Ty = *cast<PointerType>(Alias.getType());
471  GlobalValue *Declaration;
472  if (auto *FTy = dyn_cast<FunctionType>(Alias.getValueType())) {
473  Declaration = Function::Create(FTy, GlobalValue::ExternalLinkage, "", &M);
474  } else {
475  Declaration =
476  new GlobalVariable(M, Ty.getElementType(), /*isConstant*/ false,
478  /*Initializer*/ nullptr);
479  }
480  Declaration->takeName(&Alias);
481  Alias.replaceAllUsesWith(Declaration);
482  Alias.eraseFromParent();
483  }
484 }
485 
486 bool ModuleLinker::run() {
487  Module &DstM = Mover.getModule();
488  DenseSet<const Comdat *> ReplacedDstComdats;
489 
490  for (const auto &SMEC : SrcM->getComdatSymbolTable()) {
491  const Comdat &C = SMEC.getValue();
492  if (ComdatsChosen.count(&C))
493  continue;
495  bool LinkFromSrc;
496  if (getComdatResult(&C, SK, LinkFromSrc))
497  return true;
498  ComdatsChosen[&C] = std::make_pair(SK, LinkFromSrc);
499 
500  if (!LinkFromSrc)
501  continue;
502 
503  Module::ComdatSymTabType &ComdatSymTab = DstM.getComdatSymbolTable();
504  Module::ComdatSymTabType::iterator DstCI = ComdatSymTab.find(C.getName());
505  if (DstCI == ComdatSymTab.end())
506  continue;
507 
508  // The source comdat is replacing the dest one.
509  const Comdat *DstC = &DstCI->second;
510  ReplacedDstComdats.insert(DstC);
511  }
512 
513  // Alias have to go first, since we are not able to find their comdats
514  // otherwise.
515  for (auto I = DstM.alias_begin(), E = DstM.alias_end(); I != E;) {
516  GlobalAlias &GV = *I++;
517  dropReplacedComdat(GV, ReplacedDstComdats);
518  }
519 
520  for (auto I = DstM.global_begin(), E = DstM.global_end(); I != E;) {
521  GlobalVariable &GV = *I++;
522  dropReplacedComdat(GV, ReplacedDstComdats);
523  }
524 
525  for (auto I = DstM.begin(), E = DstM.end(); I != E;) {
526  Function &GV = *I++;
527  dropReplacedComdat(GV, ReplacedDstComdats);
528  }
529 
530  for (GlobalVariable &GV : SrcM->globals())
531  if (GV.hasLinkOnceLinkage())
532  if (const Comdat *SC = GV.getComdat())
533  LazyComdatMembers[SC].push_back(&GV);
534 
535  for (Function &SF : *SrcM)
536  if (SF.hasLinkOnceLinkage())
537  if (const Comdat *SC = SF.getComdat())
538  LazyComdatMembers[SC].push_back(&SF);
539 
540  for (GlobalAlias &GA : SrcM->aliases())
541  if (GA.hasLinkOnceLinkage())
542  if (const Comdat *SC = GA.getComdat())
543  LazyComdatMembers[SC].push_back(&GA);
544 
545  // Insert all of the globals in src into the DstM module... without linking
546  // initializers (which could refer to functions not yet mapped over).
547  for (GlobalVariable &GV : SrcM->globals())
548  if (linkIfNeeded(GV))
549  return true;
550 
551  for (Function &SF : *SrcM)
552  if (linkIfNeeded(SF))
553  return true;
554 
555  for (GlobalAlias &GA : SrcM->aliases())
556  if (linkIfNeeded(GA))
557  return true;
558 
559  for (unsigned I = 0; I < ValuesToLink.size(); ++I) {
560  GlobalValue *GV = ValuesToLink[I];
561  const Comdat *SC = GV->getComdat();
562  if (!SC)
563  continue;
564  for (GlobalValue *GV2 : LazyComdatMembers[SC]) {
565  GlobalValue *DGV = getLinkedToGlobal(GV2);
566  bool LinkFromSrc = true;
567  if (DGV && shouldLinkFromSource(LinkFromSrc, *DGV, *GV2))
568  return true;
569  if (LinkFromSrc)
570  ValuesToLink.insert(GV2);
571  }
572  }
573 
574  if (shouldInternalizeLinkedSymbols()) {
575  for (GlobalValue *GV : ValuesToLink)
576  Internalize.insert(GV->getName());
577  }
578 
579  // FIXME: Propagate Errors through to the caller instead of emitting
580  // diagnostics.
581  bool HasErrors = false;
582  if (Error E = Mover.move(std::move(SrcM), ValuesToLink.getArrayRef(),
583  [this](GlobalValue &GV, IRMover::ValueAdder Add) {
584  addLazyFor(GV, Add);
585  },
586  /* LinkModuleInlineAsm */ !isPerformingImport(),
587  /* IsPerformingImport */ isPerformingImport())) {
588  handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
590  HasErrors = true;
591  });
592  }
593  if (HasErrors)
594  return true;
595 
596  for (auto &P : Internalize) {
597  GlobalValue *GV = DstM.getNamedValue(P.first());
599  }
600 
601  return false;
602 }
603 
604 Linker::Linker(Module &M) : Mover(M) {}
605 
606 bool Linker::linkInModule(std::unique_ptr<Module> Src, unsigned Flags,
607  DenseSet<const GlobalValue *> *GlobalsToImport) {
608  ModuleLinker ModLinker(Mover, std::move(Src), Flags, GlobalsToImport);
609  return ModLinker.run();
610 }
611 
612 //===----------------------------------------------------------------------===//
613 // LinkModules entrypoint.
614 //===----------------------------------------------------------------------===//
615 
616 /// This function links two modules together, with the resulting Dest module
617 /// modified to be the composite of the two input modules. If an error occurs,
618 /// true is returned and ErrorMsg (if not null) is set to indicate the problem.
619 /// Upon failure, the Dest module could be in a modified state, and shouldn't be
620 /// relied on to be consistent.
621 bool Linker::linkModules(Module &Dest, std::unique_ptr<Module> Src,
622  unsigned Flags) {
623  Linker L(Dest);
624  return L.linkInModule(std::move(Src), Flags);
625 }
626 
627 //===----------------------------------------------------------------------===//
628 // C API.
629 //===----------------------------------------------------------------------===//
630 
632  Module *D = unwrap(Dest);
633  std::unique_ptr<Module> M(unwrap(Src));
634  return Linker::linkModules(*D, std::move(M));
635 }
void setVisibility(VisibilityTypes V)
Definition: GlobalValue.h:225
MachineLoop * L
A parsed version of the target data layout string in and methods for querying it. ...
Definition: DataLayout.h:102
LinkageTypes getLinkage() const
Definition: GlobalValue.h:429
VisibilityTypes getVisibility() const
Definition: GlobalValue.h:219
bool hasName() const
Definition: Value.h:236
struct LLVMOpaqueModule * LLVMModuleRef
The top-level container for all other LLVM Intermediate Representation (IR) objects.
Definition: c/Types.h:62
A Module instance is used to store all the information related to an LLVM module. ...
Definition: Module.h:52
Implements a dense probed hash-table based set.
Definition: DenseSet.h:202
UnnamedAddr getUnnamedAddr() const
Definition: GlobalValue.h:200
Type * getValueType() const
Definition: GlobalValue.h:261
static bool linkModules(Module &Dest, std::unique_ptr< Module > Src, unsigned Flags=Flags::None)
This function links two modules together, with the resulting Dest module modified to be the composite...
bool hasAppendingLinkage() const
Definition: GlobalValue.h:412
iterator find(StringRef Key)
Definition: StringMap.h:315
Externally visible function.
Definition: GlobalValue.h:49
bool hasAvailableExternallyLinkage() const
Definition: GlobalValue.h:402
ELFYAML::ELF_STV Visibility
Definition: ELFYAML.cpp:661
Type * getElementType() const
Definition: DerivedTypes.h:462
const Constant * getInitializer() const
getInitializer - Return the initializer for this global variable.
Base class for error info classes.
Definition: Support/Error.h:46
LLVMBool LLVMLinkModules2(LLVMModuleRef Dest, LLVMModuleRef Src)
static bool isLocalLinkage(LinkageTypes Linkage)
Definition: GlobalValue.h:300
StringRef getName() const
Return a constant reference to the value's name.
Definition: Value.cpp:191
Don't force link referenced linkonce definitions, import declaration.
Definition: Linker/Linker.h:34
Linker(Module &M)
bool hasCommonLinkage() const
Definition: GlobalValue.h:419
struct fuzzer::@269 Flags
Twine - A lightweight data structure for efficiently representing the concatenation of temporary valu...
Definition: Twine.h:81
Attribute unwrap(LLVMAttributeRef Attr)
Definition: Attributes.h:191
static GCRegistry::Add< StatepointGC > D("statepoint-example","an example strategy for statepoint")
StringRef getName() const
Definition: Comdat.cpp:22
global_iterator global_begin()
Definition: Module.h:518
#define F(x, y, z)
Definition: MD5.cpp:51
VisibilityTypes
An enumeration for the kinds of visibility of global values.
Definition: GlobalValue.h:63
This class provides the core functionality of linking in LLVM.
Definition: Linker/Linker.h:24
static GCRegistry::Add< OcamlGC > B("ocaml","ocaml 3.10-compatible GC")
void takeName(Value *V)
Transfer the name from V to this value.
Definition: Value.cpp:263
Class to represent pointers.
Definition: DerivedTypes.h:443
static GCRegistry::Add< CoreCLRGC > E("coreclr","CoreCLR-compatible GC")
static bool isWeakForLinker(LinkageTypes Linkage)
Whether the definition of this global may be replaced at link time.
Definition: GlobalValue.h:349
#define P(N)
alias_iterator alias_end()
Definition: Module.h:559
SelectionKind getSelectionKind() const
Definition: Comdat.h:42
void handleAllErrors(Error E, HandlerTs &&...Handlers)
Behaves the same as handleErrors, except that it requires that all errors be handled by the given han...
static GlobalValue::VisibilityTypes getMinVisibility(GlobalValue::VisibilityTypes A, GlobalValue::VisibilityTypes B)
void setConstant(bool Val)
int LLVMBool
Definition: c/Types.h:29
bool hasWeakLinkage() const
Definition: GlobalValue.h:409
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
global_iterator global_end()
Definition: Module.h:520
bool hasExternalWeakLinkage() const
Definition: GlobalValue.h:416
bool hasExternalLinkage() const
Definition: GlobalValue.h:401
bool hasDLLImportStorageClass() const
Definition: GlobalValue.h:247
Comdat * getComdat()
Definition: Globals.cpp:155
uint64_t getTypeAllocSize(Type *Ty) const
Returns the offset in bytes between successive objects of the specified type, including alignment pad...
Definition: DataLayout.h:408
CHAIN = SC CHAIN, Imm128 - System call.
alias_iterator alias_begin()
Definition: Module.h:557
void setLinkage(LinkageTypes LT)
Definition: GlobalValue.h:424
static GCRegistry::Add< ShadowStackGC > C("shadow-stack","Very portable GC for uncooperative code generators")
const GlobalObject * getBaseObject() const
Definition: GlobalValue.h:517
bool hasLinkOnceLinkage() const
Definition: GlobalValue.h:405
const DataLayout & getDataLayout() const
Get the data layout for the module's target platform.
Definition: Module.cpp:384
iterator end()
Definition: Module.h:537
void setUnnamedAddr(UnnamedAddr Val)
Definition: GlobalValue.h:203
size_type count(const ValueT &V) const
Return 1 if the specified key is in the set, 0 otherwise.
Definition: DenseSet.h:81
bool isDeclaration() const
Return true if the primary definition of this global value is outside of the current translation unit...
Definition: Globals.cpp:188
const ComdatSymTabType & getComdatSymbolTable() const
Get the Module's symbol table for COMDATs (constant).
Definition: Module.h:510
#define I(x, y, z)
Definition: MD5.cpp:54
iterator begin()
Definition: Module.h:535
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:287
Rename collisions when linking (static functions).
Definition: GlobalValue.h:56
void diagnose(const DiagnosticInfo &DI)
Report a message to the currently installed diagnostic handler.
bool hasLocalLinkage() const
Definition: GlobalValue.h:415
bool use_empty() const
Definition: Value.h:299
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
std::function< void(GlobalValue &)> ValueAdder
Definition: IRMover.h:65
Module * getParent()
Get the module that this global value is contained inside of...
Definition: GlobalValue.h:537
A vector that has set insertion semantics.
Definition: SetVector.h:41
Lightweight error class with error context and mandatory checking.
virtual void eraseFromParent()=0
This method unlinks 'this' from the containing module and deletes it.
StringSet - A wrapper for StringMap that provides set-like functionality.
Definition: StringSet.h:23
virtual std::string message() const
Return the error message as a string.
Definition: Support/Error.h:54
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:47
bool linkInModule(std::unique_ptr< Module > Src, unsigned Flags=Flags::None, DenseSet< const GlobalValue * > *GlobalsToImport=nullptr)
Link Src into the composite.
static Function * Create(FunctionType *Ty, LinkageTypes Linkage, const Twine &N="", Module *M=nullptr)
Definition: Function.h:117
static UnnamedAddr getMinUnnamedAddr(UnnamedAddr A, UnnamedAddr B)
Definition: GlobalValue.h:205
static GCRegistry::Add< ErlangGC > A("erlang","erlang-compatible garbage collector")
bool isDeclarationForLinker() const
Definition: GlobalValue.h:496
GlobalValue * getNamedValue(StringRef Name) const
Return the global value in the module with the specified name, of arbitrary type. ...
Definition: Module.cpp:93
iterator end()
Definition: StringMap.h:305
LLVMContext & getContext() const
Get the global data context.
Definition: Module.h:222