• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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"
18 #include "llvm/IR/DiagnosticPrinter.h"
19 #include "llvm/IR/LLVMContext.h"
20 #include "llvm/Linker/Linker.h"
21 #include "llvm/Support/Error.h"
22 #include "llvm/Transforms/Utils/FunctionImportUtils.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 
shouldLinkReferencedLinkOnce()49   bool shouldLinkReferencedLinkOnce() {
50     return !(Flags & Linker::DontForceLinkLinkonceODR);
51   }
shouldOverrideFromSrc()52   bool shouldOverrideFromSrc() { return Flags & Linker::OverrideFromSrc; }
shouldLinkOnlyNeeded()53   bool shouldLinkOnlyNeeded() { return Flags & Linker::LinkOnlyNeeded; }
shouldInternalizeLinkedSymbols()54   bool shouldInternalizeLinkedSymbols() {
55     return Flags & Linker::InternalizeLinkedSymbols;
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?
emitError(const Twine & Message)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,
70                                      Comdat::SelectionKind Src,
71                                      Comdat::SelectionKind Dst,
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.
79   DenseMap<const Comdat *, std::vector<GlobalValue *>> LazyComdatMembers;
80 
81   /// Given a global in the source module, return the global in the
82   /// destination module that is being linked to, if any.
getLinkedToGlobal(const GlobalValue * SrcGV)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.
isPerformingImport() const113   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:
ModuleLinker(IRMover & Mover,std::unique_ptr<Module> SrcM,unsigned Flags,DenseSet<const GlobalValue * > * GlobalsToImport=nullptr)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 
doImportAsDefinition(const GlobalValue * SGV)129 bool ModuleLinker::doImportAsDefinition(const GlobalValue *SGV) {
130   if (!isPerformingImport())
131     return false;
132   return FunctionImportGlobalProcessing::doImportAsDefinition(SGV,
133                                                               GlobalsToImport);
134 }
135 
136 static GlobalValue::VisibilityTypes
getMinVisibility(GlobalValue::VisibilityTypes A,GlobalValue::VisibilityTypes B)137 getMinVisibility(GlobalValue::VisibilityTypes A,
138                  GlobalValue::VisibilityTypes B) {
139   if (A == GlobalValue::HiddenVisibility || B == GlobalValue::HiddenVisibility)
140     return GlobalValue::HiddenVisibility;
141   if (A == GlobalValue::ProtectedVisibility ||
142       B == GlobalValue::ProtectedVisibility)
143     return GlobalValue::ProtectedVisibility;
144   return GlobalValue::DefaultVisibility;
145 }
146 
getComdatLeader(Module & M,StringRef ComdatName,const GlobalVariable * & GVar)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 
computeResultingSelectionKind(StringRef ComdatName,Comdat::SelectionKind Src,Comdat::SelectionKind Dst,Comdat::SelectionKind & Result,bool & LinkFromSrc)167 bool ModuleLinker::computeResultingSelectionKind(StringRef ComdatName,
168                                                  Comdat::SelectionKind Src,
169                                                  Comdat::SelectionKind Dst,
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
184       Result = Comdat::SelectionKind::Any;
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) {
193   case Comdat::SelectionKind::Any:
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 
getComdatResult(const Comdat * SrcC,Comdat::SelectionKind & Result,bool & LinkFromSrc)235 bool ModuleLinker::getComdatResult(const Comdat *SrcC,
236                                    Comdat::SelectionKind &Result,
237                                    bool &LinkFromSrc) {
238   Module &DstM = Mover.getModule();
239   Comdat::SelectionKind SSK = SrcC->getSelectionKind();
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;
252   Comdat::SelectionKind DSK = DstC->getSelectionKind();
253   return computeResultingSelectionKind(ComdatName, SSK, DSK, Result,
254                                        LinkFromSrc);
255 }
256 
shouldLinkFromSource(bool & LinkFromSrc,const GlobalValue & Dest,const GlobalValue & Src)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()) {
327     assert(!Dest.hasExternalWeakLinkage());
328     assert(!Dest.hasAvailableExternallyLinkage());
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 
345   assert(!Src.hasExternalWeakLinkage());
346   assert(!Dest.hasExternalWeakLinkage());
347   assert(Dest.hasExternalLinkage() && Src.hasExternalLinkage() &&
348          "Unexpected linkage type!");
349   return emitError("Linking globals named '" + Src.getName() +
350                    "': symbol multiply defined!");
351 }
352 
linkIfNeeded(GlobalValue & GV)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 
375     GlobalValue::VisibilityTypes Visibility =
376         getMinVisibility(DGV->getVisibility(), GV.getVisibility());
377     DGV->setVisibility(Visibility);
378     GV.setVisibility(Visibility);
379 
380     GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::getMinUnnamedAddr(
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() ||
398               GV.hasAvailableExternallyLinkage()))
399     return false;
400 
401   if (GV.isDeclaration())
402     return false;
403 
404   if (const Comdat *SC = GV.getComdat()) {
405     bool LinkFromSrc;
406     Comdat::SelectionKind SK;
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 
addLazyFor(GlobalValue & GV,const IRMover::ValueAdder & Add)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 
dropReplacedComdat(GlobalValue & GV,const DenseSet<const Comdat * > & ReplacedDstComdats)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,
477                              GlobalValue::ExternalLinkage,
478                              /*Initializer*/ nullptr);
479     }
480     Declaration->takeName(&Alias);
481     Alias.replaceAllUsesWith(Declaration);
482     Alias.eraseFromParent();
483   }
484 }
485 
run()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;
494     Comdat::SelectionKind SK;
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     handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
587       DstM.getContext().diagnose(LinkDiagnosticInfo(DS_Error, EIB.message()));
588       HasErrors = true;
589     });
590   }
591   if (HasErrors)
592     return true;
593 
594   for (auto &P : Internalize) {
595     GlobalValue *GV = DstM.getNamedValue(P.first());
596     GV->setLinkage(GlobalValue::InternalLinkage);
597   }
598 
599   return false;
600 }
601 
Linker(Module & M)602 Linker::Linker(Module &M) : Mover(M) {}
603 
linkInModule(std::unique_ptr<Module> Src,unsigned Flags,DenseSet<const GlobalValue * > * GlobalsToImport)604 bool Linker::linkInModule(std::unique_ptr<Module> Src, unsigned Flags,
605                           DenseSet<const GlobalValue *> *GlobalsToImport) {
606   ModuleLinker ModLinker(Mover, std::move(Src), Flags, GlobalsToImport);
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.
linkModules(Module & Dest,std::unique_ptr<Module> Src,unsigned Flags)619 bool Linker::linkModules(Module &Dest, std::unique_ptr<Module> Src,
620                          unsigned Flags) {
621   Linker L(Dest);
622   return L.linkInModule(std::move(Src), Flags);
623 }
624 
625 //===----------------------------------------------------------------------===//
626 // C API.
627 //===----------------------------------------------------------------------===//
628 
LLVMLinkModules2(LLVMModuleRef Dest,LLVMModuleRef Src)629 LLVMBool LLVMLinkModules2(LLVMModuleRef Dest, LLVMModuleRef Src) {
630   Module *D = unwrap(Dest);
631   std::unique_ptr<Module> M(unwrap(Src));
632   return Linker::linkModules(*D, std::move(M));
633 }
634