LCOV - code coverage report
Current view: top level - lib/Linker - LinkModules.cpp (source / functions) Hit Total Coverage
Test: llvm-toolchain.info Lines: 270 287 94.1 %
Date: 2017-09-14 15:23:50 Functions: 17 17 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       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/IR/Comdat.h"
      18             : #include "llvm/IR/DiagnosticPrinter.h"
      19             : #include "llvm/IR/GlobalValue.h"
      20             : #include "llvm/IR/LLVMContext.h"
      21             : #include "llvm/IR/Module.h"
      22             : #include "llvm/Linker/Linker.h"
      23             : #include "llvm/Support/Error.h"
      24             : using namespace llvm;
      25             : 
      26             : namespace {
      27             : 
      28             : /// This is an implementation class for the LinkModules function, which is the
      29             : /// entrypoint for this file.
      30        2740 : 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             : 
      53        1209 :   bool shouldOverrideFromSrc() { return Flags & Linker::OverrideFromSrc; }
      54        1368 :   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          10 :   bool emitError(const Twine &Message) {
      61          30 :     SrcM->getContext().diagnose(LinkDiagnosticInfo(DS_Error, Message));
      62          10 :     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             :                                      bool &LinkFromSrc);
      72             :   std::map<const Comdat *, std::pair<Comdat::SelectionKind, bool>>
      73             :       ComdatsChosen;
      74             :   bool getComdatResult(const Comdat *SrcC, Comdat::SelectionKind &SK,
      75             :                        bool &LinkFromSrc);
      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        1350 :   GlobalValue *getLinkedToGlobal(const GlobalValue *SrcGV) {
      82        1350 :     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        5289 :     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        1244 :     GlobalValue *DGV = DstM.getNamedValue(SrcGV->getName());
      90        1244 :     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         215 :     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);
     108             : 
     109             : public:
     110         548 :   ModuleLinker(IRMover &Mover, std::unique_ptr<Module> SrcM, unsigned Flags,
     111             :                std::function<void(Module &, const StringSet<> &)>
     112             :                    InternalizeCallback = {})
     113        1096 :       : Mover(Mover), SrcM(std::move(SrcM)), Flags(Flags),
     114        3836 :         InternalizeCallback(std::move(InternalizeCallback)) {}
     115             : 
     116             :   bool run();
     117             : };
     118             : }
     119             : 
     120             : static GlobalValue::VisibilityTypes
     121             : getMinVisibility(GlobalValue::VisibilityTypes A,
     122             :                  GlobalValue::VisibilityTypes B) {
     123         196 :   if (A == GlobalValue::HiddenVisibility || B == GlobalValue::HiddenVisibility)
     124             :     return GlobalValue::HiddenVisibility;
     125         364 :   if (A == GlobalValue::ProtectedVisibility ||
     126         182 :       B == GlobalValue::ProtectedVisibility)
     127             :     return GlobalValue::ProtectedVisibility;
     128             :   return GlobalValue::DefaultVisibility;
     129             : }
     130             : 
     131          12 : bool ModuleLinker::getComdatLeader(Module &M, StringRef ComdatName,
     132             :                                    const GlobalVariable *&GVar) {
     133          12 :   const GlobalValue *GVal = M.getNamedValue(ComdatName);
     134           2 :   if (const auto *GA = dyn_cast_or_null<GlobalAlias>(GVal)) {
     135           2 :     GVal = GA->getBaseObject();
     136           2 :     if (!GVal)
     137             :       // We cannot resolve the size of the aliasee yet.
     138           3 :       return emitError("Linking COMDATs named '" + ComdatName +
     139           3 :                        "': COMDAT key involves incomputable alias size.");
     140             :   }
     141             : 
     142          11 :   GVar = dyn_cast_or_null<GlobalVariable>(GVal);
     143          11 :   if (!GVar)
     144             :     return emitError(
     145           3 :         "Linking COMDATs named '" + ComdatName +
     146           3 :         "': GlobalVariable required for data dependent selection!");
     147             : 
     148             :   return false;
     149             : }
     150             : 
     151          19 : bool ModuleLinker::computeResultingSelectionKind(StringRef ComdatName,
     152             :                                                  Comdat::SelectionKind Src,
     153             :                                                  Comdat::SelectionKind Dst,
     154             :                                                  Comdat::SelectionKind &Result,
     155             :                                                  bool &LinkFromSrc) {
     156          19 :   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          38 :   bool DstAnyOrLargest = Dst == Comdat::SelectionKind::Any ||
     160          19 :                          Dst == Comdat::SelectionKind::Largest;
     161          38 :   bool SrcAnyOrLargest = Src == Comdat::SelectionKind::Any ||
     162          19 :                          Src == Comdat::SelectionKind::Largest;
     163          19 :   if (DstAnyOrLargest && SrcAnyOrLargest) {
     164          16 :     if (Dst == Comdat::SelectionKind::Largest ||
     165             :         Src == Comdat::SelectionKind::Largest)
     166           6 :       Result = Comdat::SelectionKind::Largest;
     167             :     else
     168          10 :       Result = Comdat::SelectionKind::Any;
     169           3 :   } else if (Src == Dst) {
     170           2 :     Result = Dst;
     171             :   } else {
     172           3 :     return emitError("Linking COMDATs named '" + ComdatName +
     173           3 :                      "': invalid selection kinds!");
     174             :   }
     175             : 
     176          18 :   switch (Result) {
     177          10 :   case Comdat::SelectionKind::Any:
     178             :     // Go with Dst.
     179          10 :     LinkFromSrc = false;
     180          10 :     break;
     181           1 :   case Comdat::SelectionKind::NoDuplicates:
     182           3 :     return emitError("Linking COMDATs named '" + ComdatName +
     183           3 :                      "': noduplicates has been violated!");
     184           7 :   case Comdat::SelectionKind::ExactMatch:
     185             :   case Comdat::SelectionKind::Largest:
     186             :   case Comdat::SelectionKind::SameSize: {
     187             :     const GlobalVariable *DstGV;
     188             :     const GlobalVariable *SrcGV;
     189          12 :     if (getComdatLeader(DstM, ComdatName, DstGV) ||
     190          10 :         getComdatLeader(*SrcM, ComdatName, SrcGV))
     191           3 :       return true;
     192             : 
     193           5 :     const DataLayout &DstDL = DstM.getDataLayout();
     194          10 :     const DataLayout &SrcDL = SrcM->getDataLayout();
     195           5 :     uint64_t DstSize = DstDL.getTypeAllocSize(DstGV->getValueType());
     196           5 :     uint64_t SrcSize = SrcDL.getTypeAllocSize(SrcGV->getValueType());
     197           5 :     if (Result == Comdat::SelectionKind::ExactMatch) {
     198           0 :       if (SrcGV->getInitializer() != DstGV->getInitializer())
     199           0 :         return emitError("Linking COMDATs named '" + ComdatName +
     200           0 :                          "': ExactMatch violated!");
     201           0 :       LinkFromSrc = false;
     202           5 :     } else if (Result == Comdat::SelectionKind::Largest) {
     203           4 :       LinkFromSrc = SrcSize > DstSize;
     204           1 :     } else if (Result == Comdat::SelectionKind::SameSize) {
     205           1 :       if (SrcSize != DstSize)
     206           3 :         return emitError("Linking COMDATs named '" + ComdatName +
     207           3 :                          "': SameSize violated!");
     208           0 :       LinkFromSrc = false;
     209             :     } else {
     210           0 :       llvm_unreachable("unknown selection kind");
     211             :     }
     212           4 :     break;
     213             :   }
     214             :   }
     215             : 
     216             :   return false;
     217             : }
     218             : 
     219          53 : bool ModuleLinker::getComdatResult(const Comdat *SrcC,
     220             :                                    Comdat::SelectionKind &Result,
     221             :                                    bool &LinkFromSrc) {
     222          53 :   Module &DstM = Mover.getModule();
     223          53 :   Comdat::SelectionKind SSK = SrcC->getSelectionKind();
     224          53 :   StringRef ComdatName = SrcC->getName();
     225          53 :   Module::ComdatSymTabType &ComdatSymTab = DstM.getComdatSymbolTable();
     226          53 :   Module::ComdatSymTabType::iterator DstCI = ComdatSymTab.find(ComdatName);
     227             : 
     228          53 :   if (DstCI == ComdatSymTab.end()) {
     229             :     // Use the comdat if it is only available in one of the modules.
     230          34 :     LinkFromSrc = true;
     231          34 :     Result = SSK;
     232          34 :     return false;
     233             :   }
     234             : 
     235          19 :   const Comdat *DstC = &DstCI->second;
     236          19 :   Comdat::SelectionKind DSK = DstC->getSelectionKind();
     237             :   return computeResultingSelectionKind(ComdatName, SSK, DSK, Result,
     238          19 :                                        LinkFromSrc);
     239             : }
     240             : 
     241         167 : bool ModuleLinker::shouldLinkFromSource(bool &LinkFromSrc,
     242             :                                         const GlobalValue &Dest,
     243             :                                         const GlobalValue &Src) {
     244             : 
     245             :   // Should we unconditionally use the Src?
     246         334 :   if (shouldOverrideFromSrc()) {
     247           4 :     LinkFromSrc = true;
     248           4 :     return false;
     249             :   }
     250             : 
     251             :   // We always have to add Src if it has appending linkage.
     252         163 :   if (Src.hasAppendingLinkage()) {
     253          17 :     LinkFromSrc = true;
     254          17 :     return false;
     255             :   }
     256             : 
     257         146 :   bool SrcIsDeclaration = Src.isDeclarationForLinker();
     258         146 :   bool DestIsDeclaration = Dest.isDeclarationForLinker();
     259             : 
     260         146 :   if (SrcIsDeclaration) {
     261             :     // If Src is external or if both Src & Dest are external..  Just link the
     262             :     // external globals, we aren't adding anything.
     263           3 :     if (Src.hasDLLImportStorageClass()) {
     264             :       // If one of GVs is marked as DLLImport, result should be dllimport'ed.
     265           0 :       LinkFromSrc = DestIsDeclaration;
     266           0 :       return false;
     267             :     }
     268             :     // If the Dest is weak, use the source linkage.
     269           3 :     if (Dest.hasExternalWeakLinkage()) {
     270           0 :       LinkFromSrc = true;
     271           0 :       return false;
     272             :     }
     273             :     // Link an available_externally over a declaration.
     274           3 :     LinkFromSrc = !Src.isDeclaration() && Dest.isDeclaration();
     275           3 :     return false;
     276             :   }
     277             : 
     278         143 :   if (DestIsDeclaration) {
     279             :     // If Dest is external but Src is not:
     280          55 :     LinkFromSrc = true;
     281          55 :     return false;
     282             :   }
     283             : 
     284          88 :   if (Src.hasCommonLinkage()) {
     285          17 :     if (Dest.hasLinkOnceLinkage() || Dest.hasWeakLinkage()) {
     286           1 :       LinkFromSrc = true;
     287           1 :       return false;
     288             :     }
     289             : 
     290           8 :     if (!Dest.hasCommonLinkage()) {
     291           0 :       LinkFromSrc = false;
     292           0 :       return false;
     293             :     }
     294             : 
     295           8 :     const DataLayout &DL = Dest.getParent()->getDataLayout();
     296           8 :     uint64_t DestSize = DL.getTypeAllocSize(Dest.getValueType());
     297           8 :     uint64_t SrcSize = DL.getTypeAllocSize(Src.getValueType());
     298           8 :     LinkFromSrc = SrcSize > DestSize;
     299           8 :     return false;
     300             :   }
     301             : 
     302          30 :   if (Src.isWeakForLinker()) {
     303             :     assert(!Dest.hasExternalWeakLinkage());
     304             :     assert(!Dest.hasAvailableExternallyLinkage());
     305             : 
     306          49 :     if (Dest.hasLinkOnceLinkage() && Src.hasWeakLinkage()) {
     307           1 :       LinkFromSrc = true;
     308           1 :       return false;
     309             :     }
     310             : 
     311          48 :     LinkFromSrc = false;
     312          48 :     return false;
     313             :   }
     314             : 
     315           5 :   if (Dest.isWeakForLinker()) {
     316             :     assert(Src.hasExternalLinkage());
     317          25 :     LinkFromSrc = true;
     318          25 :     return false;
     319             :   }
     320             : 
     321             :   assert(!Src.hasExternalWeakLinkage());
     322             :   assert(!Dest.hasExternalWeakLinkage());
     323             :   assert(Dest.hasExternalLinkage() && Src.hasExternalLinkage() &&
     324             :          "Unexpected linkage type!");
     325          20 :   return emitError("Linking globals named '" + Src.getName() +
     326          15 :                    "': symbol multiply defined!");
     327             : }
     328             : 
     329        1340 : bool ModuleLinker::linkIfNeeded(GlobalValue &GV) {
     330        1340 :   GlobalValue *DGV = getLinkedToGlobal(&GV);
     331             : 
     332        2680 :   if (shouldLinkOnlyNeeded()) {
     333             :     // Always import variables with appending linkage.
     334         116 :     if (!GV.hasAppendingLinkage()) {
     335             :       // Don't import globals unless they are referenced by the destination
     336             :       // module.
     337         104 :       if (!DGV)
     338             :         return false;
     339             :       // Don't import globals that are already defined in the destination module
     340          19 :       if (!DGV->isDeclaration())
     341             :         return false;
     342             :     }
     343             :   }
     344             : 
     345        1681 :   if (DGV && !GV.hasLocalLinkage() && !GV.hasAppendingLinkage()) {
     346         196 :     auto *DGVar = dyn_cast<GlobalVariable>(DGV);
     347         196 :     auto *SGVar = dyn_cast<GlobalVariable>(&GV);
     348         196 :     if (DGVar && SGVar) {
     349          71 :       if (DGVar->isDeclaration() && SGVar->isDeclaration() &&
     350           2 :           (!DGVar->isConstant() || !SGVar->isConstant())) {
     351           2 :         DGVar->setConstant(false);
     352             :         SGVar->setConstant(false);
     353             :       }
     354         147 :       if (DGVar->hasCommonLinkage() && SGVar->hasCommonLinkage()) {
     355          32 :         unsigned Align = std::max(DGVar->getAlignment(), SGVar->getAlignment());
     356           8 :         SGVar->setAlignment(Align);
     357           8 :         DGVar->setAlignment(Align);
     358             :       }
     359             :     }
     360             : 
     361             :     GlobalValue::VisibilityTypes Visibility =
     362         588 :         getMinVisibility(DGV->getVisibility(), GV.getVisibility());
     363         196 :     DGV->setVisibility(Visibility);
     364         196 :     GV.setVisibility(Visibility);
     365             : 
     366         392 :     GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::getMinUnnamedAddr(
     367         196 :         DGV->getUnnamedAddr(), GV.getUnnamedAddr());
     368         196 :     DGV->setUnnamedAddr(UnnamedAddr);
     369             :     GV.setUnnamedAddr(UnnamedAddr);
     370             :   }
     371             : 
     372        2297 :   if (!DGV && !shouldOverrideFromSrc() &&
     373        2818 :       (GV.hasLocalLinkage() || GV.hasLinkOnceLinkage() ||
     374         904 :        GV.hasAvailableExternallyLinkage()))
     375             :     return false;
     376             : 
     377        1116 :   if (GV.isDeclaration())
     378             :     return false;
     379             : 
     380         824 :   if (const Comdat *SC = GV.getComdat()) {
     381             :     bool LinkFromSrc;
     382             :     Comdat::SelectionKind SK;
     383         198 :     std::tie(SK, LinkFromSrc) = ComdatsChosen[SC];
     384          66 :     if (!LinkFromSrc)
     385          15 :       return false;
     386             :   }
     387             : 
     388         809 :   bool LinkFromSrc = true;
     389         809 :   if (DGV && shouldLinkFromSource(LinkFromSrc, *DGV, GV))
     390             :     return true;
     391         804 :   if (LinkFromSrc)
     392         751 :     ValuesToLink.insert(&GV);
     393             :   return false;
     394             : }
     395             : 
     396          61 : void ModuleLinker::addLazyFor(GlobalValue &GV, const IRMover::ValueAdder &Add) {
     397             :   // Add these to the internalize list
     398         121 :   if (!GV.hasLinkOnceLinkage() && !GV.hasAvailableExternallyLinkage() &&
     399          28 :       !shouldLinkOnlyNeeded())
     400          59 :     return;
     401             : 
     402         106 :   if (InternalizeCallback)
     403          12 :     Internalize.insert(GV.getName());
     404          53 :   Add(GV);
     405             : 
     406          53 :   const Comdat *SC = GV.getComdat();
     407          53 :   if (!SC)
     408             :     return;
     409          15 :   for (GlobalValue *GV2 : LazyComdatMembers[SC]) {
     410           5 :     GlobalValue *DGV = getLinkedToGlobal(GV2);
     411           5 :     bool LinkFromSrc = true;
     412           5 :     if (DGV && shouldLinkFromSource(LinkFromSrc, *DGV, *GV2))
     413           0 :       return;
     414           6 :     if (!LinkFromSrc)
     415           1 :       continue;
     416           8 :     if (InternalizeCallback)
     417           0 :       Internalize.insert(GV2->getName());
     418           4 :     Add(*GV2);
     419             :   }
     420             : }
     421             : 
     422         461 : void ModuleLinker::dropReplacedComdat(
     423             :     GlobalValue &GV, const DenseSet<const Comdat *> &ReplacedDstComdats) {
     424         461 :   Comdat *C = GV.getComdat();
     425         461 :   if (!C)
     426             :     return;
     427          62 :   if (!ReplacedDstComdats.count(C))
     428             :     return;
     429          16 :   if (GV.use_empty()) {
     430           6 :     GV.eraseFromParent();
     431             :     return;
     432             :   }
     433             : 
     434           2 :   if (auto *F = dyn_cast<Function>(&GV)) {
     435             :     F->deleteBody();
     436           2 :   } else if (auto *Var = dyn_cast<GlobalVariable>(&GV)) {
     437           0 :     Var->setInitializer(nullptr);
     438             :   } else {
     439           2 :     auto &Alias = cast<GlobalAlias>(GV);
     440           2 :     Module &M = *Alias.getParent();
     441           6 :     PointerType &Ty = *cast<PointerType>(Alias.getType());
     442             :     GlobalValue *Declaration;
     443           3 :     if (auto *FTy = dyn_cast<FunctionType>(Alias.getValueType())) {
     444           2 :       Declaration = Function::Create(FTy, GlobalValue::ExternalLinkage, "", &M);
     445             :     } else {
     446           2 :       Declaration =
     447           1 :           new GlobalVariable(M, Ty.getElementType(), /*isConstant*/ false,
     448             :                              GlobalValue::ExternalLinkage,
     449           1 :                              /*Initializer*/ nullptr);
     450             :     }
     451           2 :     Declaration->takeName(&Alias);
     452           2 :     Alias.replaceAllUsesWith(Declaration);
     453           2 :     Alias.eraseFromParent();
     454             :   }
     455             : }
     456             : 
     457         548 : bool ModuleLinker::run() {
     458         548 :   Module &DstM = Mover.getModule();
     459        1096 :   DenseSet<const Comdat *> ReplacedDstComdats;
     460             : 
     461        2841 :   for (const auto &SMEC : SrcM->getComdatSymbolTable()) {
     462          53 :     const Comdat &C = SMEC.getValue();
     463         106 :     if (ComdatsChosen.count(&C))
     464          46 :       continue;
     465             :     Comdat::SelectionKind SK;
     466             :     bool LinkFromSrc;
     467          53 :     if (getComdatResult(&C, SK, LinkFromSrc))
     468           5 :       return true;
     469         144 :     ComdatsChosen[&C] = std::make_pair(SK, LinkFromSrc);
     470             : 
     471          48 :     if (!LinkFromSrc)
     472          12 :       continue;
     473             : 
     474          36 :     Module::ComdatSymTabType &ComdatSymTab = DstM.getComdatSymbolTable();
     475          36 :     Module::ComdatSymTabType::iterator DstCI = ComdatSymTab.find(C.getName());
     476          36 :     if (DstCI == ComdatSymTab.end())
     477          34 :       continue;
     478             : 
     479             :     // The source comdat is replacing the dest one.
     480           2 :     const Comdat *DstC = &DstCI->second;
     481           2 :     ReplacedDstComdats.insert(DstC);
     482             :   }
     483             : 
     484             :   // Alias have to go first, since we are not able to find their comdats
     485             :   // otherwise.
     486        1112 :   for (auto I = DstM.alias_begin(), E = DstM.alias_end(); I != E;) {
     487          78 :     GlobalAlias &GV = *I++;
     488          26 :     dropReplacedComdat(GV, ReplacedDstComdats);
     489             :   }
     490             : 
     491        1252 :   for (auto I = DstM.global_begin(), E = DstM.global_end(); I != E;) {
     492         498 :     GlobalVariable &GV = *I++;
     493         166 :     dropReplacedComdat(GV, ReplacedDstComdats);
     494             :   }
     495             : 
     496        1355 :   for (auto I = DstM.begin(), E = DstM.end(); I != E;) {
     497         807 :     Function &GV = *I++;
     498         269 :     dropReplacedComdat(GV, ReplacedDstComdats);
     499             :   }
     500             : 
     501        2091 :   for (GlobalVariable &GV : SrcM->globals())
     502         924 :     if (GV.hasLinkOnceLinkage())
     503          34 :       if (const Comdat *SC = GV.getComdat())
     504          12 :         LazyComdatMembers[SC].push_back(&GV);
     505             : 
     506        2976 :   for (Function &SF : *SrcM)
     507        1608 :     if (SF.hasLinkOnceLinkage())
     508          35 :       if (const Comdat *SC = SF.getComdat())
     509          24 :         LazyComdatMembers[SC].push_back(&SF);
     510             : 
     511        1704 :   for (GlobalAlias &GA : SrcM->aliases())
     512         150 :     if (GA.hasLinkOnceLinkage())
     513           2 :       if (const Comdat *SC = GA.getComdat())
     514           0 :         LazyComdatMembers[SC].push_back(&GA);
     515             : 
     516             :   // Insert all of the globals in src into the DstM module... without linking
     517             :   // initializers (which could refer to functions not yet mapped over).
     518        2091 :   for (GlobalVariable &GV : SrcM->globals())
     519         462 :     if (linkIfNeeded(GV))
     520             :       return true;
     521             : 
     522        2971 :   for (Function &SF : *SrcM)
     523         803 :     if (linkIfNeeded(SF))
     524             :       return true;
     525             : 
     526        1689 :   for (GlobalAlias &GA : SrcM->aliases())
     527          75 :     if (linkIfNeeded(GA))
     528             :       return true;
     529             : 
     530        3335 :   for (unsigned I = 0; I < ValuesToLink.size(); ++I) {
     531        1506 :     GlobalValue *GV = ValuesToLink[I];
     532         753 :     const Comdat *SC = GV->getComdat();
     533         753 :     if (!SC)
     534         706 :       continue;
     535         240 :     for (GlobalValue *GV2 : LazyComdatMembers[SC]) {
     536           5 :       GlobalValue *DGV = getLinkedToGlobal(GV2);
     537           5 :       bool LinkFromSrc = true;
     538           5 :       if (DGV && shouldLinkFromSource(LinkFromSrc, *DGV, *GV2))
     539           0 :         return true;
     540           5 :       if (LinkFromSrc)
     541           4 :         ValuesToLink.insert(GV2);
     542             :     }
     543             :   }
     544             : 
     545        1076 :   if (InternalizeCallback) {
     546          73 :     for (GlobalValue *GV : ValuesToLink)
     547          96 :       Internalize.insert(GV->getName());
     548             :   }
     549             : 
     550             :   // FIXME: Propagate Errors through to the caller instead of emitting
     551             :   // diagnostics.
     552         538 :   bool HasErrors = false;
     553        1614 :   if (Error E = Mover.move(std::move(SrcM), ValuesToLink.getArrayRef(),
     554          61 :                            [this](GlobalValue &GV, IRMover::ValueAdder Add) {
     555          61 :                              addLazyFor(GV, Add);
     556             :                            },
     557        3766 :                            /* IsPerformingImport */ false)) {
     558          20 :     handleAllErrors(std::move(E), [&](ErrorInfoBase &EIB) {
     559          20 :       DstM.getContext().diagnose(LinkDiagnosticInfo(DS_Error, EIB.message()));
     560           5 :       HasErrors = true;
     561           5 :     });
     562             :   }
     563         538 :   if (HasErrors)
     564             :     return true;
     565             : 
     566        1066 :   if (InternalizeCallback)
     567          25 :     InternalizeCallback(DstM, Internalize);
     568             : 
     569             :   return false;
     570             : }
     571             : 
     572         324 : Linker::Linker(Module &M) : Mover(M) {}
     573             : 
     574         548 : bool Linker::linkInModule(
     575             :     std::unique_ptr<Module> Src, unsigned Flags,
     576             :     std::function<void(Module &, const StringSet<> &)> InternalizeCallback) {
     577         548 :   ModuleLinker ModLinker(Mover, std::move(Src), Flags,
     578        2740 :                          std::move(InternalizeCallback));
     579        1096 :   return ModLinker.run();
     580             : }
     581             : 
     582             : //===----------------------------------------------------------------------===//
     583             : // LinkModules entrypoint.
     584             : //===----------------------------------------------------------------------===//
     585             : 
     586             : /// This function links two modules together, with the resulting Dest module
     587             : /// modified to be the composite of the two input modules. If an error occurs,
     588             : /// true is returned and ErrorMsg (if not null) is set to indicate the problem.
     589             : /// Upon failure, the Dest module could be in a modified state, and shouldn't be
     590             : /// relied on to be consistent.
     591          20 : bool Linker::linkModules(
     592             :     Module &Dest, std::unique_ptr<Module> Src, unsigned Flags,
     593             :     std::function<void(Module &, const StringSet<> &)> InternalizeCallback) {
     594          40 :   Linker L(Dest);
     595         100 :   return L.linkInModule(std::move(Src), Flags, std::move(InternalizeCallback));
     596             : }
     597             : 
     598             : //===----------------------------------------------------------------------===//
     599             : // C API.
     600             : //===----------------------------------------------------------------------===//
     601             : 
     602           2 : LLVMBool LLVMLinkModules2(LLVMModuleRef Dest, LLVMModuleRef Src) {
     603           2 :   Module *D = unwrap(Dest);
     604           6 :   std::unique_ptr<Module> M(unwrap(Src));
     605           8 :   return Linker::linkModules(*D, std::move(M));
     606             : }

Generated by: LCOV version 1.13