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 "llvm/Linker/Linker.h" 15 #include "llvm-c/Linker.h" 16 #include "llvm/ADT/Hashing.h" 17 #include "llvm/ADT/Optional.h" 18 #include "llvm/ADT/SetVector.h" 19 #include "llvm/ADT/SmallString.h" 20 #include "llvm/ADT/Statistic.h" 21 #include "llvm/ADT/Triple.h" 22 #include "llvm/IR/Constants.h" 23 #include "llvm/IR/DebugInfo.h" 24 #include "llvm/IR/DiagnosticInfo.h" 25 #include "llvm/IR/DiagnosticPrinter.h" 26 #include "llvm/IR/LLVMContext.h" 27 #include "llvm/IR/Module.h" 28 #include "llvm/IR/TypeFinder.h" 29 #include "llvm/Support/CommandLine.h" 30 #include "llvm/Support/Debug.h" 31 #include "llvm/Support/raw_ostream.h" 32 #include "llvm/Transforms/Utils/Cloning.h" 33 #include <cctype> 34 #include <tuple> 35 using namespace llvm; 36 37 38 //===----------------------------------------------------------------------===// 39 // TypeMap implementation. 40 //===----------------------------------------------------------------------===// 41 42 namespace { 43 class TypeMapTy : public ValueMapTypeRemapper { 44 /// This is a mapping from a source type to a destination type to use. 45 DenseMap<Type*, Type*> MappedTypes; 46 47 /// When checking to see if two subgraphs are isomorphic, we speculatively 48 /// add types to MappedTypes, but keep track of them here in case we need to 49 /// roll back. 50 SmallVector<Type*, 16> SpeculativeTypes; 51 52 SmallVector<StructType*, 16> SpeculativeDstOpaqueTypes; 53 54 /// This is a list of non-opaque structs in the source module that are mapped 55 /// to an opaque struct in the destination module. 56 SmallVector<StructType*, 16> SrcDefinitionsToResolve; 57 58 /// This is the set of opaque types in the destination modules who are 59 /// getting a body from the source module. 60 SmallPtrSet<StructType*, 16> DstResolvedOpaqueTypes; 61 62 public: 63 TypeMapTy(Linker::IdentifiedStructTypeSet &DstStructTypesSet) 64 : DstStructTypesSet(DstStructTypesSet) {} 65 66 Linker::IdentifiedStructTypeSet &DstStructTypesSet; 67 /// Indicate that the specified type in the destination module is conceptually 68 /// equivalent to the specified type in the source module. 69 void addTypeMapping(Type *DstTy, Type *SrcTy); 70 71 /// Produce a body for an opaque type in the dest module from a type 72 /// definition in the source module. 73 void linkDefinedTypeBodies(); 74 75 /// Return the mapped type to use for the specified input type from the 76 /// source module. 77 Type *get(Type *SrcTy); 78 Type *get(Type *SrcTy, SmallPtrSet<StructType *, 8> &Visited); 79 80 void finishType(StructType *DTy, StructType *STy, ArrayRef<Type *> ETypes); 81 82 FunctionType *get(FunctionType *T) { 83 return cast<FunctionType>(get((Type *)T)); 84 } 85 86 /// Dump out the type map for debugging purposes. 87 void dump() const { 88 for (auto &Pair : MappedTypes) { 89 dbgs() << "TypeMap: "; 90 Pair.first->print(dbgs()); 91 dbgs() << " => "; 92 Pair.second->print(dbgs()); 93 dbgs() << '\n'; 94 } 95 } 96 97 private: 98 Type *remapType(Type *SrcTy) override { return get(SrcTy); } 99 100 bool areTypesIsomorphic(Type *DstTy, Type *SrcTy); 101 }; 102 } 103 104 void TypeMapTy::addTypeMapping(Type *DstTy, Type *SrcTy) { 105 assert(SpeculativeTypes.empty()); 106 assert(SpeculativeDstOpaqueTypes.empty()); 107 108 // Check to see if these types are recursively isomorphic and establish a 109 // mapping between them if so. 110 if (!areTypesIsomorphic(DstTy, SrcTy)) { 111 // Oops, they aren't isomorphic. Just discard this request by rolling out 112 // any speculative mappings we've established. 113 for (Type *Ty : SpeculativeTypes) 114 MappedTypes.erase(Ty); 115 116 SrcDefinitionsToResolve.resize(SrcDefinitionsToResolve.size() - 117 SpeculativeDstOpaqueTypes.size()); 118 for (StructType *Ty : SpeculativeDstOpaqueTypes) 119 DstResolvedOpaqueTypes.erase(Ty); 120 } else { 121 for (Type *Ty : SpeculativeTypes) 122 if (auto *STy = dyn_cast<StructType>(Ty)) 123 if (STy->hasName()) 124 STy->setName(""); 125 } 126 SpeculativeTypes.clear(); 127 SpeculativeDstOpaqueTypes.clear(); 128 } 129 130 /// Recursively walk this pair of types, returning true if they are isomorphic, 131 /// false if they are not. 132 bool TypeMapTy::areTypesIsomorphic(Type *DstTy, Type *SrcTy) { 133 // Two types with differing kinds are clearly not isomorphic. 134 if (DstTy->getTypeID() != SrcTy->getTypeID()) 135 return false; 136 137 // If we have an entry in the MappedTypes table, then we have our answer. 138 Type *&Entry = MappedTypes[SrcTy]; 139 if (Entry) 140 return Entry == DstTy; 141 142 // Two identical types are clearly isomorphic. Remember this 143 // non-speculatively. 144 if (DstTy == SrcTy) { 145 Entry = DstTy; 146 return true; 147 } 148 149 // Okay, we have two types with identical kinds that we haven't seen before. 150 151 // If this is an opaque struct type, special case it. 152 if (StructType *SSTy = dyn_cast<StructType>(SrcTy)) { 153 // Mapping an opaque type to any struct, just keep the dest struct. 154 if (SSTy->isOpaque()) { 155 Entry = DstTy; 156 SpeculativeTypes.push_back(SrcTy); 157 return true; 158 } 159 160 // Mapping a non-opaque source type to an opaque dest. If this is the first 161 // type that we're mapping onto this destination type then we succeed. Keep 162 // the dest, but fill it in later. If this is the second (different) type 163 // that we're trying to map onto the same opaque type then we fail. 164 if (cast<StructType>(DstTy)->isOpaque()) { 165 // We can only map one source type onto the opaque destination type. 166 if (!DstResolvedOpaqueTypes.insert(cast<StructType>(DstTy)).second) 167 return false; 168 SrcDefinitionsToResolve.push_back(SSTy); 169 SpeculativeTypes.push_back(SrcTy); 170 SpeculativeDstOpaqueTypes.push_back(cast<StructType>(DstTy)); 171 Entry = DstTy; 172 return true; 173 } 174 } 175 176 // If the number of subtypes disagree between the two types, then we fail. 177 if (SrcTy->getNumContainedTypes() != DstTy->getNumContainedTypes()) 178 return false; 179 180 // Fail if any of the extra properties (e.g. array size) of the type disagree. 181 if (isa<IntegerType>(DstTy)) 182 return false; // bitwidth disagrees. 183 if (PointerType *PT = dyn_cast<PointerType>(DstTy)) { 184 if (PT->getAddressSpace() != cast<PointerType>(SrcTy)->getAddressSpace()) 185 return false; 186 187 } else if (FunctionType *FT = dyn_cast<FunctionType>(DstTy)) { 188 if (FT->isVarArg() != cast<FunctionType>(SrcTy)->isVarArg()) 189 return false; 190 } else if (StructType *DSTy = dyn_cast<StructType>(DstTy)) { 191 StructType *SSTy = cast<StructType>(SrcTy); 192 if (DSTy->isLiteral() != SSTy->isLiteral() || 193 DSTy->isPacked() != SSTy->isPacked()) 194 return false; 195 } else if (ArrayType *DATy = dyn_cast<ArrayType>(DstTy)) { 196 if (DATy->getNumElements() != cast<ArrayType>(SrcTy)->getNumElements()) 197 return false; 198 } else if (VectorType *DVTy = dyn_cast<VectorType>(DstTy)) { 199 if (DVTy->getNumElements() != cast<VectorType>(SrcTy)->getNumElements()) 200 return false; 201 } 202 203 // Otherwise, we speculate that these two types will line up and recursively 204 // check the subelements. 205 Entry = DstTy; 206 SpeculativeTypes.push_back(SrcTy); 207 208 for (unsigned I = 0, E = SrcTy->getNumContainedTypes(); I != E; ++I) 209 if (!areTypesIsomorphic(DstTy->getContainedType(I), 210 SrcTy->getContainedType(I))) 211 return false; 212 213 // If everything seems to have lined up, then everything is great. 214 return true; 215 } 216 217 void TypeMapTy::linkDefinedTypeBodies() { 218 SmallVector<Type*, 16> Elements; 219 for (StructType *SrcSTy : SrcDefinitionsToResolve) { 220 StructType *DstSTy = cast<StructType>(MappedTypes[SrcSTy]); 221 assert(DstSTy->isOpaque()); 222 223 // Map the body of the source type over to a new body for the dest type. 224 Elements.resize(SrcSTy->getNumElements()); 225 for (unsigned I = 0, E = Elements.size(); I != E; ++I) 226 Elements[I] = get(SrcSTy->getElementType(I)); 227 228 DstSTy->setBody(Elements, SrcSTy->isPacked()); 229 DstStructTypesSet.switchToNonOpaque(DstSTy); 230 } 231 SrcDefinitionsToResolve.clear(); 232 DstResolvedOpaqueTypes.clear(); 233 } 234 235 void TypeMapTy::finishType(StructType *DTy, StructType *STy, 236 ArrayRef<Type *> ETypes) { 237 DTy->setBody(ETypes, STy->isPacked()); 238 239 // Steal STy's name. 240 if (STy->hasName()) { 241 SmallString<16> TmpName = STy->getName(); 242 STy->setName(""); 243 DTy->setName(TmpName); 244 } 245 246 DstStructTypesSet.addNonOpaque(DTy); 247 } 248 249 Type *TypeMapTy::get(Type *Ty) { 250 SmallPtrSet<StructType *, 8> Visited; 251 return get(Ty, Visited); 252 } 253 254 Type *TypeMapTy::get(Type *Ty, SmallPtrSet<StructType *, 8> &Visited) { 255 // If we already have an entry for this type, return it. 256 Type **Entry = &MappedTypes[Ty]; 257 if (*Entry) 258 return *Entry; 259 260 // These are types that LLVM itself will unique. 261 bool IsUniqued = !isa<StructType>(Ty) || cast<StructType>(Ty)->isLiteral(); 262 263 #ifndef NDEBUG 264 if (!IsUniqued) { 265 for (auto &Pair : MappedTypes) { 266 assert(!(Pair.first != Ty && Pair.second == Ty) && 267 "mapping to a source type"); 268 } 269 } 270 #endif 271 272 if (!IsUniqued && !Visited.insert(cast<StructType>(Ty)).second) { 273 StructType *DTy = StructType::create(Ty->getContext()); 274 return *Entry = DTy; 275 } 276 277 // If this is not a recursive type, then just map all of the elements and 278 // then rebuild the type from inside out. 279 SmallVector<Type *, 4> ElementTypes; 280 281 // If there are no element types to map, then the type is itself. This is 282 // true for the anonymous {} struct, things like 'float', integers, etc. 283 if (Ty->getNumContainedTypes() == 0 && IsUniqued) 284 return *Entry = Ty; 285 286 // Remap all of the elements, keeping track of whether any of them change. 287 bool AnyChange = false; 288 ElementTypes.resize(Ty->getNumContainedTypes()); 289 for (unsigned I = 0, E = Ty->getNumContainedTypes(); I != E; ++I) { 290 ElementTypes[I] = get(Ty->getContainedType(I), Visited); 291 AnyChange |= ElementTypes[I] != Ty->getContainedType(I); 292 } 293 294 // If we found our type while recursively processing stuff, just use it. 295 Entry = &MappedTypes[Ty]; 296 if (*Entry) { 297 if (auto *DTy = dyn_cast<StructType>(*Entry)) { 298 if (DTy->isOpaque()) { 299 auto *STy = cast<StructType>(Ty); 300 finishType(DTy, STy, ElementTypes); 301 } 302 } 303 return *Entry; 304 } 305 306 // If all of the element types mapped directly over and the type is not 307 // a nomed struct, then the type is usable as-is. 308 if (!AnyChange && IsUniqued) 309 return *Entry = Ty; 310 311 // Otherwise, rebuild a modified type. 312 switch (Ty->getTypeID()) { 313 default: 314 llvm_unreachable("unknown derived type to remap"); 315 case Type::ArrayTyID: 316 return *Entry = ArrayType::get(ElementTypes[0], 317 cast<ArrayType>(Ty)->getNumElements()); 318 case Type::VectorTyID: 319 return *Entry = VectorType::get(ElementTypes[0], 320 cast<VectorType>(Ty)->getNumElements()); 321 case Type::PointerTyID: 322 return *Entry = PointerType::get(ElementTypes[0], 323 cast<PointerType>(Ty)->getAddressSpace()); 324 case Type::FunctionTyID: 325 return *Entry = FunctionType::get(ElementTypes[0], 326 makeArrayRef(ElementTypes).slice(1), 327 cast<FunctionType>(Ty)->isVarArg()); 328 case Type::StructTyID: { 329 auto *STy = cast<StructType>(Ty); 330 bool IsPacked = STy->isPacked(); 331 if (IsUniqued) 332 return *Entry = StructType::get(Ty->getContext(), ElementTypes, IsPacked); 333 334 // If the type is opaque, we can just use it directly. 335 if (STy->isOpaque()) { 336 DstStructTypesSet.addOpaque(STy); 337 return *Entry = Ty; 338 } 339 340 if (StructType *OldT = 341 DstStructTypesSet.findNonOpaque(ElementTypes, IsPacked)) { 342 STy->setName(""); 343 return *Entry = OldT; 344 } 345 346 if (!AnyChange) { 347 DstStructTypesSet.addNonOpaque(STy); 348 return *Entry = Ty; 349 } 350 351 StructType *DTy = StructType::create(Ty->getContext()); 352 finishType(DTy, STy, ElementTypes); 353 return *Entry = DTy; 354 } 355 } 356 } 357 358 //===----------------------------------------------------------------------===// 359 // ModuleLinker implementation. 360 //===----------------------------------------------------------------------===// 361 362 namespace { 363 class ModuleLinker; 364 365 /// Creates prototypes for functions that are lazily linked on the fly. This 366 /// speeds up linking for modules with many/ lazily linked functions of which 367 /// few get used. 368 class ValueMaterializerTy : public ValueMaterializer { 369 TypeMapTy &TypeMap; 370 Module *DstM; 371 std::vector<GlobalValue *> &LazilyLinkGlobalValues; 372 373 public: 374 ValueMaterializerTy(TypeMapTy &TypeMap, Module *DstM, 375 std::vector<GlobalValue *> &LazilyLinkGlobalValues) 376 : ValueMaterializer(), TypeMap(TypeMap), DstM(DstM), 377 LazilyLinkGlobalValues(LazilyLinkGlobalValues) {} 378 379 Value *materializeValueFor(Value *V) override; 380 }; 381 382 class LinkDiagnosticInfo : public DiagnosticInfo { 383 const Twine &Msg; 384 385 public: 386 LinkDiagnosticInfo(DiagnosticSeverity Severity, const Twine &Msg); 387 void print(DiagnosticPrinter &DP) const override; 388 }; 389 LinkDiagnosticInfo::LinkDiagnosticInfo(DiagnosticSeverity Severity, 390 const Twine &Msg) 391 : DiagnosticInfo(DK_Linker, Severity), Msg(Msg) {} 392 void LinkDiagnosticInfo::print(DiagnosticPrinter &DP) const { DP << Msg; } 393 394 /// This is an implementation class for the LinkModules function, which is the 395 /// entrypoint for this file. 396 class ModuleLinker { 397 Module *DstM, *SrcM; 398 399 TypeMapTy TypeMap; 400 ValueMaterializerTy ValMaterializer; 401 402 /// Mapping of values from what they used to be in Src, to what they are now 403 /// in DstM. ValueToValueMapTy is a ValueMap, which involves some overhead 404 /// due to the use of Value handles which the Linker doesn't actually need, 405 /// but this allows us to reuse the ValueMapper code. 406 ValueToValueMapTy ValueMap; 407 408 struct AppendingVarInfo { 409 GlobalVariable *NewGV; // New aggregate global in dest module. 410 const Constant *DstInit; // Old initializer from dest module. 411 const Constant *SrcInit; // Old initializer from src module. 412 }; 413 414 std::vector<AppendingVarInfo> AppendingVars; 415 416 // Set of items not to link in from source. 417 SmallPtrSet<const Value *, 16> DoNotLinkFromSource; 418 419 // Vector of GlobalValues to lazily link in. 420 std::vector<GlobalValue *> LazilyLinkGlobalValues; 421 422 /// Functions that have replaced other functions. 423 SmallPtrSet<const Function *, 16> OverridingFunctions; 424 425 DiagnosticHandlerFunction DiagnosticHandler; 426 427 public: 428 ModuleLinker(Module *dstM, Linker::IdentifiedStructTypeSet &Set, Module *srcM, 429 DiagnosticHandlerFunction DiagnosticHandler) 430 : DstM(dstM), SrcM(srcM), TypeMap(Set), 431 ValMaterializer(TypeMap, DstM, LazilyLinkGlobalValues), 432 DiagnosticHandler(DiagnosticHandler) {} 433 434 bool run(); 435 436 private: 437 bool shouldLinkFromSource(bool &LinkFromSrc, const GlobalValue &Dest, 438 const GlobalValue &Src); 439 440 /// Helper method for setting a message and returning an error code. 441 bool emitError(const Twine &Message) { 442 DiagnosticHandler(LinkDiagnosticInfo(DS_Error, Message)); 443 return true; 444 } 445 446 void emitWarning(const Twine &Message) { 447 DiagnosticHandler(LinkDiagnosticInfo(DS_Warning, Message)); 448 } 449 450 bool getComdatLeader(Module *M, StringRef ComdatName, 451 const GlobalVariable *&GVar); 452 bool computeResultingSelectionKind(StringRef ComdatName, 453 Comdat::SelectionKind Src, 454 Comdat::SelectionKind Dst, 455 Comdat::SelectionKind &Result, 456 bool &LinkFromSrc); 457 std::map<const Comdat *, std::pair<Comdat::SelectionKind, bool>> 458 ComdatsChosen; 459 bool getComdatResult(const Comdat *SrcC, Comdat::SelectionKind &SK, 460 bool &LinkFromSrc); 461 462 /// Given a global in the source module, return the global in the 463 /// destination module that is being linked to, if any. 464 GlobalValue *getLinkedToGlobal(const GlobalValue *SrcGV) { 465 // If the source has no name it can't link. If it has local linkage, 466 // there is no name match-up going on. 467 if (!SrcGV->hasName() || SrcGV->hasLocalLinkage()) 468 return nullptr; 469 470 // Otherwise see if we have a match in the destination module's symtab. 471 GlobalValue *DGV = DstM->getNamedValue(SrcGV->getName()); 472 if (!DGV) 473 return nullptr; 474 475 // If we found a global with the same name in the dest module, but it has 476 // internal linkage, we are really not doing any linkage here. 477 if (DGV->hasLocalLinkage()) 478 return nullptr; 479 480 // Otherwise, we do in fact link to the destination global. 481 return DGV; 482 } 483 484 void computeTypeMapping(); 485 486 void upgradeMismatchedGlobalArray(StringRef Name); 487 void upgradeMismatchedGlobals(); 488 489 bool linkAppendingVarProto(GlobalVariable *DstGV, 490 const GlobalVariable *SrcGV); 491 492 bool linkGlobalValueProto(GlobalValue *GV); 493 bool linkModuleFlagsMetadata(); 494 495 void linkAppendingVarInit(const AppendingVarInfo &AVI); 496 497 void linkGlobalInit(GlobalVariable &Dst, GlobalVariable &Src); 498 bool linkFunctionBody(Function &Dst, Function &Src); 499 void linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src); 500 bool linkGlobalValueBody(GlobalValue &Src); 501 502 void linkNamedMDNodes(); 503 void stripReplacedSubprograms(); 504 }; 505 } 506 507 /// The LLVM SymbolTable class autorenames globals that conflict in the symbol 508 /// table. This is good for all clients except for us. Go through the trouble 509 /// to force this back. 510 static void forceRenaming(GlobalValue *GV, StringRef Name) { 511 // If the global doesn't force its name or if it already has the right name, 512 // there is nothing for us to do. 513 if (GV->hasLocalLinkage() || GV->getName() == Name) 514 return; 515 516 Module *M = GV->getParent(); 517 518 // If there is a conflict, rename the conflict. 519 if (GlobalValue *ConflictGV = M->getNamedValue(Name)) { 520 GV->takeName(ConflictGV); 521 ConflictGV->setName(Name); // This will cause ConflictGV to get renamed 522 assert(ConflictGV->getName() != Name && "forceRenaming didn't work"); 523 } else { 524 GV->setName(Name); // Force the name back 525 } 526 } 527 528 /// copy additional attributes (those not needed to construct a GlobalValue) 529 /// from the SrcGV to the DestGV. 530 static void copyGVAttributes(GlobalValue *DestGV, const GlobalValue *SrcGV) { 531 DestGV->copyAttributesFrom(SrcGV); 532 forceRenaming(DestGV, SrcGV->getName()); 533 } 534 535 static bool isLessConstraining(GlobalValue::VisibilityTypes a, 536 GlobalValue::VisibilityTypes b) { 537 if (a == GlobalValue::HiddenVisibility) 538 return false; 539 if (b == GlobalValue::HiddenVisibility) 540 return true; 541 if (a == GlobalValue::ProtectedVisibility) 542 return false; 543 if (b == GlobalValue::ProtectedVisibility) 544 return true; 545 return false; 546 } 547 548 /// Loop through the global variables in the src module and merge them into the 549 /// dest module. 550 static GlobalVariable *copyGlobalVariableProto(TypeMapTy &TypeMap, Module &DstM, 551 const GlobalVariable *SGVar) { 552 // No linking to be performed or linking from the source: simply create an 553 // identical version of the symbol over in the dest module... the 554 // initializer will be filled in later by LinkGlobalInits. 555 GlobalVariable *NewDGV = new GlobalVariable( 556 DstM, TypeMap.get(SGVar->getType()->getElementType()), 557 SGVar->isConstant(), SGVar->getLinkage(), /*init*/ nullptr, 558 SGVar->getName(), /*insertbefore*/ nullptr, SGVar->getThreadLocalMode(), 559 SGVar->getType()->getAddressSpace()); 560 561 return NewDGV; 562 } 563 564 /// Link the function in the source module into the destination module if 565 /// needed, setting up mapping information. 566 static Function *copyFunctionProto(TypeMapTy &TypeMap, Module &DstM, 567 const Function *SF) { 568 // If there is no linkage to be performed or we are linking from the source, 569 // bring SF over. 570 return Function::Create(TypeMap.get(SF->getFunctionType()), SF->getLinkage(), 571 SF->getName(), &DstM); 572 } 573 574 /// Set up prototypes for any aliases that come over from the source module. 575 static GlobalAlias *copyGlobalAliasProto(TypeMapTy &TypeMap, Module &DstM, 576 const GlobalAlias *SGA) { 577 // If there is no linkage to be performed or we're linking from the source, 578 // bring over SGA. 579 auto *PTy = cast<PointerType>(TypeMap.get(SGA->getType())); 580 return GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(), 581 SGA->getLinkage(), SGA->getName(), &DstM); 582 } 583 584 static GlobalValue *copyGlobalValueProto(TypeMapTy &TypeMap, Module &DstM, 585 const GlobalValue *SGV) { 586 GlobalValue *NewGV; 587 if (auto *SGVar = dyn_cast<GlobalVariable>(SGV)) 588 NewGV = copyGlobalVariableProto(TypeMap, DstM, SGVar); 589 else if (auto *SF = dyn_cast<Function>(SGV)) 590 NewGV = copyFunctionProto(TypeMap, DstM, SF); 591 else 592 NewGV = copyGlobalAliasProto(TypeMap, DstM, cast<GlobalAlias>(SGV)); 593 copyGVAttributes(NewGV, SGV); 594 return NewGV; 595 } 596 597 Value *ValueMaterializerTy::materializeValueFor(Value *V) { 598 auto *SGV = dyn_cast<GlobalValue>(V); 599 if (!SGV) 600 return nullptr; 601 602 GlobalValue *DGV = copyGlobalValueProto(TypeMap, *DstM, SGV); 603 604 if (Comdat *SC = SGV->getComdat()) { 605 if (auto *DGO = dyn_cast<GlobalObject>(DGV)) { 606 Comdat *DC = DstM->getOrInsertComdat(SC->getName()); 607 DGO->setComdat(DC); 608 } 609 } 610 611 LazilyLinkGlobalValues.push_back(SGV); 612 return DGV; 613 } 614 615 bool ModuleLinker::getComdatLeader(Module *M, StringRef ComdatName, 616 const GlobalVariable *&GVar) { 617 const GlobalValue *GVal = M->getNamedValue(ComdatName); 618 if (const auto *GA = dyn_cast_or_null<GlobalAlias>(GVal)) { 619 GVal = GA->getBaseObject(); 620 if (!GVal) 621 // We cannot resolve the size of the aliasee yet. 622 return emitError("Linking COMDATs named '" + ComdatName + 623 "': COMDAT key involves incomputable alias size."); 624 } 625 626 GVar = dyn_cast_or_null<GlobalVariable>(GVal); 627 if (!GVar) 628 return emitError( 629 "Linking COMDATs named '" + ComdatName + 630 "': GlobalVariable required for data dependent selection!"); 631 632 return false; 633 } 634 635 bool ModuleLinker::computeResultingSelectionKind(StringRef ComdatName, 636 Comdat::SelectionKind Src, 637 Comdat::SelectionKind Dst, 638 Comdat::SelectionKind &Result, 639 bool &LinkFromSrc) { 640 // The ability to mix Comdat::SelectionKind::Any with 641 // Comdat::SelectionKind::Largest is a behavior that comes from COFF. 642 bool DstAnyOrLargest = Dst == Comdat::SelectionKind::Any || 643 Dst == Comdat::SelectionKind::Largest; 644 bool SrcAnyOrLargest = Src == Comdat::SelectionKind::Any || 645 Src == Comdat::SelectionKind::Largest; 646 if (DstAnyOrLargest && SrcAnyOrLargest) { 647 if (Dst == Comdat::SelectionKind::Largest || 648 Src == Comdat::SelectionKind::Largest) 649 Result = Comdat::SelectionKind::Largest; 650 else 651 Result = Comdat::SelectionKind::Any; 652 } else if (Src == Dst) { 653 Result = Dst; 654 } else { 655 return emitError("Linking COMDATs named '" + ComdatName + 656 "': invalid selection kinds!"); 657 } 658 659 switch (Result) { 660 case Comdat::SelectionKind::Any: 661 // Go with Dst. 662 LinkFromSrc = false; 663 break; 664 case Comdat::SelectionKind::NoDuplicates: 665 return emitError("Linking COMDATs named '" + ComdatName + 666 "': noduplicates has been violated!"); 667 case Comdat::SelectionKind::ExactMatch: 668 case Comdat::SelectionKind::Largest: 669 case Comdat::SelectionKind::SameSize: { 670 const GlobalVariable *DstGV; 671 const GlobalVariable *SrcGV; 672 if (getComdatLeader(DstM, ComdatName, DstGV) || 673 getComdatLeader(SrcM, ComdatName, SrcGV)) 674 return true; 675 676 const DataLayout &DstDL = DstM->getDataLayout(); 677 const DataLayout &SrcDL = SrcM->getDataLayout(); 678 uint64_t DstSize = 679 DstDL.getTypeAllocSize(DstGV->getType()->getPointerElementType()); 680 uint64_t SrcSize = 681 SrcDL.getTypeAllocSize(SrcGV->getType()->getPointerElementType()); 682 if (Result == Comdat::SelectionKind::ExactMatch) { 683 if (SrcGV->getInitializer() != DstGV->getInitializer()) 684 return emitError("Linking COMDATs named '" + ComdatName + 685 "': ExactMatch violated!"); 686 LinkFromSrc = false; 687 } else if (Result == Comdat::SelectionKind::Largest) { 688 LinkFromSrc = SrcSize > DstSize; 689 } else if (Result == Comdat::SelectionKind::SameSize) { 690 if (SrcSize != DstSize) 691 return emitError("Linking COMDATs named '" + ComdatName + 692 "': SameSize violated!"); 693 LinkFromSrc = false; 694 } else { 695 llvm_unreachable("unknown selection kind"); 696 } 697 break; 698 } 699 } 700 701 return false; 702 } 703 704 bool ModuleLinker::getComdatResult(const Comdat *SrcC, 705 Comdat::SelectionKind &Result, 706 bool &LinkFromSrc) { 707 Comdat::SelectionKind SSK = SrcC->getSelectionKind(); 708 StringRef ComdatName = SrcC->getName(); 709 Module::ComdatSymTabType &ComdatSymTab = DstM->getComdatSymbolTable(); 710 Module::ComdatSymTabType::iterator DstCI = ComdatSymTab.find(ComdatName); 711 712 if (DstCI == ComdatSymTab.end()) { 713 // Use the comdat if it is only available in one of the modules. 714 LinkFromSrc = true; 715 Result = SSK; 716 return false; 717 } 718 719 const Comdat *DstC = &DstCI->second; 720 Comdat::SelectionKind DSK = DstC->getSelectionKind(); 721 return computeResultingSelectionKind(ComdatName, SSK, DSK, Result, 722 LinkFromSrc); 723 } 724 725 bool ModuleLinker::shouldLinkFromSource(bool &LinkFromSrc, 726 const GlobalValue &Dest, 727 const GlobalValue &Src) { 728 // We always have to add Src if it has appending linkage. 729 if (Src.hasAppendingLinkage()) { 730 LinkFromSrc = true; 731 return false; 732 } 733 734 bool SrcIsDeclaration = Src.isDeclarationForLinker(); 735 bool DestIsDeclaration = Dest.isDeclarationForLinker(); 736 737 if (SrcIsDeclaration) { 738 // If Src is external or if both Src & Dest are external.. Just link the 739 // external globals, we aren't adding anything. 740 if (Src.hasDLLImportStorageClass()) { 741 // If one of GVs is marked as DLLImport, result should be dllimport'ed. 742 LinkFromSrc = DestIsDeclaration; 743 return false; 744 } 745 // If the Dest is weak, use the source linkage. 746 LinkFromSrc = Dest.hasExternalWeakLinkage(); 747 return false; 748 } 749 750 if (DestIsDeclaration) { 751 // If Dest is external but Src is not: 752 LinkFromSrc = true; 753 return false; 754 } 755 756 if (Src.hasCommonLinkage()) { 757 if (Dest.hasLinkOnceLinkage() || Dest.hasWeakLinkage()) { 758 LinkFromSrc = true; 759 return false; 760 } 761 762 if (!Dest.hasCommonLinkage()) { 763 LinkFromSrc = false; 764 return false; 765 } 766 767 const DataLayout &DL = Dest.getParent()->getDataLayout(); 768 uint64_t DestSize = DL.getTypeAllocSize(Dest.getType()->getElementType()); 769 uint64_t SrcSize = DL.getTypeAllocSize(Src.getType()->getElementType()); 770 LinkFromSrc = SrcSize > DestSize; 771 return false; 772 } 773 774 if (Src.isWeakForLinker()) { 775 assert(!Dest.hasExternalWeakLinkage()); 776 assert(!Dest.hasAvailableExternallyLinkage()); 777 778 if (Dest.hasLinkOnceLinkage() && Src.hasWeakLinkage()) { 779 LinkFromSrc = true; 780 return false; 781 } 782 783 LinkFromSrc = false; 784 return false; 785 } 786 787 if (Dest.isWeakForLinker()) { 788 assert(Src.hasExternalLinkage()); 789 LinkFromSrc = true; 790 return false; 791 } 792 793 assert(!Src.hasExternalWeakLinkage()); 794 assert(!Dest.hasExternalWeakLinkage()); 795 assert(Dest.hasExternalLinkage() && Src.hasExternalLinkage() && 796 "Unexpected linkage type!"); 797 return emitError("Linking globals named '" + Src.getName() + 798 "': symbol multiply defined!"); 799 } 800 801 /// Loop over all of the linked values to compute type mappings. For example, 802 /// if we link "extern Foo *x" and "Foo *x = NULL", then we have two struct 803 /// types 'Foo' but one got renamed when the module was loaded into the same 804 /// LLVMContext. 805 void ModuleLinker::computeTypeMapping() { 806 for (GlobalValue &SGV : SrcM->globals()) { 807 GlobalValue *DGV = getLinkedToGlobal(&SGV); 808 if (!DGV) 809 continue; 810 811 if (!DGV->hasAppendingLinkage() || !SGV.hasAppendingLinkage()) { 812 TypeMap.addTypeMapping(DGV->getType(), SGV.getType()); 813 continue; 814 } 815 816 // Unify the element type of appending arrays. 817 ArrayType *DAT = cast<ArrayType>(DGV->getType()->getElementType()); 818 ArrayType *SAT = cast<ArrayType>(SGV.getType()->getElementType()); 819 TypeMap.addTypeMapping(DAT->getElementType(), SAT->getElementType()); 820 } 821 822 for (GlobalValue &SGV : *SrcM) { 823 if (GlobalValue *DGV = getLinkedToGlobal(&SGV)) 824 TypeMap.addTypeMapping(DGV->getType(), SGV.getType()); 825 } 826 827 for (GlobalValue &SGV : SrcM->aliases()) { 828 if (GlobalValue *DGV = getLinkedToGlobal(&SGV)) 829 TypeMap.addTypeMapping(DGV->getType(), SGV.getType()); 830 } 831 832 // Incorporate types by name, scanning all the types in the source module. 833 // At this point, the destination module may have a type "%foo = { i32 }" for 834 // example. When the source module got loaded into the same LLVMContext, if 835 // it had the same type, it would have been renamed to "%foo.42 = { i32 }". 836 std::vector<StructType *> Types = SrcM->getIdentifiedStructTypes(); 837 for (StructType *ST : Types) { 838 if (!ST->hasName()) 839 continue; 840 841 // Check to see if there is a dot in the name followed by a digit. 842 size_t DotPos = ST->getName().rfind('.'); 843 if (DotPos == 0 || DotPos == StringRef::npos || 844 ST->getName().back() == '.' || 845 !isdigit(static_cast<unsigned char>(ST->getName()[DotPos + 1]))) 846 continue; 847 848 // Check to see if the destination module has a struct with the prefix name. 849 StructType *DST = DstM->getTypeByName(ST->getName().substr(0, DotPos)); 850 if (!DST) 851 continue; 852 853 // Don't use it if this actually came from the source module. They're in 854 // the same LLVMContext after all. Also don't use it unless the type is 855 // actually used in the destination module. This can happen in situations 856 // like this: 857 // 858 // Module A Module B 859 // -------- -------- 860 // %Z = type { %A } %B = type { %C.1 } 861 // %A = type { %B.1, [7 x i8] } %C.1 = type { i8* } 862 // %B.1 = type { %C } %A.2 = type { %B.3, [5 x i8] } 863 // %C = type { i8* } %B.3 = type { %C.1 } 864 // 865 // When we link Module B with Module A, the '%B' in Module B is 866 // used. However, that would then use '%C.1'. But when we process '%C.1', 867 // we prefer to take the '%C' version. So we are then left with both 868 // '%C.1' and '%C' being used for the same types. This leads to some 869 // variables using one type and some using the other. 870 if (TypeMap.DstStructTypesSet.hasType(DST)) 871 TypeMap.addTypeMapping(DST, ST); 872 } 873 874 // Now that we have discovered all of the type equivalences, get a body for 875 // any 'opaque' types in the dest module that are now resolved. 876 TypeMap.linkDefinedTypeBodies(); 877 } 878 879 static void upgradeGlobalArray(GlobalVariable *GV) { 880 ArrayType *ATy = cast<ArrayType>(GV->getType()->getElementType()); 881 StructType *OldTy = cast<StructType>(ATy->getElementType()); 882 assert(OldTy->getNumElements() == 2 && "Expected to upgrade from 2 elements"); 883 884 // Get the upgraded 3 element type. 885 PointerType *VoidPtrTy = Type::getInt8Ty(GV->getContext())->getPointerTo(); 886 Type *Tys[3] = {OldTy->getElementType(0), OldTy->getElementType(1), 887 VoidPtrTy}; 888 StructType *NewTy = StructType::get(GV->getContext(), Tys, false); 889 890 // Build new constants with a null third field filled in. 891 Constant *OldInitC = GV->getInitializer(); 892 ConstantArray *OldInit = dyn_cast<ConstantArray>(OldInitC); 893 if (!OldInit && !isa<ConstantAggregateZero>(OldInitC)) 894 // Invalid initializer; give up. 895 return; 896 std::vector<Constant *> Initializers; 897 if (OldInit && OldInit->getNumOperands()) { 898 Value *Null = Constant::getNullValue(VoidPtrTy); 899 for (Use &U : OldInit->operands()) { 900 ConstantStruct *Init = cast<ConstantStruct>(U.get()); 901 Initializers.push_back(ConstantStruct::get( 902 NewTy, Init->getOperand(0), Init->getOperand(1), Null, nullptr)); 903 } 904 } 905 assert(Initializers.size() == ATy->getNumElements() && 906 "Failed to copy all array elements"); 907 908 // Replace the old GV with a new one. 909 ATy = ArrayType::get(NewTy, Initializers.size()); 910 Constant *NewInit = ConstantArray::get(ATy, Initializers); 911 GlobalVariable *NewGV = new GlobalVariable( 912 *GV->getParent(), ATy, GV->isConstant(), GV->getLinkage(), NewInit, "", 913 GV, GV->getThreadLocalMode(), GV->getType()->getAddressSpace(), 914 GV->isExternallyInitialized()); 915 NewGV->copyAttributesFrom(GV); 916 NewGV->takeName(GV); 917 assert(GV->use_empty() && "program cannot use initializer list"); 918 GV->eraseFromParent(); 919 } 920 921 void ModuleLinker::upgradeMismatchedGlobalArray(StringRef Name) { 922 // Look for the global arrays. 923 auto *DstGV = dyn_cast_or_null<GlobalVariable>(DstM->getNamedValue(Name)); 924 if (!DstGV) 925 return; 926 auto *SrcGV = dyn_cast_or_null<GlobalVariable>(SrcM->getNamedValue(Name)); 927 if (!SrcGV) 928 return; 929 930 // Check if the types already match. 931 auto *DstTy = cast<ArrayType>(DstGV->getType()->getElementType()); 932 auto *SrcTy = 933 cast<ArrayType>(TypeMap.get(SrcGV->getType()->getElementType())); 934 if (DstTy == SrcTy) 935 return; 936 937 // Grab the element types. We can only upgrade an array of a two-field 938 // struct. Only bother if the other one has three-fields. 939 auto *DstEltTy = cast<StructType>(DstTy->getElementType()); 940 auto *SrcEltTy = cast<StructType>(SrcTy->getElementType()); 941 if (DstEltTy->getNumElements() == 2 && SrcEltTy->getNumElements() == 3) { 942 upgradeGlobalArray(DstGV); 943 return; 944 } 945 if (DstEltTy->getNumElements() == 3 && SrcEltTy->getNumElements() == 2) 946 upgradeGlobalArray(SrcGV); 947 948 // We can't upgrade any other differences. 949 } 950 951 void ModuleLinker::upgradeMismatchedGlobals() { 952 upgradeMismatchedGlobalArray("llvm.global_ctors"); 953 upgradeMismatchedGlobalArray("llvm.global_dtors"); 954 } 955 956 /// If there were any appending global variables, link them together now. 957 /// Return true on error. 958 bool ModuleLinker::linkAppendingVarProto(GlobalVariable *DstGV, 959 const GlobalVariable *SrcGV) { 960 961 if (!SrcGV->hasAppendingLinkage() || !DstGV->hasAppendingLinkage()) 962 return emitError("Linking globals named '" + SrcGV->getName() + 963 "': can only link appending global with another appending global!"); 964 965 ArrayType *DstTy = cast<ArrayType>(DstGV->getType()->getElementType()); 966 ArrayType *SrcTy = 967 cast<ArrayType>(TypeMap.get(SrcGV->getType()->getElementType())); 968 Type *EltTy = DstTy->getElementType(); 969 970 // Check to see that they two arrays agree on type. 971 if (EltTy != SrcTy->getElementType()) 972 return emitError("Appending variables with different element types!"); 973 if (DstGV->isConstant() != SrcGV->isConstant()) 974 return emitError("Appending variables linked with different const'ness!"); 975 976 if (DstGV->getAlignment() != SrcGV->getAlignment()) 977 return emitError( 978 "Appending variables with different alignment need to be linked!"); 979 980 if (DstGV->getVisibility() != SrcGV->getVisibility()) 981 return emitError( 982 "Appending variables with different visibility need to be linked!"); 983 984 if (DstGV->hasUnnamedAddr() != SrcGV->hasUnnamedAddr()) 985 return emitError( 986 "Appending variables with different unnamed_addr need to be linked!"); 987 988 if (StringRef(DstGV->getSection()) != SrcGV->getSection()) 989 return emitError( 990 "Appending variables with different section name need to be linked!"); 991 992 uint64_t NewSize = DstTy->getNumElements() + SrcTy->getNumElements(); 993 ArrayType *NewType = ArrayType::get(EltTy, NewSize); 994 995 // Create the new global variable. 996 GlobalVariable *NG = 997 new GlobalVariable(*DstGV->getParent(), NewType, SrcGV->isConstant(), 998 DstGV->getLinkage(), /*init*/nullptr, /*name*/"", DstGV, 999 DstGV->getThreadLocalMode(), 1000 DstGV->getType()->getAddressSpace()); 1001 1002 // Propagate alignment, visibility and section info. 1003 copyGVAttributes(NG, DstGV); 1004 1005 AppendingVarInfo AVI; 1006 AVI.NewGV = NG; 1007 AVI.DstInit = DstGV->getInitializer(); 1008 AVI.SrcInit = SrcGV->getInitializer(); 1009 AppendingVars.push_back(AVI); 1010 1011 // Replace any uses of the two global variables with uses of the new 1012 // global. 1013 ValueMap[SrcGV] = ConstantExpr::getBitCast(NG, TypeMap.get(SrcGV->getType())); 1014 1015 DstGV->replaceAllUsesWith(ConstantExpr::getBitCast(NG, DstGV->getType())); 1016 DstGV->eraseFromParent(); 1017 1018 // Track the source variable so we don't try to link it. 1019 DoNotLinkFromSource.insert(SrcGV); 1020 1021 return false; 1022 } 1023 1024 bool ModuleLinker::linkGlobalValueProto(GlobalValue *SGV) { 1025 GlobalValue *DGV = getLinkedToGlobal(SGV); 1026 1027 // Handle the ultra special appending linkage case first. 1028 if (DGV && DGV->hasAppendingLinkage()) 1029 return linkAppendingVarProto(cast<GlobalVariable>(DGV), 1030 cast<GlobalVariable>(SGV)); 1031 1032 bool LinkFromSrc = true; 1033 Comdat *C = nullptr; 1034 GlobalValue::VisibilityTypes Visibility = SGV->getVisibility(); 1035 bool HasUnnamedAddr = SGV->hasUnnamedAddr(); 1036 1037 if (const Comdat *SC = SGV->getComdat()) { 1038 Comdat::SelectionKind SK; 1039 std::tie(SK, LinkFromSrc) = ComdatsChosen[SC]; 1040 C = DstM->getOrInsertComdat(SC->getName()); 1041 C->setSelectionKind(SK); 1042 } else if (DGV) { 1043 if (shouldLinkFromSource(LinkFromSrc, *DGV, *SGV)) 1044 return true; 1045 } 1046 1047 if (!LinkFromSrc) { 1048 // Track the source global so that we don't attempt to copy it over when 1049 // processing global initializers. 1050 DoNotLinkFromSource.insert(SGV); 1051 1052 if (DGV) 1053 // Make sure to remember this mapping. 1054 ValueMap[SGV] = 1055 ConstantExpr::getBitCast(DGV, TypeMap.get(SGV->getType())); 1056 } 1057 1058 if (DGV) { 1059 Visibility = isLessConstraining(Visibility, DGV->getVisibility()) 1060 ? DGV->getVisibility() 1061 : Visibility; 1062 HasUnnamedAddr = HasUnnamedAddr && DGV->hasUnnamedAddr(); 1063 } 1064 1065 if (!LinkFromSrc && !DGV) 1066 return false; 1067 1068 GlobalValue *NewGV; 1069 if (!LinkFromSrc) { 1070 NewGV = DGV; 1071 } else { 1072 // If the GV is to be lazily linked, don't create it just yet. 1073 // The ValueMaterializerTy will deal with creating it if it's used. 1074 if (!DGV && (SGV->hasLocalLinkage() || SGV->hasLinkOnceLinkage() || 1075 SGV->hasAvailableExternallyLinkage())) { 1076 DoNotLinkFromSource.insert(SGV); 1077 return false; 1078 } 1079 1080 NewGV = copyGlobalValueProto(TypeMap, *DstM, SGV); 1081 1082 if (DGV && isa<Function>(DGV)) 1083 if (auto *NewF = dyn_cast<Function>(NewGV)) 1084 OverridingFunctions.insert(NewF); 1085 } 1086 1087 NewGV->setUnnamedAddr(HasUnnamedAddr); 1088 NewGV->setVisibility(Visibility); 1089 1090 if (auto *NewGO = dyn_cast<GlobalObject>(NewGV)) { 1091 if (C) 1092 NewGO->setComdat(C); 1093 1094 if (DGV && DGV->hasCommonLinkage() && SGV->hasCommonLinkage()) 1095 NewGO->setAlignment(std::max(DGV->getAlignment(), SGV->getAlignment())); 1096 } 1097 1098 if (auto *NewGVar = dyn_cast<GlobalVariable>(NewGV)) { 1099 auto *DGVar = dyn_cast_or_null<GlobalVariable>(DGV); 1100 auto *SGVar = dyn_cast<GlobalVariable>(SGV); 1101 if (DGVar && SGVar && DGVar->isDeclaration() && SGVar->isDeclaration() && 1102 (!DGVar->isConstant() || !SGVar->isConstant())) 1103 NewGVar->setConstant(false); 1104 } 1105 1106 // Make sure to remember this mapping. 1107 if (NewGV != DGV) { 1108 if (DGV) { 1109 DGV->replaceAllUsesWith(ConstantExpr::getBitCast(NewGV, DGV->getType())); 1110 DGV->eraseFromParent(); 1111 } 1112 ValueMap[SGV] = NewGV; 1113 } 1114 1115 return false; 1116 } 1117 1118 static void getArrayElements(const Constant *C, 1119 SmallVectorImpl<Constant *> &Dest) { 1120 unsigned NumElements = cast<ArrayType>(C->getType())->getNumElements(); 1121 1122 for (unsigned i = 0; i != NumElements; ++i) 1123 Dest.push_back(C->getAggregateElement(i)); 1124 } 1125 1126 void ModuleLinker::linkAppendingVarInit(const AppendingVarInfo &AVI) { 1127 // Merge the initializer. 1128 SmallVector<Constant *, 16> DstElements; 1129 getArrayElements(AVI.DstInit, DstElements); 1130 1131 SmallVector<Constant *, 16> SrcElements; 1132 getArrayElements(AVI.SrcInit, SrcElements); 1133 1134 ArrayType *NewType = cast<ArrayType>(AVI.NewGV->getType()->getElementType()); 1135 1136 StringRef Name = AVI.NewGV->getName(); 1137 bool IsNewStructor = 1138 (Name == "llvm.global_ctors" || Name == "llvm.global_dtors") && 1139 cast<StructType>(NewType->getElementType())->getNumElements() == 3; 1140 1141 for (auto *V : SrcElements) { 1142 if (IsNewStructor) { 1143 Constant *Key = V->getAggregateElement(2); 1144 if (DoNotLinkFromSource.count(Key)) 1145 continue; 1146 } 1147 DstElements.push_back( 1148 MapValue(V, ValueMap, RF_None, &TypeMap, &ValMaterializer)); 1149 } 1150 if (IsNewStructor) { 1151 NewType = ArrayType::get(NewType->getElementType(), DstElements.size()); 1152 AVI.NewGV->mutateType(PointerType::get(NewType, 0)); 1153 } 1154 1155 AVI.NewGV->setInitializer(ConstantArray::get(NewType, DstElements)); 1156 } 1157 1158 /// Update the initializers in the Dest module now that all globals that may be 1159 /// referenced are in Dest. 1160 void ModuleLinker::linkGlobalInit(GlobalVariable &Dst, GlobalVariable &Src) { 1161 // Figure out what the initializer looks like in the dest module. 1162 Dst.setInitializer(MapValue(Src.getInitializer(), ValueMap, RF_None, &TypeMap, 1163 &ValMaterializer)); 1164 } 1165 1166 /// Copy the source function over into the dest function and fix up references 1167 /// to values. At this point we know that Dest is an external function, and 1168 /// that Src is not. 1169 bool ModuleLinker::linkFunctionBody(Function &Dst, Function &Src) { 1170 assert(Dst.isDeclaration() && !Src.isDeclaration()); 1171 1172 // Materialize if needed. 1173 if (std::error_code EC = Src.materialize()) 1174 return emitError(EC.message()); 1175 1176 // Link in the prefix data. 1177 if (Src.hasPrefixData()) 1178 Dst.setPrefixData(MapValue(Src.getPrefixData(), ValueMap, RF_None, &TypeMap, 1179 &ValMaterializer)); 1180 1181 // Link in the prologue data. 1182 if (Src.hasPrologueData()) 1183 Dst.setPrologueData(MapValue(Src.getPrologueData(), ValueMap, RF_None, 1184 &TypeMap, &ValMaterializer)); 1185 1186 // Go through and convert function arguments over, remembering the mapping. 1187 Function::arg_iterator DI = Dst.arg_begin(); 1188 for (Argument &Arg : Src.args()) { 1189 DI->setName(Arg.getName()); // Copy the name over. 1190 1191 // Add a mapping to our mapping. 1192 ValueMap[&Arg] = DI; 1193 ++DI; 1194 } 1195 1196 // Splice the body of the source function into the dest function. 1197 Dst.getBasicBlockList().splice(Dst.end(), Src.getBasicBlockList()); 1198 1199 // At this point, all of the instructions and values of the function are now 1200 // copied over. The only problem is that they are still referencing values in 1201 // the Source function as operands. Loop through all of the operands of the 1202 // functions and patch them up to point to the local versions. 1203 for (BasicBlock &BB : Dst) 1204 for (Instruction &I : BB) 1205 RemapInstruction(&I, ValueMap, RF_IgnoreMissingEntries, &TypeMap, 1206 &ValMaterializer); 1207 1208 // There is no need to map the arguments anymore. 1209 for (Argument &Arg : Src.args()) 1210 ValueMap.erase(&Arg); 1211 1212 Src.Dematerialize(); 1213 return false; 1214 } 1215 1216 void ModuleLinker::linkAliasBody(GlobalAlias &Dst, GlobalAlias &Src) { 1217 Constant *Aliasee = Src.getAliasee(); 1218 Constant *Val = 1219 MapValue(Aliasee, ValueMap, RF_None, &TypeMap, &ValMaterializer); 1220 Dst.setAliasee(Val); 1221 } 1222 1223 bool ModuleLinker::linkGlobalValueBody(GlobalValue &Src) { 1224 Value *Dst = ValueMap[&Src]; 1225 assert(Dst); 1226 if (auto *F = dyn_cast<Function>(&Src)) 1227 return linkFunctionBody(cast<Function>(*Dst), *F); 1228 if (auto *GVar = dyn_cast<GlobalVariable>(&Src)) { 1229 linkGlobalInit(cast<GlobalVariable>(*Dst), *GVar); 1230 return false; 1231 } 1232 linkAliasBody(cast<GlobalAlias>(*Dst), cast<GlobalAlias>(Src)); 1233 return false; 1234 } 1235 1236 /// Insert all of the named MDNodes in Src into the Dest module. 1237 void ModuleLinker::linkNamedMDNodes() { 1238 const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata(); 1239 for (Module::const_named_metadata_iterator I = SrcM->named_metadata_begin(), 1240 E = SrcM->named_metadata_end(); I != E; ++I) { 1241 // Don't link module flags here. Do them separately. 1242 if (&*I == SrcModFlags) continue; 1243 NamedMDNode *DestNMD = DstM->getOrInsertNamedMetadata(I->getName()); 1244 // Add Src elements into Dest node. 1245 for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) 1246 DestNMD->addOperand(MapMetadata(I->getOperand(i), ValueMap, RF_None, 1247 &TypeMap, &ValMaterializer)); 1248 } 1249 } 1250 1251 /// Drop DISubprograms that have been superseded. 1252 /// 1253 /// FIXME: this creates an asymmetric result: we strip functions from losing 1254 /// subprograms in DstM, but leave losing subprograms in SrcM. 1255 /// TODO: Remove this logic once the backend can correctly determine canonical 1256 /// subprograms. 1257 void ModuleLinker::stripReplacedSubprograms() { 1258 // Avoid quadratic runtime by returning early when there's nothing to do. 1259 if (OverridingFunctions.empty()) 1260 return; 1261 1262 // Move the functions now, so the set gets cleared even on early returns. 1263 auto Functions = std::move(OverridingFunctions); 1264 OverridingFunctions.clear(); 1265 1266 // Drop functions from subprograms if they've been overridden by the new 1267 // compile unit. 1268 NamedMDNode *CompileUnits = DstM->getNamedMetadata("llvm.dbg.cu"); 1269 if (!CompileUnits) 1270 return; 1271 for (unsigned I = 0, E = CompileUnits->getNumOperands(); I != E; ++I) { 1272 DICompileUnit CU = cast<MDCompileUnit>(CompileUnits->getOperand(I)); 1273 assert(CU && "Expected valid compile unit"); 1274 1275 for (MDSubprogram *SP : CU->getSubprograms()) { 1276 if (!SP || !SP->getFunction() || !Functions.count(SP->getFunction())) 1277 continue; 1278 1279 // Prevent DebugInfoFinder from tagging this as the canonical subprogram, 1280 // since the canonical one is in the incoming module. 1281 SP->replaceFunction(nullptr); 1282 } 1283 } 1284 } 1285 1286 /// Merge the linker flags in Src into the Dest module. 1287 bool ModuleLinker::linkModuleFlagsMetadata() { 1288 // If the source module has no module flags, we are done. 1289 const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata(); 1290 if (!SrcModFlags) return false; 1291 1292 // If the destination module doesn't have module flags yet, then just copy 1293 // over the source module's flags. 1294 NamedMDNode *DstModFlags = DstM->getOrInsertModuleFlagsMetadata(); 1295 if (DstModFlags->getNumOperands() == 0) { 1296 for (unsigned I = 0, E = SrcModFlags->getNumOperands(); I != E; ++I) 1297 DstModFlags->addOperand(SrcModFlags->getOperand(I)); 1298 1299 return false; 1300 } 1301 1302 // First build a map of the existing module flags and requirements. 1303 DenseMap<MDString *, std::pair<MDNode *, unsigned>> Flags; 1304 SmallSetVector<MDNode*, 16> Requirements; 1305 for (unsigned I = 0, E = DstModFlags->getNumOperands(); I != E; ++I) { 1306 MDNode *Op = DstModFlags->getOperand(I); 1307 ConstantInt *Behavior = mdconst::extract<ConstantInt>(Op->getOperand(0)); 1308 MDString *ID = cast<MDString>(Op->getOperand(1)); 1309 1310 if (Behavior->getZExtValue() == Module::Require) { 1311 Requirements.insert(cast<MDNode>(Op->getOperand(2))); 1312 } else { 1313 Flags[ID] = std::make_pair(Op, I); 1314 } 1315 } 1316 1317 // Merge in the flags from the source module, and also collect its set of 1318 // requirements. 1319 bool HasErr = false; 1320 for (unsigned I = 0, E = SrcModFlags->getNumOperands(); I != E; ++I) { 1321 MDNode *SrcOp = SrcModFlags->getOperand(I); 1322 ConstantInt *SrcBehavior = 1323 mdconst::extract<ConstantInt>(SrcOp->getOperand(0)); 1324 MDString *ID = cast<MDString>(SrcOp->getOperand(1)); 1325 MDNode *DstOp; 1326 unsigned DstIndex; 1327 std::tie(DstOp, DstIndex) = Flags.lookup(ID); 1328 unsigned SrcBehaviorValue = SrcBehavior->getZExtValue(); 1329 1330 // If this is a requirement, add it and continue. 1331 if (SrcBehaviorValue == Module::Require) { 1332 // If the destination module does not already have this requirement, add 1333 // it. 1334 if (Requirements.insert(cast<MDNode>(SrcOp->getOperand(2)))) { 1335 DstModFlags->addOperand(SrcOp); 1336 } 1337 continue; 1338 } 1339 1340 // If there is no existing flag with this ID, just add it. 1341 if (!DstOp) { 1342 Flags[ID] = std::make_pair(SrcOp, DstModFlags->getNumOperands()); 1343 DstModFlags->addOperand(SrcOp); 1344 continue; 1345 } 1346 1347 // Otherwise, perform a merge. 1348 ConstantInt *DstBehavior = 1349 mdconst::extract<ConstantInt>(DstOp->getOperand(0)); 1350 unsigned DstBehaviorValue = DstBehavior->getZExtValue(); 1351 1352 // If either flag has override behavior, handle it first. 1353 if (DstBehaviorValue == Module::Override) { 1354 // Diagnose inconsistent flags which both have override behavior. 1355 if (SrcBehaviorValue == Module::Override && 1356 SrcOp->getOperand(2) != DstOp->getOperand(2)) { 1357 HasErr |= emitError("linking module flags '" + ID->getString() + 1358 "': IDs have conflicting override values"); 1359 } 1360 continue; 1361 } else if (SrcBehaviorValue == Module::Override) { 1362 // Update the destination flag to that of the source. 1363 DstModFlags->setOperand(DstIndex, SrcOp); 1364 Flags[ID].first = SrcOp; 1365 continue; 1366 } 1367 1368 // Diagnose inconsistent merge behavior types. 1369 if (SrcBehaviorValue != DstBehaviorValue) { 1370 HasErr |= emitError("linking module flags '" + ID->getString() + 1371 "': IDs have conflicting behaviors"); 1372 continue; 1373 } 1374 1375 auto replaceDstValue = [&](MDNode *New) { 1376 Metadata *FlagOps[] = {DstOp->getOperand(0), ID, New}; 1377 MDNode *Flag = MDNode::get(DstM->getContext(), FlagOps); 1378 DstModFlags->setOperand(DstIndex, Flag); 1379 Flags[ID].first = Flag; 1380 }; 1381 1382 // Perform the merge for standard behavior types. 1383 switch (SrcBehaviorValue) { 1384 case Module::Require: 1385 case Module::Override: llvm_unreachable("not possible"); 1386 case Module::Error: { 1387 // Emit an error if the values differ. 1388 if (SrcOp->getOperand(2) != DstOp->getOperand(2)) { 1389 HasErr |= emitError("linking module flags '" + ID->getString() + 1390 "': IDs have conflicting values"); 1391 } 1392 continue; 1393 } 1394 case Module::Warning: { 1395 // Emit a warning if the values differ. 1396 if (SrcOp->getOperand(2) != DstOp->getOperand(2)) { 1397 emitWarning("linking module flags '" + ID->getString() + 1398 "': IDs have conflicting values"); 1399 } 1400 continue; 1401 } 1402 case Module::Append: { 1403 MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2)); 1404 MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2)); 1405 SmallVector<Metadata *, 8> MDs; 1406 MDs.reserve(DstValue->getNumOperands() + SrcValue->getNumOperands()); 1407 MDs.append(DstValue->op_begin(), DstValue->op_end()); 1408 MDs.append(SrcValue->op_begin(), SrcValue->op_end()); 1409 1410 replaceDstValue(MDNode::get(DstM->getContext(), MDs)); 1411 break; 1412 } 1413 case Module::AppendUnique: { 1414 SmallSetVector<Metadata *, 16> Elts; 1415 MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2)); 1416 MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2)); 1417 Elts.insert(DstValue->op_begin(), DstValue->op_end()); 1418 Elts.insert(SrcValue->op_begin(), SrcValue->op_end()); 1419 1420 replaceDstValue(MDNode::get(DstM->getContext(), 1421 makeArrayRef(Elts.begin(), Elts.end()))); 1422 break; 1423 } 1424 } 1425 } 1426 1427 // Check all of the requirements. 1428 for (unsigned I = 0, E = Requirements.size(); I != E; ++I) { 1429 MDNode *Requirement = Requirements[I]; 1430 MDString *Flag = cast<MDString>(Requirement->getOperand(0)); 1431 Metadata *ReqValue = Requirement->getOperand(1); 1432 1433 MDNode *Op = Flags[Flag].first; 1434 if (!Op || Op->getOperand(2) != ReqValue) { 1435 HasErr |= emitError("linking module flags '" + Flag->getString() + 1436 "': does not have the required value"); 1437 continue; 1438 } 1439 } 1440 1441 return HasErr; 1442 } 1443 1444 // This function returns true if the triples match. 1445 static bool triplesMatch(const Triple &T0, const Triple &T1) { 1446 // If vendor is apple, ignore the version number. 1447 if (T0.getVendor() == Triple::Apple) 1448 return T0.getArch() == T1.getArch() && 1449 T0.getSubArch() == T1.getSubArch() && 1450 T0.getVendor() == T1.getVendor() && 1451 T0.getOS() == T1.getOS(); 1452 1453 return T0 == T1; 1454 } 1455 1456 // This function returns the merged triple. 1457 static std::string mergeTriples(const Triple &SrcTriple, const Triple &DstTriple) { 1458 // If vendor is apple, pick the triple with the larger version number. 1459 if (SrcTriple.getVendor() == Triple::Apple) 1460 if (DstTriple.isOSVersionLT(SrcTriple)) 1461 return SrcTriple.str(); 1462 1463 return DstTriple.str(); 1464 } 1465 1466 bool ModuleLinker::run() { 1467 assert(DstM && "Null destination module"); 1468 assert(SrcM && "Null source module"); 1469 1470 // Inherit the target data from the source module if the destination module 1471 // doesn't have one already. 1472 if (DstM->getDataLayout().isDefault()) 1473 DstM->setDataLayout(SrcM->getDataLayout()); 1474 1475 if (SrcM->getDataLayout() != DstM->getDataLayout()) { 1476 emitWarning("Linking two modules of different data layouts: '" + 1477 SrcM->getModuleIdentifier() + "' is '" + 1478 SrcM->getDataLayoutStr() + "' whereas '" + 1479 DstM->getModuleIdentifier() + "' is '" + 1480 DstM->getDataLayoutStr() + "'\n"); 1481 } 1482 1483 // Copy the target triple from the source to dest if the dest's is empty. 1484 if (DstM->getTargetTriple().empty() && !SrcM->getTargetTriple().empty()) 1485 DstM->setTargetTriple(SrcM->getTargetTriple()); 1486 1487 Triple SrcTriple(SrcM->getTargetTriple()), DstTriple(DstM->getTargetTriple()); 1488 1489 if (!SrcM->getTargetTriple().empty() && !triplesMatch(SrcTriple, DstTriple)) 1490 emitWarning("Linking two modules of different target triples: " + 1491 SrcM->getModuleIdentifier() + "' is '" + 1492 SrcM->getTargetTriple() + "' whereas '" + 1493 DstM->getModuleIdentifier() + "' is '" + 1494 DstM->getTargetTriple() + "'\n"); 1495 1496 DstM->setTargetTriple(mergeTriples(SrcTriple, DstTriple)); 1497 1498 // Append the module inline asm string. 1499 if (!SrcM->getModuleInlineAsm().empty()) { 1500 if (DstM->getModuleInlineAsm().empty()) 1501 DstM->setModuleInlineAsm(SrcM->getModuleInlineAsm()); 1502 else 1503 DstM->setModuleInlineAsm(DstM->getModuleInlineAsm()+"\n"+ 1504 SrcM->getModuleInlineAsm()); 1505 } 1506 1507 // Loop over all of the linked values to compute type mappings. 1508 computeTypeMapping(); 1509 1510 ComdatsChosen.clear(); 1511 for (const auto &SMEC : SrcM->getComdatSymbolTable()) { 1512 const Comdat &C = SMEC.getValue(); 1513 if (ComdatsChosen.count(&C)) 1514 continue; 1515 Comdat::SelectionKind SK; 1516 bool LinkFromSrc; 1517 if (getComdatResult(&C, SK, LinkFromSrc)) 1518 return true; 1519 ComdatsChosen[&C] = std::make_pair(SK, LinkFromSrc); 1520 } 1521 1522 // Upgrade mismatched global arrays. 1523 upgradeMismatchedGlobals(); 1524 1525 // Insert all of the globals in src into the DstM module... without linking 1526 // initializers (which could refer to functions not yet mapped over). 1527 for (Module::global_iterator I = SrcM->global_begin(), 1528 E = SrcM->global_end(); I != E; ++I) 1529 if (linkGlobalValueProto(I)) 1530 return true; 1531 1532 // Link the functions together between the two modules, without doing function 1533 // bodies... this just adds external function prototypes to the DstM 1534 // function... We do this so that when we begin processing function bodies, 1535 // all of the global values that may be referenced are available in our 1536 // ValueMap. 1537 for (Module::iterator I = SrcM->begin(), E = SrcM->end(); I != E; ++I) 1538 if (linkGlobalValueProto(I)) 1539 return true; 1540 1541 // If there were any aliases, link them now. 1542 for (Module::alias_iterator I = SrcM->alias_begin(), 1543 E = SrcM->alias_end(); I != E; ++I) 1544 if (linkGlobalValueProto(I)) 1545 return true; 1546 1547 for (unsigned i = 0, e = AppendingVars.size(); i != e; ++i) 1548 linkAppendingVarInit(AppendingVars[i]); 1549 1550 for (const auto &Entry : DstM->getComdatSymbolTable()) { 1551 const Comdat &C = Entry.getValue(); 1552 if (C.getSelectionKind() == Comdat::Any) 1553 continue; 1554 const GlobalValue *GV = SrcM->getNamedValue(C.getName()); 1555 assert(GV); 1556 MapValue(GV, ValueMap, RF_None, &TypeMap, &ValMaterializer); 1557 } 1558 1559 // Strip replaced subprograms before mapping any metadata -- so that we're 1560 // not changing metadata from the source module (note that 1561 // linkGlobalValueBody() eventually calls RemapInstruction() and therefore 1562 // MapMetadata()) -- but after linking global value protocols -- so that 1563 // OverridingFunctions has been built. 1564 stripReplacedSubprograms(); 1565 1566 // Link in the function bodies that are defined in the source module into 1567 // DstM. 1568 for (Function &SF : *SrcM) { 1569 // Skip if no body (function is external). 1570 if (SF.isDeclaration()) 1571 continue; 1572 1573 // Skip if not linking from source. 1574 if (DoNotLinkFromSource.count(&SF)) 1575 continue; 1576 1577 if (linkGlobalValueBody(SF)) 1578 return true; 1579 } 1580 1581 // Resolve all uses of aliases with aliasees. 1582 for (GlobalAlias &Src : SrcM->aliases()) { 1583 if (DoNotLinkFromSource.count(&Src)) 1584 continue; 1585 linkGlobalValueBody(Src); 1586 } 1587 1588 // Remap all of the named MDNodes in Src into the DstM module. We do this 1589 // after linking GlobalValues so that MDNodes that reference GlobalValues 1590 // are properly remapped. 1591 linkNamedMDNodes(); 1592 1593 // Merge the module flags into the DstM module. 1594 if (linkModuleFlagsMetadata()) 1595 return true; 1596 1597 // Update the initializers in the DstM module now that all globals that may 1598 // be referenced are in DstM. 1599 for (GlobalVariable &Src : SrcM->globals()) { 1600 // Only process initialized GV's or ones not already in dest. 1601 if (!Src.hasInitializer() || DoNotLinkFromSource.count(&Src)) 1602 continue; 1603 linkGlobalValueBody(Src); 1604 } 1605 1606 // Process vector of lazily linked in functions. 1607 while (!LazilyLinkGlobalValues.empty()) { 1608 GlobalValue *SGV = LazilyLinkGlobalValues.back(); 1609 LazilyLinkGlobalValues.pop_back(); 1610 1611 assert(!SGV->isDeclaration() && "users should not pass down decls"); 1612 if (linkGlobalValueBody(*SGV)) 1613 return true; 1614 } 1615 1616 return false; 1617 } 1618 1619 Linker::StructTypeKeyInfo::KeyTy::KeyTy(ArrayRef<Type *> E, bool P) 1620 : ETypes(E), IsPacked(P) {} 1621 1622 Linker::StructTypeKeyInfo::KeyTy::KeyTy(const StructType *ST) 1623 : ETypes(ST->elements()), IsPacked(ST->isPacked()) {} 1624 1625 bool Linker::StructTypeKeyInfo::KeyTy::operator==(const KeyTy &That) const { 1626 if (IsPacked != That.IsPacked) 1627 return false; 1628 if (ETypes != That.ETypes) 1629 return false; 1630 return true; 1631 } 1632 1633 bool Linker::StructTypeKeyInfo::KeyTy::operator!=(const KeyTy &That) const { 1634 return !this->operator==(That); 1635 } 1636 1637 StructType *Linker::StructTypeKeyInfo::getEmptyKey() { 1638 return DenseMapInfo<StructType *>::getEmptyKey(); 1639 } 1640 1641 StructType *Linker::StructTypeKeyInfo::getTombstoneKey() { 1642 return DenseMapInfo<StructType *>::getTombstoneKey(); 1643 } 1644 1645 unsigned Linker::StructTypeKeyInfo::getHashValue(const KeyTy &Key) { 1646 return hash_combine(hash_combine_range(Key.ETypes.begin(), Key.ETypes.end()), 1647 Key.IsPacked); 1648 } 1649 1650 unsigned Linker::StructTypeKeyInfo::getHashValue(const StructType *ST) { 1651 return getHashValue(KeyTy(ST)); 1652 } 1653 1654 bool Linker::StructTypeKeyInfo::isEqual(const KeyTy &LHS, 1655 const StructType *RHS) { 1656 if (RHS == getEmptyKey() || RHS == getTombstoneKey()) 1657 return false; 1658 return LHS == KeyTy(RHS); 1659 } 1660 1661 bool Linker::StructTypeKeyInfo::isEqual(const StructType *LHS, 1662 const StructType *RHS) { 1663 if (RHS == getEmptyKey()) 1664 return LHS == getEmptyKey(); 1665 1666 if (RHS == getTombstoneKey()) 1667 return LHS == getTombstoneKey(); 1668 1669 return KeyTy(LHS) == KeyTy(RHS); 1670 } 1671 1672 void Linker::IdentifiedStructTypeSet::addNonOpaque(StructType *Ty) { 1673 assert(!Ty->isOpaque()); 1674 NonOpaqueStructTypes.insert(Ty); 1675 } 1676 1677 void Linker::IdentifiedStructTypeSet::switchToNonOpaque(StructType *Ty) { 1678 assert(!Ty->isOpaque()); 1679 NonOpaqueStructTypes.insert(Ty); 1680 bool Removed = OpaqueStructTypes.erase(Ty); 1681 (void)Removed; 1682 assert(Removed); 1683 } 1684 1685 void Linker::IdentifiedStructTypeSet::addOpaque(StructType *Ty) { 1686 assert(Ty->isOpaque()); 1687 OpaqueStructTypes.insert(Ty); 1688 } 1689 1690 StructType * 1691 Linker::IdentifiedStructTypeSet::findNonOpaque(ArrayRef<Type *> ETypes, 1692 bool IsPacked) { 1693 Linker::StructTypeKeyInfo::KeyTy Key(ETypes, IsPacked); 1694 auto I = NonOpaqueStructTypes.find_as(Key); 1695 if (I == NonOpaqueStructTypes.end()) 1696 return nullptr; 1697 return *I; 1698 } 1699 1700 bool Linker::IdentifiedStructTypeSet::hasType(StructType *Ty) { 1701 if (Ty->isOpaque()) 1702 return OpaqueStructTypes.count(Ty); 1703 auto I = NonOpaqueStructTypes.find(Ty); 1704 if (I == NonOpaqueStructTypes.end()) 1705 return false; 1706 return *I == Ty; 1707 } 1708 1709 void Linker::init(Module *M, DiagnosticHandlerFunction DiagnosticHandler) { 1710 this->Composite = M; 1711 this->DiagnosticHandler = DiagnosticHandler; 1712 1713 TypeFinder StructTypes; 1714 StructTypes.run(*M, true); 1715 for (StructType *Ty : StructTypes) { 1716 if (Ty->isOpaque()) 1717 IdentifiedStructTypes.addOpaque(Ty); 1718 else 1719 IdentifiedStructTypes.addNonOpaque(Ty); 1720 } 1721 } 1722 1723 Linker::Linker(Module *M, DiagnosticHandlerFunction DiagnosticHandler) { 1724 init(M, DiagnosticHandler); 1725 } 1726 1727 Linker::Linker(Module *M) { 1728 init(M, [this](const DiagnosticInfo &DI) { 1729 Composite->getContext().diagnose(DI); 1730 }); 1731 } 1732 1733 Linker::~Linker() { 1734 } 1735 1736 void Linker::deleteModule() { 1737 delete Composite; 1738 Composite = nullptr; 1739 } 1740 1741 bool Linker::linkInModule(Module *Src) { 1742 ModuleLinker TheLinker(Composite, IdentifiedStructTypes, Src, 1743 DiagnosticHandler); 1744 bool RetCode = TheLinker.run(); 1745 Composite->dropTriviallyDeadConstantArrays(); 1746 return RetCode; 1747 } 1748 1749 void Linker::setModule(Module *Dst) { 1750 init(Dst, DiagnosticHandler); 1751 } 1752 1753 //===----------------------------------------------------------------------===// 1754 // LinkModules entrypoint. 1755 //===----------------------------------------------------------------------===// 1756 1757 /// This function links two modules together, with the resulting Dest module 1758 /// modified to be the composite of the two input modules. If an error occurs, 1759 /// true is returned and ErrorMsg (if not null) is set to indicate the problem. 1760 /// Upon failure, the Dest module could be in a modified state, and shouldn't be 1761 /// relied on to be consistent. 1762 bool Linker::LinkModules(Module *Dest, Module *Src, 1763 DiagnosticHandlerFunction DiagnosticHandler) { 1764 Linker L(Dest, DiagnosticHandler); 1765 return L.linkInModule(Src); 1766 } 1767 1768 bool Linker::LinkModules(Module *Dest, Module *Src) { 1769 Linker L(Dest); 1770 return L.linkInModule(Src); 1771 } 1772 1773 //===----------------------------------------------------------------------===// 1774 // C API. 1775 //===----------------------------------------------------------------------===// 1776 1777 LLVMBool LLVMLinkModules(LLVMModuleRef Dest, LLVMModuleRef Src, 1778 LLVMLinkerMode Unused, char **OutMessages) { 1779 Module *D = unwrap(Dest); 1780 std::string Message; 1781 raw_string_ostream Stream(Message); 1782 DiagnosticPrinterRawOStream DP(Stream); 1783 1784 LLVMBool Result = Linker::LinkModules( 1785 D, unwrap(Src), [&](const DiagnosticInfo &DI) { DI.print(DP); }); 1786 1787 if (OutMessages && Result) 1788 *OutMessages = strdup(Message.c_str()); 1789 return Result; 1790 } 1791