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 
shouldOverrideFromSrc()53   bool shouldOverrideFromSrc() { return Flags & Linker::OverrideFromSrc; }
shouldLinkOnlyNeeded()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?
emitError(const Twine & Message)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,
68                                      Comdat::SelectionKind Src,
69                                      Comdat::SelectionKind Dst,
70                                      Comdat::SelectionKind &Result,
71                                      LinkFrom &From);
72   DenseMap<const Comdat *, std::pair<Comdat::SelectionKind, LinkFrom>>
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.
77   DenseMap<const Comdat *, std::vector<GlobalValue *>> LazyComdatMembers;
78 
79   /// Given a global in the source module, return the global in the
80   /// destination module that is being linked to, if any.
getLinkedToGlobal(const GlobalValue * SrcGV)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:
ModuleLinker(IRMover & Mover,std::unique_ptr<Module> SrcM,unsigned Flags,std::function<void (Module &,const StringSet<> &)> InternalizeCallback={})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 
120 static GlobalValue::VisibilityTypes
getMinVisibility(GlobalValue::VisibilityTypes A,GlobalValue::VisibilityTypes B)121 getMinVisibility(GlobalValue::VisibilityTypes A,
122                  GlobalValue::VisibilityTypes B) {
123   if (A == GlobalValue::HiddenVisibility || B == GlobalValue::HiddenVisibility)
124     return GlobalValue::HiddenVisibility;
125   if (A == GlobalValue::ProtectedVisibility ||
126       B == GlobalValue::ProtectedVisibility)
127     return GlobalValue::ProtectedVisibility;
128   return GlobalValue::DefaultVisibility;
129 }
130 
getComdatLeader(Module & M,StringRef ComdatName,const GlobalVariable * & GVar)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 
computeResultingSelectionKind(StringRef ComdatName,Comdat::SelectionKind Src,Comdat::SelectionKind Dst,Comdat::SelectionKind & Result,LinkFrom & From)151 bool ModuleLinker::computeResultingSelectionKind(StringRef ComdatName,
152                                                  Comdat::SelectionKind Src,
153                                                  Comdat::SelectionKind Dst,
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
168       Result = Comdat::SelectionKind::Any;
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) {
177   case Comdat::SelectionKind::Any:
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 
getComdatResult(const Comdat * SrcC,Comdat::SelectionKind & Result,LinkFrom & From)219 bool ModuleLinker::getComdatResult(const Comdat *SrcC,
220                                    Comdat::SelectionKind &Result,
221                                    LinkFrom &From) {
222   Module &DstM = Mover.getModule();
223   Comdat::SelectionKind SSK = SrcC->getSelectionKind();
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;
236   Comdat::SelectionKind DSK = DstC->getSelectionKind();
237   return computeResultingSelectionKind(ComdatName, SSK, DSK, Result, From);
238 }
239 
shouldLinkFromSource(bool & LinkFromSrc,const GlobalValue & Dest,const GlobalValue & Src)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()) {
302     assert(!Dest.hasExternalWeakLinkage());
303     assert(!Dest.hasAvailableExternallyLinkage());
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());
321   assert(!Dest.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 
linkIfNeeded(GlobalValue & GV,SmallVectorImpl<GlobalValue * > & GVToClone)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 =
367         getMinVisibility(DGV->getVisibility(), GV.getVisibility());
368     DGV->setVisibility(Visibility);
369     GV.setVisibility(Visibility);
370 
371     GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::getMinUnnamedAddr(
372         DGV->getUnnamedAddr(), GV.getUnnamedAddr());
373     DGV->setUnnamedAddr(UnnamedAddr);
374     GV.setUnnamedAddr(UnnamedAddr);
375   }
376 
377   if (!DGV && !shouldOverrideFromSrc() &&
378       (GV.hasLocalLinkage() || GV.hasLinkOnceLinkage() ||
379        GV.hasAvailableExternallyLinkage()))
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 
addLazyFor(GlobalValue & GV,const IRMover::ValueAdder & Add)402 void ModuleLinker::addLazyFor(GlobalValue &GV, const IRMover::ValueAdder &Add) {
403   // Add these to the internalize list
404   if (!GV.hasLinkOnceLinkage() && !GV.hasAvailableExternallyLinkage() &&
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 
dropReplacedComdat(GlobalValue & GV,const DenseSet<const Comdat * > & ReplacedDstComdats)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,
453                              GlobalValue::ExternalLinkage,
454                              /*Initializer*/ nullptr);
455     }
456     Declaration->takeName(&Alias);
457     Alias.replaceAllUsesWith(Declaration);
458     Alias.eraseFromParent();
459   }
460 }
461 
run()462 bool ModuleLinker::run() {
463   Module &DstM = Mover.getModule();
464   DenseSet<const Comdat *> ReplacedDstComdats;
465   DenseSet<const Comdat *> NonPrevailingComdats;
466 
467   for (const auto &SMEC : SrcM->getComdatSymbolTable()) {
468     const Comdat &C = SMEC.getValue();
469     if (ComdatsChosen.count(&C))
470       continue;
471     Comdat::SelectionKind SK;
472     LinkFrom From;
473     if (getComdatResult(&C, SK, From))
474       return true;
475     ComdatsChosen[&C] = std::make_pair(SK, From);
476 
477     if (From == LinkFrom::Dst)
478       NonPrevailingComdats.insert(&C);
479 
480     if (From != LinkFrom::Src)
481       continue;
482 
483     Module::ComdatSymTabType &ComdatSymTab = DstM.getComdatSymbolTable();
484     Module::ComdatSymTabType::iterator DstCI = ComdatSymTab.find(C.getName());
485     if (DstCI == ComdatSymTab.end())
486       continue;
487 
488     // The source comdat is replacing the dest one.
489     const Comdat *DstC = &DstCI->second;
490     ReplacedDstComdats.insert(DstC);
491   }
492 
493   // Alias have to go first, since we are not able to find their comdats
494   // otherwise.
495   for (GlobalAlias &GV : llvm::make_early_inc_range(DstM.aliases()))
496     dropReplacedComdat(GV, ReplacedDstComdats);
497 
498   for (GlobalVariable &GV : llvm::make_early_inc_range(DstM.globals()))
499     dropReplacedComdat(GV, ReplacedDstComdats);
500 
501   for (Function &GV : llvm::make_early_inc_range(DstM))
502     dropReplacedComdat(GV, ReplacedDstComdats);
503 
504   if (!NonPrevailingComdats.empty()) {
505     DenseSet<GlobalObject *> AliasedGlobals;
506     for (auto &GA : SrcM->aliases())
507       if (GlobalObject *GO = GA.getAliaseeObject(); GO && GO->getComdat())
508         AliasedGlobals.insert(GO);
509     for (const Comdat *C : NonPrevailingComdats) {
510       SmallVector<GlobalObject *> ToUpdate;
511       for (GlobalObject *GO : C->getUsers())
512         if (GO->hasPrivateLinkage() && !AliasedGlobals.contains(GO))
513           ToUpdate.push_back(GO);
514       for (GlobalObject *GO : ToUpdate) {
515         GO->setLinkage(GlobalValue::AvailableExternallyLinkage);
516         GO->setComdat(nullptr);
517       }
518     }
519   }
520 
521   for (GlobalVariable &GV : SrcM->globals())
522     if (GV.hasLinkOnceLinkage())
523       if (const Comdat *SC = GV.getComdat())
524         LazyComdatMembers[SC].push_back(&GV);
525 
526   for (Function &SF : *SrcM)
527     if (SF.hasLinkOnceLinkage())
528       if (const Comdat *SC = SF.getComdat())
529         LazyComdatMembers[SC].push_back(&SF);
530 
531   for (GlobalAlias &GA : SrcM->aliases())
532     if (GA.hasLinkOnceLinkage())
533       if (const Comdat *SC = GA.getComdat())
534         LazyComdatMembers[SC].push_back(&GA);
535 
536   // Insert all of the globals in src into the DstM module... without linking
537   // initializers (which could refer to functions not yet mapped over).
538   SmallVector<GlobalValue *, 0> GVToClone;
539   for (GlobalVariable &GV : SrcM->globals())
540     if (linkIfNeeded(GV, GVToClone))
541       return true;
542 
543   for (Function &SF : *SrcM)
544     if (linkIfNeeded(SF, GVToClone))
545       return true;
546 
547   for (GlobalAlias &GA : SrcM->aliases())
548     if (linkIfNeeded(GA, GVToClone))
549       return true;
550 
551   for (GlobalIFunc &GI : SrcM->ifuncs())
552     if (linkIfNeeded(GI, GVToClone))
553       return true;
554 
555   // For a variable in a comdat nodeduplicate, its initializer should be
556   // preserved (its content may be implicitly used by other members) even if
557   // symbol resolution does not pick it. Clone it into an unnamed private
558   // variable.
559   for (GlobalValue *GV : GVToClone) {
560     if (auto *Var = dyn_cast<GlobalVariable>(GV)) {
561       auto *NewVar = new GlobalVariable(*Var->getParent(), Var->getValueType(),
562                                         Var->isConstant(), Var->getLinkage(),
563                                         Var->getInitializer());
564       NewVar->copyAttributesFrom(Var);
565       NewVar->setVisibility(GlobalValue::DefaultVisibility);
566       NewVar->setLinkage(GlobalValue::PrivateLinkage);
567       NewVar->setDSOLocal(true);
568       NewVar->setComdat(Var->getComdat());
569       if (Var->getParent() != &Mover.getModule())
570         ValuesToLink.insert(NewVar);
571     } else {
572       emitError("linking '" + GV->getName() +
573                 "': non-variables in comdat nodeduplicate are not handled");
574     }
575   }
576 
577   for (unsigned I = 0; I < ValuesToLink.size(); ++I) {
578     GlobalValue *GV = ValuesToLink[I];
579     const Comdat *SC = GV->getComdat();
580     if (!SC)
581       continue;
582     for (GlobalValue *GV2 : LazyComdatMembers[SC]) {
583       GlobalValue *DGV = getLinkedToGlobal(GV2);
584       bool LinkFromSrc = true;
585       if (DGV && shouldLinkFromSource(LinkFromSrc, *DGV, *GV2))
586         return true;
587       if (LinkFromSrc)
588         ValuesToLink.insert(GV2);
589     }
590   }
591 
592   if (InternalizeCallback) {
593     for (GlobalValue *GV : ValuesToLink)
594       Internalize.insert(GV->getName());
595   }
596 
597   // FIXME: Propagate Errors through to the caller instead of emitting
598   // diagnostics.
599   bool HasErrors = false;
600   if (Error E =
601           Mover.move(std::move(SrcM), ValuesToLink.getArrayRef(),
602                      IRMover::LazyCallback(
603                          [this](GlobalValue &GV, IRMover::ValueAdder Add) {
604                            addLazyFor(GV, Add);
605                          }),
606                      /* IsPerformingImport */ false)) {
607     handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
608       DstM.getContext().diagnose(LinkDiagnosticInfo(DS_Error, EIB.message()));
609       HasErrors = true;
610     });
611   }
612   if (HasErrors)
613     return true;
614 
615   if (InternalizeCallback)
616     InternalizeCallback(DstM, Internalize);
617 
618   return false;
619 }
620 
Linker(Module & M)621 Linker::Linker(Module &M) : Mover(M) {}
622 
linkInModule(std::unique_ptr<Module> Src,unsigned Flags,std::function<void (Module &,const StringSet<> &)> InternalizeCallback)623 bool Linker::linkInModule(
624     std::unique_ptr<Module> Src, unsigned Flags,
625     std::function<void(Module &, const StringSet<> &)> InternalizeCallback) {
626   ModuleLinker ModLinker(Mover, std::move(Src), Flags,
627                          std::move(InternalizeCallback));
628   return ModLinker.run();
629 }
630 
631 //===----------------------------------------------------------------------===//
632 // LinkModules entrypoint.
633 //===----------------------------------------------------------------------===//
634 
635 /// This function links two modules together, with the resulting Dest module
636 /// modified to be the composite of the two input modules. If an error occurs,
637 /// true is returned and ErrorMsg (if not null) is set to indicate the problem.
638 /// Upon failure, the Dest module could be in a modified state, and shouldn't be
639 /// relied on to be consistent.
linkModules(Module & Dest,std::unique_ptr<Module> Src,unsigned Flags,std::function<void (Module &,const StringSet<> &)> InternalizeCallback)640 bool Linker::linkModules(
641     Module &Dest, std::unique_ptr<Module> Src, unsigned Flags,
642     std::function<void(Module &, const StringSet<> &)> InternalizeCallback) {
643   Linker L(Dest);
644   return L.linkInModule(std::move(Src), Flags, std::move(InternalizeCallback));
645 }
646 
647 //===----------------------------------------------------------------------===//
648 // C API.
649 //===----------------------------------------------------------------------===//
650 
LLVMLinkModules2(LLVMModuleRef Dest,LLVMModuleRef Src)651 LLVMBool LLVMLinkModules2(LLVMModuleRef Dest, LLVMModuleRef Src) {
652   Module *D = unwrap(Dest);
653   std::unique_ptr<Module> M(unwrap(Src));
654   return Linker::linkModules(*D, std::move(M));
655 }
656