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"
22using namespace llvm;
23
24namespace {
25
26enum class LinkFrom { Dst, Src, Both };
27
28/// This is an implementation class for the LinkModules function, which is the
29/// entrypoint for this file.
30class 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,
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.
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
109public:
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
120static GlobalValue::VisibilityTypes
121getMinVisibility(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
131bool 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
151bool 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
219bool 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
240bool 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
328bool 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
402void 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
428void 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
462bool 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
621Linker::Linker(Module &M) : Mover(M) {}
622
623bool 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.
640bool 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
651LLVMBool 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