contrib/llvm/lib/Linker/LinkModules.cpp

   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
  49   bool shouldLinkReferencedLinkOnce() {
  50     return !(Flags & Linker::DontForceLinkLinkonceODR);
  51   }
  52   bool shouldOverrideFromSrc() { return Flags & Linker::OverrideFromSrc; }
  53   bool shouldLinkOnlyNeeded() { return Flags & Linker::LinkOnlyNeeded; }
  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?
  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.
  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
 136 static GlobalValue::VisibilityTypes
 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
 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,
 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
 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
 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
 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
 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,
 477                              GlobalValue::ExternalLinkage,
 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;
 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
 602 Linker::Linker(Module &M) : Mover(M) {}
 603
 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.
 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
 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 }