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.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