LinkModules.cpp revision c68d127b2c5a233c5e3f9dd59ca4ab335419d9dd
1c834bbf55832c45f90b1163f920472fefbf77bc1Mikhail Glushenkov//===- lib/Linker/LinkModules.cpp - Module Linker Implementation ----------===// 2f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 952f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// 1052f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// This file implements the LLVM module linker. 1152f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// 1252f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner//===----------------------------------------------------------------------===// 1352f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 147cc371a7958c7a049c679a59023c3c8c83f6cc83Reid Spencer#include "llvm/Linker.h" 15adbc0b5287bf36893cdcae2440d48b3cb3489e38Chris Lattner#include "llvm/Constants.h" 16adbc0b5287bf36893cdcae2440d48b3cb3489e38Chris Lattner#include "llvm/DerivedTypes.h" 17f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner#include "llvm/Instructions.h" 185c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner#include "llvm/Module.h" 19d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling#include "llvm/ADT/DenseSet.h" 203ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola#include "llvm/ADT/Optional.h" 21d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling#include "llvm/ADT/SetVector.h" 22d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling#include "llvm/ADT/SmallPtrSet.h" 2374382b7c699120fbec5cb5603c9cf4212eb37f06Chris Lattner#include "llvm/Support/raw_ostream.h" 241f6efa3996dd1929fbc129203ce5009b620e6969Michael J. Spencer#include "llvm/Support/Path.h" 25f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner#include "llvm/Transforms/Utils/Cloning.h" 2605ea54e8869a81b8dd846397175f218f97968907Dan Gohman#include "llvm/Transforms/Utils/ValueMapper.h" 27f7703df4968084c18c248c1feea9961c19a32e6aChris Lattnerusing namespace llvm; 28d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 291afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner//===----------------------------------------------------------------------===// 301afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner// TypeMap implementation. 311afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner//===----------------------------------------------------------------------===// 324c00e53b81de81ecf4ba0c4e287ea230c79e82aeChris Lattner 3362a81a1eba019ab570b002f8e1686494139785a1Chris Lattnernamespace { 341afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnerclass TypeMapTy : public ValueMapTypeRemapper { 351afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// MappedTypes - This is a mapping from a source type to a destination type 361afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// to use. 371afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DenseMap<Type*, Type*> MappedTypes; 381afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 391afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// SpeculativeTypes - When checking to see if two subgraphs are isomorphic, 401afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// we speculatively add types to MappedTypes, but keep track of them here in 411afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// case we need to roll back. 421afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SmallVector<Type*, 16> SpeculativeTypes; 431afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 4468910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner /// SrcDefinitionsToResolve - This is a list of non-opaque structs in the 4568910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner /// source module that are mapped to an opaque struct in the destination 4668910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner /// module. 4768910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner SmallVector<StructType*, 16> SrcDefinitionsToResolve; 4868910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner 4968910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner /// DstResolvedOpaqueTypes - This is the set of opaque types in the 5068910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner /// destination modules who are getting a body from the source module. 5168910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner SmallPtrSet<StructType*, 16> DstResolvedOpaqueTypes; 52fc196f9ee909ac35837f6f771a42aa0dec817584Chris Lattnerpublic: 531afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 541afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// addTypeMapping - Indicate that the specified type in the destination 551afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// module is conceptually equivalent to the specified type in the source 561afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// module. 571afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner void addTypeMapping(Type *DstTy, Type *SrcTy); 581afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 591afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// linkDefinedTypeBodies - Produce a body for an opaque type in the dest 601afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// module from a type definition in the source module. 611afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner void linkDefinedTypeBodies(); 621afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 631afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// get - Return the mapped type to use for the specified input type from the 641afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// source module. 651afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Type *get(Type *SrcTy); 661afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 671afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner FunctionType *get(FunctionType *T) {return cast<FunctionType>(get((Type*)T));} 681afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 691afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnerprivate: 701afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Type *getImpl(Type *T); 711afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// remapType - Implement the ValueMapTypeRemapper interface. 721afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Type *remapType(Type *SrcTy) { 731afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return get(SrcTy); 7462a81a1eba019ab570b002f8e1686494139785a1Chris Lattner } 751afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 761afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner bool areTypesIsomorphic(Type *DstTy, Type *SrcTy); 771afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner}; 781afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner} 79eba2cb0d5aef5a8229facae5624c65d9fd65e9d1Mikhail Glushenkov 801afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnervoid TypeMapTy::addTypeMapping(Type *DstTy, Type *SrcTy) { 811afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Type *&Entry = MappedTypes[SrcTy]; 821afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (Entry) return; 831afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 841afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DstTy == SrcTy) { 851afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Entry = DstTy; 861afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return; 8762a81a1eba019ab570b002f8e1686494139785a1Chris Lattner } 881afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 891afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Check to see if these types are recursively isomorphic and establish a 901afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // mapping between them if so. 911afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!areTypesIsomorphic(DstTy, SrcTy)) { 921afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Oops, they aren't isomorphic. Just discard this request by rolling out 931afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // any speculative mappings we've established. 941afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (unsigned i = 0, e = SpeculativeTypes.size(); i != e; ++i) 951afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner MappedTypes.erase(SpeculativeTypes[i]); 9662a81a1eba019ab570b002f8e1686494139785a1Chris Lattner } 971afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SpeculativeTypes.clear(); 9862a81a1eba019ab570b002f8e1686494139785a1Chris Lattner} 9962a81a1eba019ab570b002f8e1686494139785a1Chris Lattner 1001afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// areTypesIsomorphic - Recursively walk this pair of types, returning true 1011afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// if they are isomorphic, false if they are not. 1021afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnerbool TypeMapTy::areTypesIsomorphic(Type *DstTy, Type *SrcTy) { 1031afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Two types with differing kinds are clearly not isomorphic. 1041afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DstTy->getTypeID() != SrcTy->getTypeID()) return false; 1051afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 1061afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If we have an entry in the MappedTypes table, then we have our answer. 1071afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Type *&Entry = MappedTypes[SrcTy]; 1081afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (Entry) 1091afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return Entry == DstTy; 1101afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 1111afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Two identical types are clearly isomorphic. Remember this 1121afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // non-speculatively. 1131afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DstTy == SrcTy) { 1141afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Entry = DstTy; 11556539659eb1b192d493aa333b60213889129b9f1Chris Lattner return true; 116e76c57ad467ed57f09f2a3ef51628d4b6eb2b304Chris Lattner } 1171afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 1181afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Okay, we have two types with identical kinds that we haven't seen before. 1191afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 1201afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If this is an opaque struct type, special case it. 1211afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (StructType *SSTy = dyn_cast<StructType>(SrcTy)) { 1221afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Mapping an opaque type to any struct, just keep the dest struct. 1231afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (SSTy->isOpaque()) { 1241afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Entry = DstTy; 1251afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SpeculativeTypes.push_back(SrcTy); 126f6f4f7a149e2864cc0441afcbed5fd99ff4b9587Chris Lattner return true; 1271afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 128eba2cb0d5aef5a8229facae5624c65d9fd65e9d1Mikhail Glushenkov 12968910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner // Mapping a non-opaque source type to an opaque dest. If this is the first 13068910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner // type that we're mapping onto this destination type then we succeed. Keep 13168910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner // the dest, but fill it in later. This doesn't need to be speculative. If 13268910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner // this is the second (different) type that we're trying to map onto the 13368910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner // same opaque type then we fail. 1341afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (cast<StructType>(DstTy)->isOpaque()) { 13568910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner // We can only map one source type onto the opaque destination type. 13668910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner if (!DstResolvedOpaqueTypes.insert(cast<StructType>(DstTy))) 13768910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner return false; 13868910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner SrcDefinitionsToResolve.push_back(SSTy); 1391afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Entry = DstTy; 1401afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return true; 141a4477f9b31ce0b6fadc5365ff9355679c1ecb954Chris Lattner } 142e3092c94ad2e3af96f37a0a8186149acbbd9700aChris Lattner } 1431afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 1441afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If the number of subtypes disagree between the two types, then we fail. 1451afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (SrcTy->getNumContainedTypes() != DstTy->getNumContainedTypes()) 1461afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return false; 1471afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 1481afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Fail if any of the extra properties (e.g. array size) of the type disagree. 1491afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (isa<IntegerType>(DstTy)) 1501afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return false; // bitwidth disagrees. 1511afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (PointerType *PT = dyn_cast<PointerType>(DstTy)) { 1521afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (PT->getAddressSpace() != cast<PointerType>(SrcTy)->getAddressSpace()) 1531afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return false; 1541a31f3b90c012b067f8509546e1e037051e6482dChris Lattner 1551afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } else if (FunctionType *FT = dyn_cast<FunctionType>(DstTy)) { 1561afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (FT->isVarArg() != cast<FunctionType>(SrcTy)->isVarArg()) 1571afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return false; 1581afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } else if (StructType *DSTy = dyn_cast<StructType>(DstTy)) { 1591afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner StructType *SSTy = cast<StructType>(SrcTy); 1601bcbf8582e94eee6f151e5e2db2d04f417abf5f7Chris Lattner if (DSTy->isLiteral() != SSTy->isLiteral() || 1611afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DSTy->isPacked() != SSTy->isPacked()) 1621afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return false; 1631afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } else if (ArrayType *DATy = dyn_cast<ArrayType>(DstTy)) { 1641afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DATy->getNumElements() != cast<ArrayType>(SrcTy)->getNumElements()) 1651afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return false; 1661afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } else if (VectorType *DVTy = dyn_cast<VectorType>(DstTy)) { 1671afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DVTy->getNumElements() != cast<ArrayType>(SrcTy)->getNumElements()) 1681afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return false; 169f6f4f7a149e2864cc0441afcbed5fd99ff4b9587Chris Lattner } 170eba2cb0d5aef5a8229facae5624c65d9fd65e9d1Mikhail Glushenkov 1711afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Otherwise, we speculate that these two types will line up and recursively 1721afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // check the subelements. 1731afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Entry = DstTy; 1741afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SpeculativeTypes.push_back(SrcTy); 1751afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 1761afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (unsigned i = 0, e = SrcTy->getNumContainedTypes(); i != e; ++i) 1771afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!areTypesIsomorphic(DstTy->getContainedType(i), 1781afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SrcTy->getContainedType(i))) 1791afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return false; 1801afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 1811afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If everything seems to have lined up, then everything is great. 1821afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return true; 1831afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner} 184eba2cb0d5aef5a8229facae5624c65d9fd65e9d1Mikhail Glushenkov 1851afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// linkDefinedTypeBodies - Produce a body for an opaque type in the dest 1861afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// module from a type definition in the source module. 1871afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnervoid TypeMapTy::linkDefinedTypeBodies() { 1881afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SmallVector<Type*, 16> Elements; 1891afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SmallString<16> TmpName; 1901afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 1911afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Note that processing entries in this loop (calling 'get') can add new 19268910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner // entries to the SrcDefinitionsToResolve vector. 19368910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner while (!SrcDefinitionsToResolve.empty()) { 19468910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner StructType *SrcSTy = SrcDefinitionsToResolve.pop_back_val(); 1951afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner StructType *DstSTy = cast<StructType>(MappedTypes[SrcSTy]); 1961afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 1971afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // TypeMap is a many-to-one mapping, if there were multiple types that 1981afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // provide a body for DstSTy then previous iterations of this loop may have 1991afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // already handled it. Just ignore this case. 2001afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!DstSTy->isOpaque()) continue; 2011afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner assert(!SrcSTy->isOpaque() && "Not resolving a definition?"); 2021afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 2031afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Map the body of the source type over to a new body for the dest type. 2041afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Elements.resize(SrcSTy->getNumElements()); 2051afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (unsigned i = 0, e = Elements.size(); i != e; ++i) 2061afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Elements[i] = getImpl(SrcSTy->getElementType(i)); 2071afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 2081afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DstSTy->setBody(Elements, SrcSTy->isPacked()); 2091afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 2101afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If DstSTy has no name or has a longer name than STy, then viciously steal 2111afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // STy's name. 2121afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!SrcSTy->hasName()) continue; 2131afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner StringRef SrcName = SrcSTy->getName(); 2141afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 2151afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!DstSTy->hasName() || DstSTy->getName().size() > SrcName.size()) { 2161afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner TmpName.insert(TmpName.end(), SrcName.begin(), SrcName.end()); 2171afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SrcSTy->setName(""); 2181afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DstSTy->setName(TmpName.str()); 2191afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner TmpName.clear(); 2201afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 221f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman } 22268910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner 22368910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner DstResolvedOpaqueTypes.clear(); 224e76c57ad467ed57f09f2a3ef51628d4b6eb2b304Chris Lattner} 225e76c57ad467ed57f09f2a3ef51628d4b6eb2b304Chris Lattner 226e3092c94ad2e3af96f37a0a8186149acbbd9700aChris Lattner 2271afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// get - Return the mapped type to use for the specified input type from the 2281afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// source module. 2291afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris LattnerType *TypeMapTy::get(Type *Ty) { 2301afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Type *Result = getImpl(Ty); 2311afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 2321afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If this caused a reference to any struct type, resolve it before returning. 23368910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner if (!SrcDefinitionsToResolve.empty()) 2341afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner linkDefinedTypeBodies(); 2351afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return Result; 2361afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner} 237e76c57ad467ed57f09f2a3ef51628d4b6eb2b304Chris Lattner 2381afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// getImpl - This is the recursive version of get(). 2391afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris LattnerType *TypeMapTy::getImpl(Type *Ty) { 2401afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If we already have an entry for this type, return it. 2411afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Type **Entry = &MappedTypes[Ty]; 2421afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (*Entry) return *Entry; 2431afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 2441afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If this is not a named struct type, then just map all of the elements and 2451afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // then rebuild the type from inside out. 2461bcbf8582e94eee6f151e5e2db2d04f417abf5f7Chris Lattner if (!isa<StructType>(Ty) || cast<StructType>(Ty)->isLiteral()) { 2471afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If there are no element types to map, then the type is itself. This is 2481afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // true for the anonymous {} struct, things like 'float', integers, etc. 2491afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (Ty->getNumContainedTypes() == 0) 2501afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return *Entry = Ty; 2511afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 2521afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Remap all of the elements, keeping track of whether any of them change. 2531afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner bool AnyChange = false; 2541afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SmallVector<Type*, 4> ElementTypes; 2551afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ElementTypes.resize(Ty->getNumContainedTypes()); 2561afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (unsigned i = 0, e = Ty->getNumContainedTypes(); i != e; ++i) { 2571afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ElementTypes[i] = getImpl(Ty->getContainedType(i)); 2581afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner AnyChange |= ElementTypes[i] != Ty->getContainedType(i); 2591afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 2601afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 2611afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If we found our type while recursively processing stuff, just use it. 2621afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Entry = &MappedTypes[Ty]; 2631afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (*Entry) return *Entry; 2641afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 2651afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If all of the element types mapped directly over, then the type is usable 2661afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // as-is. 2671afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!AnyChange) 2681afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return *Entry = Ty; 2691afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 2701afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Otherwise, rebuild a modified type. 2711afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner switch (Ty->getTypeID()) { 272858143816d43e58b17bfd11cb1b57afbd7f0f893Craig Topper default: llvm_unreachable("unknown derived type to remap"); 2731afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner case Type::ArrayTyID: 2741afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return *Entry = ArrayType::get(ElementTypes[0], 2751afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner cast<ArrayType>(Ty)->getNumElements()); 2761afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner case Type::VectorTyID: 2771afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return *Entry = VectorType::get(ElementTypes[0], 2781afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner cast<VectorType>(Ty)->getNumElements()); 2791afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner case Type::PointerTyID: 2801afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return *Entry = PointerType::get(ElementTypes[0], 2811afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner cast<PointerType>(Ty)->getAddressSpace()); 2821afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner case Type::FunctionTyID: 2831afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return *Entry = FunctionType::get(ElementTypes[0], 28439b5abf507b43da6b92f68b86406e0015ead18e9Frits van Bommel makeArrayRef(ElementTypes).slice(1), 2851afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner cast<FunctionType>(Ty)->isVarArg()); 2861afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner case Type::StructTyID: 2871afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Note that this is only reached for anonymous structs. 2881afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return *Entry = StructType::get(Ty->getContext(), ElementTypes, 2891afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner cast<StructType>(Ty)->isPacked()); 2904c00e53b81de81ecf4ba0c4e287ea230c79e82aeChris Lattner } 2914c00e53b81de81ecf4ba0c4e287ea230c79e82aeChris Lattner } 2924c00e53b81de81ecf4ba0c4e287ea230c79e82aeChris Lattner 2931afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Otherwise, this is an unmapped named struct. If the struct can be directly 2941afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // mapped over, just use it as-is. This happens in a case when the linked-in 2951afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // module has something like: 2961afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // %T = type {%T*, i32} 2971afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // @GV = global %T* null 2981afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // where T does not exist at all in the destination module. 2991afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // 3001afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // The other case we watch for is when the type is not in the destination 3011afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // module, but that it has to be rebuilt because it refers to something that 3021afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // is already mapped. For example, if the destination module has: 3031afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // %A = type { i32 } 3041afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // and the source module has something like 3051afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // %A' = type { i32 } 3061afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // %B = type { %A'* } 3071afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // @GV = global %B* null 3081afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // then we want to create a new type: "%B = type { %A*}" and have it take the 3091afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // pristine "%B" name from the source module. 3101afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // 3111afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // To determine which case this is, we have to recursively walk the type graph 3121afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // speculating that we'll be able to reuse it unmodified. Only if this is 3131afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // safe would we map the entire thing over. Because this is an optimization, 3141afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // and is not required for the prettiness of the linked module, we just skip 3151afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // it and always rebuild a type here. 3161afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner StructType *STy = cast<StructType>(Ty); 3171afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 3181afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If the type is opaque, we can just use it directly. 3191afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (STy->isOpaque()) 3201afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return *Entry = STy; 3211afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 3221afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Otherwise we create a new type and resolve its body later. This will be 3231afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // resolved by the top level of get(). 32468910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner SrcDefinitionsToResolve.push_back(STy); 32568910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner StructType *DTy = StructType::create(STy->getContext()); 32668910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner DstResolvedOpaqueTypes.insert(DTy); 32768910509fdd638727ce2f244ab7c0e4346671de1Chris Lattner return *Entry = DTy; 3281afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner} 3292f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner 330e76c57ad467ed57f09f2a3ef51628d4b6eb2b304Chris Lattner 3314c00e53b81de81ecf4ba0c4e287ea230c79e82aeChris Lattner 3321afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner//===----------------------------------------------------------------------===// 3331afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner// ModuleLinker implementation. 3341afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner//===----------------------------------------------------------------------===// 3354c00e53b81de81ecf4ba0c4e287ea230c79e82aeChris Lattner 3361afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnernamespace { 3371afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// ModuleLinker - This is an implementation class for the LinkModules 3381afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// function, which is the entrypoint for this file. 3391afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner class ModuleLinker { 3401afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Module *DstM, *SrcM; 3411afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 3421afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner TypeMapTy TypeMap; 3431afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 3441afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// ValueMap - Mapping of values from what they used to be in Src, to what 3451afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// they are now in DstM. ValueToValueMapTy is a ValueMap, which involves 3461afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// some overhead due to the use of Value handles which the Linker doesn't 3471afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// actually need, but this allows us to reuse the ValueMapper code. 3481afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ValueToValueMapTy ValueMap; 3491afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 3501afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner struct AppendingVarInfo { 3511afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner GlobalVariable *NewGV; // New aggregate global in dest module. 3521afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Constant *DstInit; // Old initializer from dest module. 3531afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Constant *SrcInit; // Old initializer from src module. 3541afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner }; 3551afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 3561afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner std::vector<AppendingVarInfo> AppendingVars; 3571afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 358f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner unsigned Mode; // Mode to treat source module. 359f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner 360f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner // Set of items not to link in from source. 361f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner SmallPtrSet<const Value*, 16> DoNotLinkFromSource; 362f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner 3639af37a3de8c8688adae383471379f0216287ce28Tanya Lattner // Vector of functions to lazily link in. 3649af37a3de8c8688adae383471379f0216287ce28Tanya Lattner std::vector<Function*> LazilyLinkFunctions; 3659af37a3de8c8688adae383471379f0216287ce28Tanya Lattner 3661afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner public: 3671afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner std::string ErrorMsg; 3681afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 369f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner ModuleLinker(Module *dstM, Module *srcM, unsigned mode) 370f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner : DstM(dstM), SrcM(srcM), Mode(mode) { } 3711afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 3721afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner bool run(); 3731afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 3741afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner private: 3751afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// emitError - Helper method for setting a message and returning an error 3761afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// code. 3771afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner bool emitError(const Twine &Message) { 3781afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ErrorMsg = Message.str(); 3791afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return true; 3801afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 3811afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 3821afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// getLinkageResult - This analyzes the two global values and determines 3831afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// what the result will look like in the destination module. 3841afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner bool getLinkageResult(GlobalValue *Dest, const GlobalValue *Src, 3853ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola GlobalValue::LinkageTypes <, 3863ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola GlobalValue::VisibilityTypes &Vis, 3873ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola bool &LinkFromSrc); 3881afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 3891afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// getLinkedToGlobal - Given a global in the source module, return the 3901afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /// global in the destination module that is being linked to, if any. 3911afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner GlobalValue *getLinkedToGlobal(GlobalValue *SrcGV) { 3921afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If the source has no name it can't link. If it has local linkage, 3931afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // there is no name match-up going on. 3941afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!SrcGV->hasName() || SrcGV->hasLocalLinkage()) 3951afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return 0; 3961afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 3971afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Otherwise see if we have a match in the destination module's symtab. 3981afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner GlobalValue *DGV = DstM->getNamedValue(SrcGV->getName()); 3991afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DGV == 0) return 0; 4001afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 4011afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If we found a global with the same name in the dest module, but it has 4021afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // internal linkage, we are really not doing any linkage here. 4031afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DGV->hasLocalLinkage()) 4041afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return 0; 4051afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 4061afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Otherwise, we do in fact link to the destination global. 4071afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return DGV; 4081afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 4091afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 4101afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner void computeTypeMapping(); 411d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling bool categorizeModuleFlagNodes(const NamedMDNode *ModFlags, 412d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DenseMap<MDString*, MDNode*> &ErrorNode, 413d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DenseMap<MDString*, MDNode*> &WarningNode, 414d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DenseMap<MDString*, MDNode*> &OverrideNode, 415d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DenseMap<MDString*, 416d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling SmallSetVector<MDNode*, 8> > &RequireNodes, 417d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling SmallSetVector<MDString*, 16> &SeenIDs); 4181afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 4191afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner bool linkAppendingVarProto(GlobalVariable *DstGV, GlobalVariable *SrcGV); 4201afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner bool linkGlobalProto(GlobalVariable *SrcGV); 4211afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner bool linkFunctionProto(Function *SrcF); 4221afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner bool linkAliasProto(GlobalAlias *SrcA); 423d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling bool linkModuleFlagsMetadata(); 4241afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 4251afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner void linkAppendingVarInit(const AppendingVarInfo &AVI); 4261afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner void linkGlobalInits(); 4271afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner void linkFunctionBody(Function *Dst, Function *Src); 4281afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner void linkAliasBodies(); 4291afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner void linkNamedMDNodes(); 4301afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner }; 4312c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner} 4322c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 4331afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 4341afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 4351afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// forceRenaming - The LLVM SymbolTable class autorenames globals that conflict 4368bef0373f1b8fab20b9acd277377ca01d72bac7eReid Spencer/// in the symbol table. This is good for all clients except for us. Go 4378bef0373f1b8fab20b9acd277377ca01d72bac7eReid Spencer/// through the trouble to force this back. 4381afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnerstatic void forceRenaming(GlobalValue *GV, StringRef Name) { 4391afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If the global doesn't force its name or if it already has the right name, 4401afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // there is nothing for us to do. 4411afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (GV->hasLocalLinkage() || GV->getName() == Name) 4421afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return; 4431afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 4441afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Module *M = GV->getParent(); 445c003628a612d3687fb77088a5894314210a65385Chris Lattner 446c003628a612d3687fb77088a5894314210a65385Chris Lattner // If there is a conflict, rename the conflict. 4471afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (GlobalValue *ConflictGV = M->getNamedValue(Name)) { 44833f294930e0affa51c3818405741abd80cc90316Chris Lattner GV->takeName(ConflictGV); 44933f294930e0affa51c3818405741abd80cc90316Chris Lattner ConflictGV->setName(Name); // This will cause ConflictGV to get renamed 4501afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner assert(ConflictGV->getName() != Name && "forceRenaming didn't work"); 45133f294930e0affa51c3818405741abd80cc90316Chris Lattner } else { 45233f294930e0affa51c3818405741abd80cc90316Chris Lattner GV->setName(Name); // Force the name back 453ef9b9a793949469cdaa4ab6d0173136229dcab7bReid Spencer } 454ef9b9a793949469cdaa4ab6d0173136229dcab7bReid Spencer} 455ef9b9a793949469cdaa4ab6d0173136229dcab7bReid Spencer 456ef9b9a793949469cdaa4ab6d0173136229dcab7bReid Spencer/// CopyGVAttributes - copy additional attributes (those not needed to construct 457eba2cb0d5aef5a8229facae5624c65d9fd65e9d1Mikhail Glushenkov/// a GlobalValue) from the SrcGV to the DestGV. 458ef9b9a793949469cdaa4ab6d0173136229dcab7bReid Spencerstatic void CopyGVAttributes(GlobalValue *DestGV, const GlobalValue *SrcGV) { 45928c3cff8250b3fe2adc6479306fe7dbdb48a1bdbDuncan Sands // Use the maximum alignment, rather than just copying the alignment of SrcGV. 46028c3cff8250b3fe2adc6479306fe7dbdb48a1bdbDuncan Sands unsigned Alignment = std::max(DestGV->getAlignment(), SrcGV->getAlignment()); 46128c3cff8250b3fe2adc6479306fe7dbdb48a1bdbDuncan Sands DestGV->copyAttributesFrom(SrcGV); 46228c3cff8250b3fe2adc6479306fe7dbdb48a1bdbDuncan Sands DestGV->setAlignment(Alignment); 4631afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 4641afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner forceRenaming(DestGV, SrcGV->getName()); 465c003628a612d3687fb77088a5894314210a65385Chris Lattner} 466c003628a612d3687fb77088a5894314210a65385Chris Lattner 4673ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindolastatic bool isLessConstraining(GlobalValue::VisibilityTypes a, 4683ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola GlobalValue::VisibilityTypes b) { 4693ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola if (a == GlobalValue::HiddenVisibility) 4703ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola return false; 4713ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola if (b == GlobalValue::HiddenVisibility) 4723ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola return true; 4733ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola if (a == GlobalValue::ProtectedVisibility) 4743ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola return false; 4753ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola if (b == GlobalValue::ProtectedVisibility) 4763ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola return true; 4773ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola return false; 4783ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola} 4793ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola 4801afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// getLinkageResult - This analyzes the two global values and determines what 481aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner/// the result will look like in the destination module. In particular, it 4823ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola/// computes the resultant linkage type and visibility, computes whether the 4833ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola/// global in the source should be copied over to the destination (replacing 4843ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola/// the existing one), and computes whether this linkage is an error or not. 4851afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnerbool ModuleLinker::getLinkageResult(GlobalValue *Dest, const GlobalValue *Src, 4863ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola GlobalValue::LinkageTypes <, 4873ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola GlobalValue::VisibilityTypes &Vis, 4881afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner bool &LinkFromSrc) { 4891afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner assert(Dest && "Must have two globals being queried"); 4901afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner assert(!Src->hasLocalLinkage() && 491aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner "If Src has internal linkage, Dest shouldn't be set!"); 4921afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 4938895316d0489e2353c0dce289b49f5cdd41085d7Peter Collingbourne bool SrcIsDeclaration = Src->isDeclaration() && !Src->isMaterializable(); 494f84c59d1100af416a70e475eb25741e27f3bb832Chris Lattner bool DestIsDeclaration = Dest->isDeclaration(); 4951afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 4961afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (SrcIsDeclaration) { 4972b48ef0450944c2c46633aec9baf6be835a3b503Anton Korobeynikov // If Src is external or if both Src & Dest are external.. Just link the 498aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner // external globals, we aren't adding anything. 499b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov if (Src->hasDLLImportLinkage()) { 50078ee7b78c3c47b71c4b7a1475438d6574216a64bAnton Korobeynikov // If one of GVs has DLLImport linkage, result should be dllimport'ed. 5011afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DestIsDeclaration) { 502b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov LinkFromSrc = true; 503b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov LT = Src->getLinkage(); 504eba2cb0d5aef5a8229facae5624c65d9fd65e9d1Mikhail Glushenkov } 5058753c447a5f8eec1421331c40ffbb72c6d411f78Andrew Lenharth } else if (Dest->hasExternalWeakLinkage()) { 506667d4b8de6dea70195ff12ef39a4deebffa2f5c7Duncan Sands // If the Dest is weak, use the source linkage. 5078753c447a5f8eec1421331c40ffbb72c6d411f78Andrew Lenharth LinkFromSrc = true; 5088753c447a5f8eec1421331c40ffbb72c6d411f78Andrew Lenharth LT = Src->getLinkage(); 509b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov } else { 510b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov LinkFromSrc = false; 511b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov LT = Dest->getLinkage(); 512b74ed07bfd3af42331b1964c24c39912610a08f4Anton Korobeynikov } 5131afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } else if (DestIsDeclaration && !Dest->hasDLLImportLinkage()) { 514aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner // If Dest is external but Src is not: 515aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner LinkFromSrc = true; 516aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner LT = Src->getLinkage(); 517a05ef5e107943478ad02bc0cd5170a3894076bc4Duncan Sands } else if (Src->isWeakForLinker()) { 518aafce77b17d340aace52bcd49d1944109d82f14aDale Johannesen // At this point we know that Dest has LinkOnce, External*, Weak, Common, 519aafce77b17d340aace52bcd49d1944109d82f14aDale Johannesen // or DLL* linkage. 520266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner if (Dest->hasExternalWeakLinkage() || 521266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner Dest->hasAvailableExternallyLinkage() || 522266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner (Dest->hasLinkOnceLinkage() && 523266c7bbbbcc4b326dea82e577de1a415d6acc23eChris Lattner (Src->hasWeakLinkage() || Src->hasCommonLinkage()))) { 524aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner LinkFromSrc = true; 525aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner LT = Src->getLinkage(); 526aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner } else { 527aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner LinkFromSrc = false; 528aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner LT = Dest->getLinkage(); 529aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner } 530a05ef5e107943478ad02bc0cd5170a3894076bc4Duncan Sands } else if (Dest->isWeakForLinker()) { 53178ee7b78c3c47b71c4b7a1475438d6574216a64bAnton Korobeynikov // At this point we know that Src has External* or DLL* linkage. 53278ee7b78c3c47b71c4b7a1475438d6574216a64bAnton Korobeynikov if (Src->hasExternalWeakLinkage()) { 53378ee7b78c3c47b71c4b7a1475438d6574216a64bAnton Korobeynikov LinkFromSrc = false; 53478ee7b78c3c47b71c4b7a1475438d6574216a64bAnton Korobeynikov LT = Dest->getLinkage(); 53578ee7b78c3c47b71c4b7a1475438d6574216a64bAnton Korobeynikov } else { 53678ee7b78c3c47b71c4b7a1475438d6574216a64bAnton Korobeynikov LinkFromSrc = true; 53778ee7b78c3c47b71c4b7a1475438d6574216a64bAnton Korobeynikov LT = GlobalValue::ExternalLinkage; 53878ee7b78c3c47b71c4b7a1475438d6574216a64bAnton Korobeynikov } 539aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner } else { 5401afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner assert((Dest->hasExternalLinkage() || Dest->hasDLLImportLinkage() || 5411afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Dest->hasDLLExportLinkage() || Dest->hasExternalWeakLinkage()) && 5421afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner (Src->hasExternalLinkage() || Src->hasDLLImportLinkage() || 5431afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Src->hasDLLExportLinkage() || Src->hasExternalWeakLinkage()) && 544aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner "Unexpected linkage type!"); 5451afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return emitError("Linking globals named '" + Src->getName() + 546aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner "': symbol multiply defined!"); 547aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner } 5489cd3ccf5065a8a139e458d016c88a8512471598bAnton Korobeynikov 5493ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola // Compute the visibility. We follow the rules in the System V Application 5503ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola // Binary Interface. 5513ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola Vis = isLessConstraining(Src->getVisibility(), Dest->getVisibility()) ? 5523ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola Dest->getVisibility() : Src->getVisibility(); 553aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner return false; 554aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner} 5555c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 5561afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// computeTypeMapping - Loop over all of the linked values to compute type 5571afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// mappings. For example, if we link "extern Foo *x" and "Foo *x = NULL", then 5581afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// we have two struct types 'Foo' but one got renamed when the module was 5591afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// loaded into the same LLVMContext. 5601afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnervoid ModuleLinker::computeTypeMapping() { 5611afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Incorporate globals. 5621afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (Module::global_iterator I = SrcM->global_begin(), 5631afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner E = SrcM->global_end(); I != E; ++I) { 5641afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner GlobalValue *DGV = getLinkedToGlobal(I); 5651afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DGV == 0) continue; 5661afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 5671afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!DGV->hasAppendingLinkage() || !I->hasAppendingLinkage()) { 5681afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner TypeMap.addTypeMapping(DGV->getType(), I->getType()); 5691afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner continue; 5701afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 5711afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 5721afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Unify the element type of appending arrays. 5731afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ArrayType *DAT = cast<ArrayType>(DGV->getType()->getElementType()); 5741afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ArrayType *SAT = cast<ArrayType>(I->getType()->getElementType()); 5751afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner TypeMap.addTypeMapping(DAT->getElementType(), SAT->getElementType()); 576ab67e705f59d567afded845465f358b8a66ab62eDevang Patel } 5771afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 5781afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Incorporate functions. 5791afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (Module::iterator I = SrcM->begin(), E = SrcM->end(); I != E; ++I) { 5801afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (GlobalValue *DGV = getLinkedToGlobal(I)) 5811afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner TypeMap.addTypeMapping(DGV->getType(), I->getType()); 5821afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 583c68d127b2c5a233c5e3f9dd59ca4ab335419d9ddBill Wendling 584c68d127b2c5a233c5e3f9dd59ca4ab335419d9ddBill Wendling#if 0 585c68d127b2c5a233c5e3f9dd59ca4ab335419d9ddBill Wendling // FIXME: This doesn't play well with LTO. We cannot compile LLVM with this 586c68d127b2c5a233c5e3f9dd59ca4ab335419d9ddBill Wendling // enabled. <rdar://problem/10913281>. 587c68d127b2c5a233c5e3f9dd59ca4ab335419d9ddBill Wendling 588ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner // Incorporate types by name, scanning all the types in the source module. 589ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner // At this point, the destination module may have a type "%foo = { i32 }" for 590ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner // example. When the source module got loaded into the same LLVMContext, if 591ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner // it had the same type, it would have been renamed to "%foo.42 = { i32 }". 592ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner // Though it isn't required for correctness, attempt to link these up to clean 593ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner // up the IR. 594ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner std::vector<StructType*> SrcStructTypes; 595ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner SrcM->findUsedStructTypes(SrcStructTypes); 596ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner 5971a31f3b90c012b067f8509546e1e037051e6482dChris Lattner SmallPtrSet<StructType*, 32> SrcStructTypesSet(SrcStructTypes.begin(), 5981a31f3b90c012b067f8509546e1e037051e6482dChris Lattner SrcStructTypes.end()); 5991a31f3b90c012b067f8509546e1e037051e6482dChris Lattner 600ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner for (unsigned i = 0, e = SrcStructTypes.size(); i != e; ++i) { 601ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner StructType *ST = SrcStructTypes[i]; 602ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner if (!ST->hasName()) continue; 603ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner 604ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner // Check to see if there is a dot in the name followed by a digit. 605ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner size_t DotPos = ST->getName().rfind('.'); 606ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner if (DotPos == 0 || DotPos == StringRef::npos || 607ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner ST->getName().back() == '.' || !isdigit(ST->getName()[DotPos+1])) 608ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner continue; 609ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner 610ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner // Check to see if the destination module has a struct with the prefix name. 611ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner if (StructType *DST = DstM->getTypeByName(ST->getName().substr(0, DotPos))) 6121a31f3b90c012b067f8509546e1e037051e6482dChris Lattner // Don't use it if this actually came from the source module. They're in 6131a31f3b90c012b067f8509546e1e037051e6482dChris Lattner // the same LLVMContext after all. 6141a31f3b90c012b067f8509546e1e037051e6482dChris Lattner if (!SrcStructTypesSet.count(DST)) 6151a31f3b90c012b067f8509546e1e037051e6482dChris Lattner TypeMap.addTypeMapping(DST, ST); 616ea93373a0a1bf1d087f5414e566384c2af3ebf09Chris Lattner } 617c68d127b2c5a233c5e3f9dd59ca4ab335419d9ddBill Wendling#endif 618c68d127b2c5a233c5e3f9dd59ca4ab335419d9ddBill Wendling 6191afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Don't bother incorporating aliases, they aren't generally typed well. 6201afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 6211afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Now that we have discovered all of the type equivalences, get a body for 6221afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // any 'opaque' types in the dest module that are now resolved. 6231afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner TypeMap.linkDefinedTypeBodies(); 624ab67e705f59d567afded845465f358b8a66ab62eDevang Patel} 625ab67e705f59d567afded845465f358b8a66ab62eDevang Patel 6261afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// linkAppendingVarProto - If there were any appending global variables, link 6271afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// them together now. Return true on error. 6281afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnerbool ModuleLinker::linkAppendingVarProto(GlobalVariable *DstGV, 6291afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner GlobalVariable *SrcGV) { 6301afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 6311afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!SrcGV->hasAppendingLinkage() || !DstGV->hasAppendingLinkage()) 6321afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return emitError("Linking globals named '" + SrcGV->getName() + 6331afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner "': can only link appending global with another appending global!"); 6341afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 6351afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ArrayType *DstTy = cast<ArrayType>(DstGV->getType()->getElementType()); 6361afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ArrayType *SrcTy = 6371afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner cast<ArrayType>(TypeMap.get(SrcGV->getType()->getElementType())); 6381afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Type *EltTy = DstTy->getElementType(); 6391afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 6401afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Check to see that they two arrays agree on type. 6411afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (EltTy != SrcTy->getElementType()) 6421afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return emitError("Appending variables with different element types!"); 6431afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DstGV->isConstant() != SrcGV->isConstant()) 6441afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return emitError("Appending variables linked with different const'ness!"); 6451afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 6461afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DstGV->getAlignment() != SrcGV->getAlignment()) 6471afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return emitError( 6481afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner "Appending variables with different alignment need to be linked!"); 6491afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 6501afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DstGV->getVisibility() != SrcGV->getVisibility()) 6511afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return emitError( 6521afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner "Appending variables with different visibility need to be linked!"); 6531afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 6541afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DstGV->getSection() != SrcGV->getSection()) 6551afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return emitError( 6561afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner "Appending variables with different section name need to be linked!"); 6571afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 6581afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner uint64_t NewSize = DstTy->getNumElements() + SrcTy->getNumElements(); 6591afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ArrayType *NewType = ArrayType::get(EltTy, NewSize); 6601afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 6611afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Create the new global variable. 6621afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner GlobalVariable *NG = 6631afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner new GlobalVariable(*DstGV->getParent(), NewType, SrcGV->isConstant(), 6641afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DstGV->getLinkage(), /*init*/0, /*name*/"", DstGV, 6651afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DstGV->isThreadLocal(), 6661afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DstGV->getType()->getAddressSpace()); 6671afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 6681afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Propagate alignment, visibility and section info. 6691afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner CopyGVAttributes(NG, DstGV); 6701afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 6711afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner AppendingVarInfo AVI; 6721afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner AVI.NewGV = NG; 6731afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner AVI.DstInit = DstGV->getInitializer(); 6741afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner AVI.SrcInit = SrcGV->getInitializer(); 6751afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner AppendingVars.push_back(AVI); 6761afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 6771afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Replace any uses of the two global variables with uses of the new 6781afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // global. 6791afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ValueMap[SrcGV] = ConstantExpr::getBitCast(NG, TypeMap.get(SrcGV->getType())); 6801afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 6811afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DstGV->replaceAllUsesWith(ConstantExpr::getBitCast(NG, DstGV->getType())); 6821afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DstGV->eraseFromParent(); 6831afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 684f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner // Track the source variable so we don't try to link it. 685f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner DoNotLinkFromSource.insert(SrcGV); 686f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner 6871afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return false; 6881afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner} 6895c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 6901afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// linkGlobalProto - Loop through the global variables in the src module and 6911afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// merge them into the dest module. 6921afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnerbool ModuleLinker::linkGlobalProto(GlobalVariable *SGV) { 6931afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner GlobalValue *DGV = getLinkedToGlobal(SGV); 6943ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola llvm::Optional<GlobalValue::VisibilityTypes> NewVisibility; 6951afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 6961afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DGV) { 6971afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Concatenation of appending linkage variables is magic and handled later. 6981afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DGV->hasAppendingLinkage() || SGV->hasAppendingLinkage()) 6991afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return linkAppendingVarProto(cast<GlobalVariable>(DGV), SGV); 7001afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 7011afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Determine whether linkage of these two globals follows the source 7021afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // module's definition or the destination module's definition. 703b324bd735ff5c99a52cd3c3f5d01c0e1398a2d3aChris Lattner GlobalValue::LinkageTypes NewLinkage = GlobalValue::InternalLinkage; 7043ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola GlobalValue::VisibilityTypes NV; 705b324bd735ff5c99a52cd3c3f5d01c0e1398a2d3aChris Lattner bool LinkFromSrc = false; 7063ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola if (getLinkageResult(DGV, SGV, NewLinkage, NV, LinkFromSrc)) 707aee38ea5698fd770bb41d01d06542cb849e131a4Chris Lattner return true; 7083ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola NewVisibility = NV; 7090fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner 7101afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If we're not linking from the source, then keep the definition that we 7111afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // have. 7121afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!LinkFromSrc) { 7131afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Special case for const propagation. 7141afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (GlobalVariable *DGVar = dyn_cast<GlobalVariable>(DGV)) 7151afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DGVar->isDeclaration() && SGV->isConstant() && !DGVar->isConstant()) 7161afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DGVar->setConstant(true); 7171afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 7183ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola // Set calculated linkage and visibility. 7191afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DGV->setLinkage(NewLinkage); 7203ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola DGV->setVisibility(*NewVisibility); 7213ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola 7226157e383c4a15ffb6e7f27cdb153daa9caa15ca5Chris Lattner // Make sure to remember this mapping. 7231afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ValueMap[SGV] = ConstantExpr::getBitCast(DGV,TypeMap.get(SGV->getType())); 7241afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 725f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner // Track the source global so that we don't attempt to copy it over when 726f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner // processing global initializers. 727f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner DoNotLinkFromSource.insert(SGV); 728f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner 7291afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return false; 7306157e383c4a15ffb6e7f27cdb153daa9caa15ca5Chris Lattner } 7315c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 7321afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 7331afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // No linking to be performed or linking from the source: simply create an 7341afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // identical version of the symbol over in the dest module... the 7351afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // initializer will be filled in later by LinkGlobalInits. 7361afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner GlobalVariable *NewDGV = 7371afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner new GlobalVariable(*DstM, TypeMap.get(SGV->getType()->getElementType()), 7381afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SGV->isConstant(), SGV->getLinkage(), /*init*/0, 7391afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SGV->getName(), /*insertbefore*/0, 7401afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SGV->isThreadLocal(), 7411afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SGV->getType()->getAddressSpace()); 7421afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Propagate alignment, visibility and section info. 7431afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner CopyGVAttributes(NewDGV, SGV); 7443ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola if (NewVisibility) 7453ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola NewDGV->setVisibility(*NewVisibility); 7461afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 7471afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DGV) { 7481afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DGV->replaceAllUsesWith(ConstantExpr::getBitCast(NewDGV, DGV->getType())); 7491afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DGV->eraseFromParent(); 75058887bc59316bcaf0c0675a45ddecd6994f3fbc6Anton Korobeynikov } 7511afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 7521afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Make sure to remember this mapping. 7531afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ValueMap[SGV] = NewDGV; 75431ed0fb804dd86fb15093e114701932119914400Lauro Ramos Venancio return false; 75531ed0fb804dd86fb15093e114701932119914400Lauro Ramos Venancio} 75631ed0fb804dd86fb15093e114701932119914400Lauro Ramos Venancio 7571afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// linkFunctionProto - Link the function in the source module into the 7581afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// destination module if needed, setting up mapping information. 7591afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnerbool ModuleLinker::linkFunctionProto(Function *SF) { 7601afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner GlobalValue *DGV = getLinkedToGlobal(SF); 7613ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola llvm::Optional<GlobalValue::VisibilityTypes> NewVisibility; 7625c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 7631afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DGV) { 7641afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner GlobalValue::LinkageTypes NewLinkage = GlobalValue::InternalLinkage; 7651afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner bool LinkFromSrc = false; 7663ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola GlobalValue::VisibilityTypes NV; 7673ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola if (getLinkageResult(DGV, SF, NewLinkage, NV, LinkFromSrc)) 7681afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return true; 7693ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola NewVisibility = NV; 7703ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola 7711afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!LinkFromSrc) { 7721afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Set calculated linkage 7731afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DGV->setLinkage(NewLinkage); 7743ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola DGV->setVisibility(*NewVisibility); 7753ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola 7761afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Make sure to remember this mapping. 7771afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ValueMap[SF] = ConstantExpr::getBitCast(DGV, TypeMap.get(SF->getType())); 7781afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 779f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner // Track the function from the source module so we don't attempt to remap 780f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner // it. 781f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner DoNotLinkFromSource.insert(SF); 782f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner 7831afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return false; 7848d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 7858d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 7861afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 7871afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If there is no linkage to be performed or we are linking from the source, 7881afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // bring SF over. 7891afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Function *NewDF = Function::Create(TypeMap.get(SF->getFunctionType()), 7901afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SF->getLinkage(), SF->getName(), DstM); 7911afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner CopyGVAttributes(NewDF, SF); 7923ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola if (NewVisibility) 7933ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola NewDF->setVisibility(*NewVisibility); 7941afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 7951afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DGV) { 7961afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Any uses of DF need to change to NewDF, with cast. 7971afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DGV->replaceAllUsesWith(ConstantExpr::getBitCast(NewDF, DGV->getType())); 7981afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DGV->eraseFromParent(); 7999af37a3de8c8688adae383471379f0216287ce28Tanya Lattner } else { 8009af37a3de8c8688adae383471379f0216287ce28Tanya Lattner // Internal, LO_ODR, or LO linkage - stick in set to ignore and lazily link. 8019af37a3de8c8688adae383471379f0216287ce28Tanya Lattner if (SF->hasLocalLinkage() || SF->hasLinkOnceLinkage() || 8029af37a3de8c8688adae383471379f0216287ce28Tanya Lattner SF->hasAvailableExternallyLinkage()) { 8039af37a3de8c8688adae383471379f0216287ce28Tanya Lattner DoNotLinkFromSource.insert(SF); 8049af37a3de8c8688adae383471379f0216287ce28Tanya Lattner LazilyLinkFunctions.push_back(SF); 8059af37a3de8c8688adae383471379f0216287ce28Tanya Lattner } 8061afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 8071afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 8081afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ValueMap[SF] = NewDF; 8098d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return false; 8108d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner} 8115c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 8121afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// LinkAliasProto - Set up prototypes for any aliases that come over from the 8131afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// source module. 8141afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnerbool ModuleLinker::linkAliasProto(GlobalAlias *SGA) { 8151afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner GlobalValue *DGV = getLinkedToGlobal(SGA); 8163ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola llvm::Optional<GlobalValue::VisibilityTypes> NewVisibility; 8173ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola 8181afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DGV) { 8196157e383c4a15ffb6e7f27cdb153daa9caa15ca5Chris Lattner GlobalValue::LinkageTypes NewLinkage = GlobalValue::InternalLinkage; 8203ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola GlobalValue::VisibilityTypes NV; 8216157e383c4a15ffb6e7f27cdb153daa9caa15ca5Chris Lattner bool LinkFromSrc = false; 8223ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola if (getLinkageResult(DGV, SGA, NewLinkage, NV, LinkFromSrc)) 8236157e383c4a15ffb6e7f27cdb153daa9caa15ca5Chris Lattner return true; 8243ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola NewVisibility = NV; 8253ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola 8261afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!LinkFromSrc) { 8271afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Set calculated linkage. 8281afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DGV->setLinkage(NewLinkage); 8293ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola DGV->setVisibility(*NewVisibility); 8303ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola 8311afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Make sure to remember this mapping. 8321afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ValueMap[SGA] = ConstantExpr::getBitCast(DGV,TypeMap.get(SGA->getType())); 8331afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 834f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner // Track the alias from the source module so we don't attempt to remap it. 835f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner DoNotLinkFromSource.insert(SGA); 836f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner 8371afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return false; 838822143e6f7271c6546434d2d0b3da7a29711020dChris Lattner } 8391afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 8401afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 8411afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If there is no linkage to be performed or we're linking from the source, 8421afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // bring over SGA. 8431afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner GlobalAlias *NewDA = new GlobalAlias(TypeMap.get(SGA->getType()), 8441afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SGA->getLinkage(), SGA->getName(), 8451afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner /*aliasee*/0, DstM); 8461afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner CopyGVAttributes(NewDA, SGA); 8473ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola if (NewVisibility) 8483ed8815541d2118728a91bbd5bee054fbcfba71fRafael Espindola NewDA->setVisibility(*NewVisibility); 8491afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 8501afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DGV) { 8511afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Any uses of DGV need to change to NewDA, with cast. 8521afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DGV->replaceAllUsesWith(ConstantExpr::getBitCast(NewDA, DGV->getType())); 8531afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DGV->eraseFromParent(); 8541afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 8551afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 8561afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ValueMap[SGA] = NewDA; 8571afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return false; 8581afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner} 859eba2cb0d5aef5a8229facae5624c65d9fd65e9d1Mikhail Glushenkov 8601ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattnerstatic void getArrayElements(Constant *C, SmallVectorImpl<Constant*> &Dest) { 861a1f00f4d488eb5daff52faaf99c62ee652fd3b85Chris Lattner unsigned NumElements = cast<ArrayType>(C->getType())->getNumElements(); 862a1f00f4d488eb5daff52faaf99c62ee652fd3b85Chris Lattner 863a1f00f4d488eb5daff52faaf99c62ee652fd3b85Chris Lattner for (unsigned i = 0; i != NumElements; ++i) 864a1f00f4d488eb5daff52faaf99c62ee652fd3b85Chris Lattner Dest.push_back(C->getAggregateElement(i)); 8651ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner} 8661ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner 8671afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnervoid ModuleLinker::linkAppendingVarInit(const AppendingVarInfo &AVI) { 8681afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Merge the initializer. 8691afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SmallVector<Constant*, 16> Elements; 8701ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner getArrayElements(AVI.DstInit, Elements); 8711afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 8721afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Constant *SrcInit = MapValue(AVI.SrcInit, ValueMap, RF_None, &TypeMap); 8731ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner getArrayElements(SrcInit, Elements); 8741ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner 8751afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner ArrayType *NewType = cast<ArrayType>(AVI.NewGV->getType()->getElementType()); 8761afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner AVI.NewGV->setInitializer(ConstantArray::get(NewType, Elements)); 8771afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner} 8786157e383c4a15ffb6e7f27cdb153daa9caa15ca5Chris Lattner 8796157e383c4a15ffb6e7f27cdb153daa9caa15ca5Chris Lattner 8801afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner// linkGlobalInits - Update the initializers in the Dest module now that all 8811afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner// globals that may be referenced are in Dest. 8821afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnervoid ModuleLinker::linkGlobalInits() { 8831afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Loop over all of the globals in the src module, mapping them over as we go 8841afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (Module::const_global_iterator I = SrcM->global_begin(), 8851afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner E = SrcM->global_end(); I != E; ++I) { 886f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner 887f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner // Only process initialized GV's or ones not already in dest. 888f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner if (!I->hasInitializer() || DoNotLinkFromSource.count(I)) continue; 8891afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 8901afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Grab destination global variable. 8911afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner GlobalVariable *DGV = cast<GlobalVariable>(ValueMap[I]); 8921afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Figure out what the initializer looks like in the dest module. 8931afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DGV->setInitializer(MapValue(I->getInitializer(), ValueMap, 8941afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner RF_None, &TypeMap)); 8955c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 8965c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 8975c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 8981afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner// linkFunctionBody - Copy the source function over into the dest function and 899c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// fix up references to values. At this point we know that Dest is an external 900c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// function, and that Src is not. 9011afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnervoid ModuleLinker::linkFunctionBody(Function *Dst, Function *Src) { 9021afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner assert(Src && Dst && Dst->isDeclaration() && !Src->isDeclaration()); 9035c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 9040033baf94e049e075f3ba4700c109779e2d7c131Chris Lattner // Go through and convert function arguments over, remembering the mapping. 9051afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Function::arg_iterator DI = Dst->arg_begin(); 906e4d5c441e04bdc00ccf1804744af670655123b07Chris Lattner for (Function::arg_iterator I = Src->arg_begin(), E = Src->arg_end(); 90769da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner I != E; ++I, ++DI) { 9081afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DI->setName(I->getName()); // Copy the name over. 9095c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 9101afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Add a mapping to our mapping. 911817bf2aeb22db13d03beb15e9bf17c425d0c694dAnton Korobeynikov ValueMap[I] = DI; 9125c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 9135c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 914f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner if (Mode == Linker::DestroySource) { 915f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner // Splice the body of the source function into the dest function. 916f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner Dst->getBasicBlockList().splice(Dst->end(), Src->getBasicBlockList()); 917f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner 918f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner // At this point, all of the instructions and values of the function are now 919f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner // copied over. The only problem is that they are still referencing values in 920f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner // the Source function as operands. Loop through all of the operands of the 921f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner // functions and patch them up to point to the local versions. 922f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner for (Function::iterator BB = Dst->begin(), BE = Dst->end(); BB != BE; ++BB) 923f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 924f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner RemapInstruction(I, ValueMap, RF_IgnoreMissingEntries, &TypeMap); 925f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner 926f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner } else { 927f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner // Clone the body of the function into the dest function. 928f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner SmallVector<ReturnInst*, 8> Returns; // Ignore returns. 929d24397a9319a41e80169f572ad274a711f41d64eMon P Wang CloneFunctionInto(Dst, Src, ValueMap, false, Returns, "", NULL, &TypeMap); 930f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner } 931f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner 9320033baf94e049e075f3ba4700c109779e2d7c131Chris Lattner // There is no need to map the arguments anymore. 9331127315562b221010040925980040fd4f65bdb1cChris Lattner for (Function::arg_iterator I = Src->arg_begin(), E = Src->arg_end(); 9341127315562b221010040925980040fd4f65bdb1cChris Lattner I != E; ++I) 935ef9b9a793949469cdaa4ab6d0173136229dcab7bReid Spencer ValueMap.erase(I); 936f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner 9375c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 9385c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 9395c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 9401afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnervoid ModuleLinker::linkAliasBodies() { 9411afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (Module::alias_iterator I = SrcM->alias_begin(), E = SrcM->alias_end(); 942f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner I != E; ++I) { 943f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner if (DoNotLinkFromSource.count(I)) 944f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner continue; 9451afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (Constant *Aliasee = I->getAliasee()) { 9461afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner GlobalAlias *DA = cast<GlobalAlias>(ValueMap[I]); 9471afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DA->setAliasee(MapValue(Aliasee, ValueMap, RF_None, &TypeMap)); 948c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner } 949f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner } 9505c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 9515c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 9521afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// linkNamedMDNodes - Insert all of the named mdnodes in Src into the Dest 9531afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// module. 9541afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnervoid ModuleLinker::linkNamedMDNodes() { 955d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata(); 9561afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (Module::const_named_metadata_iterator I = SrcM->named_metadata_begin(), 9571afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner E = SrcM->named_metadata_end(); I != E; ++I) { 958d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling // Don't link module flags here. Do them separately. 959d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling if (&*I == SrcModFlags) continue; 9601afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner NamedMDNode *DestNMD = DstM->getOrInsertNamedMetadata(I->getName()); 9611afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Add Src elements into Dest node. 9621afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i) 9631afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DestNMD->addOperand(MapValue(I->getOperand(i), ValueMap, 9641afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner RF_None, &TypeMap)); 9658166e6eef6518da6f1f805e0d5e2bb22c15dd49cChris Lattner } 9668166e6eef6518da6f1f805e0d5e2bb22c15dd49cChris Lattner} 967d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 968d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling/// categorizeModuleFlagNodes - 969d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendlingbool ModuleLinker:: 970d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill WendlingcategorizeModuleFlagNodes(const NamedMDNode *ModFlags, 971d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DenseMap<MDString*, MDNode*> &ErrorNode, 972d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DenseMap<MDString*, MDNode*> &WarningNode, 973d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DenseMap<MDString*, MDNode*> &OverrideNode, 974d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DenseMap<MDString*, 975d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling SmallSetVector<MDNode*, 8> > &RequireNodes, 976d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling SmallSetVector<MDString*, 16> &SeenIDs) { 977d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling bool HasErr = false; 978d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 979d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling for (unsigned I = 0, E = ModFlags->getNumOperands(); I != E; ++I) { 980d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling MDNode *Op = ModFlags->getOperand(I); 981d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling assert(Op->getNumOperands() == 3 && "Invalid module flag metadata!"); 982d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling assert(isa<ConstantInt>(Op->getOperand(0)) && 983d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling "Module flag's first operand must be an integer!"); 984d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling assert(isa<MDString>(Op->getOperand(1)) && 985d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling "Module flag's second operand must be an MDString!"); 986d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 987d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling ConstantInt *Behavior = cast<ConstantInt>(Op->getOperand(0)); 988d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling MDString *ID = cast<MDString>(Op->getOperand(1)); 989d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling Value *Val = Op->getOperand(2); 990d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling switch (Behavior->getZExtValue()) { 991d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling default: 992d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling assert(false && "Invalid behavior in module flag metadata!"); 993d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling break; 994d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling case Module::Error: { 995d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling MDNode *&ErrNode = ErrorNode[ID]; 996d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling if (!ErrNode) ErrNode = Op; 997d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling if (ErrNode->getOperand(2) != Val) 99875b3d6886762bbbc9e1805793222c29cb39fbd2fBill Wendling HasErr = emitError("linking module flags '" + ID->getString() + 99975b3d6886762bbbc9e1805793222c29cb39fbd2fBill Wendling "': IDs have conflicting values"); 1000d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling break; 1001d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling } 1002d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling case Module::Warning: { 1003d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling MDNode *&WarnNode = WarningNode[ID]; 1004d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling if (!WarnNode) WarnNode = Op; 1005d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling if (WarnNode->getOperand(2) != Val) 100675b3d6886762bbbc9e1805793222c29cb39fbd2fBill Wendling errs() << "WARNING: linking module flags '" << ID->getString() 100775b3d6886762bbbc9e1805793222c29cb39fbd2fBill Wendling << "': IDs have conflicting values"; 1008d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling break; 1009d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling } 1010d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling case Module::Require: RequireNodes[ID].insert(Op); break; 1011d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling case Module::Override: { 1012d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling MDNode *&OvrNode = OverrideNode[ID]; 1013d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling if (!OvrNode) OvrNode = Op; 1014d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling if (OvrNode->getOperand(2) != Val) 101575b3d6886762bbbc9e1805793222c29cb39fbd2fBill Wendling HasErr = emitError("linking module flags '" + ID->getString() + 101675b3d6886762bbbc9e1805793222c29cb39fbd2fBill Wendling "': IDs have conflicting override values"); 1017d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling break; 1018d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling } 1019d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling } 1020d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1021d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling SeenIDs.insert(ID); 1022d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling } 1023d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1024d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling return HasErr; 1025d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling} 1026d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1027d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling/// linkModuleFlagsMetadata - Merge the linker flags in Src into the Dest 1028d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling/// module. 1029d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendlingbool ModuleLinker::linkModuleFlagsMetadata() { 1030d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata(); 1031d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling if (!SrcModFlags) return false; 1032d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1033d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling NamedMDNode *DstModFlags = DstM->getOrInsertModuleFlagsMetadata(); 1034d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1035d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling // If the destination module doesn't have module flags yet, then just copy 1036d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling // over the source module's flags. 1037d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling if (DstModFlags->getNumOperands() == 0) { 1038d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling for (unsigned I = 0, E = SrcModFlags->getNumOperands(); I != E; ++I) 1039d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DstModFlags->addOperand(SrcModFlags->getOperand(I)); 1040d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1041d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling return false; 1042d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling } 1043d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1044d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling bool HasErr = false; 1045d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1046d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling // Otherwise, we have to merge them based on their behaviors. First, 1047d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling // categorize all of the nodes in the modules' module flags. If an error or 1048d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling // warning occurs, then emit the appropriate message(s). 1049d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DenseMap<MDString*, MDNode*> ErrorNode; 1050d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DenseMap<MDString*, MDNode*> WarningNode; 1051d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DenseMap<MDString*, MDNode*> OverrideNode; 1052d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DenseMap<MDString*, SmallSetVector<MDNode*, 8> > RequireNodes; 1053d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling SmallSetVector<MDString*, 16> SeenIDs; 1054d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1055d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling HasErr |= categorizeModuleFlagNodes(SrcModFlags, ErrorNode, WarningNode, 1056d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling OverrideNode, RequireNodes, SeenIDs); 1057d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling HasErr |= categorizeModuleFlagNodes(DstModFlags, ErrorNode, WarningNode, 1058d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling OverrideNode, RequireNodes, SeenIDs); 1059d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1060d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling // Check that there isn't both an error and warning node for a flag. 1061d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling for (SmallSetVector<MDString*, 16>::iterator 1062d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling I = SeenIDs.begin(), E = SeenIDs.end(); I != E; ++I) { 1063d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling MDString *ID = *I; 1064d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling if (ErrorNode[ID] && WarningNode[ID]) 106575b3d6886762bbbc9e1805793222c29cb39fbd2fBill Wendling HasErr = emitError("linking module flags '" + ID->getString() + 1066d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling "': IDs have conflicting behaviors"); 1067d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling } 1068d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1069d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling // Early exit if we had an error. 1070d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling if (HasErr) return true; 1071d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1072d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling // Get the destination's module flags ready for new operands. 1073d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DstModFlags->dropAllReferences(); 1074d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1075d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling // Add all of the module flags to the destination module. 1076d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DenseMap<MDString*, SmallVector<MDNode*, 4> > AddedNodes; 1077d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling for (SmallSetVector<MDString*, 16>::iterator 1078d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling I = SeenIDs.begin(), E = SeenIDs.end(); I != E; ++I) { 1079d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling MDString *ID = *I; 1080d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling if (OverrideNode[ID]) { 1081d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DstModFlags->addOperand(OverrideNode[ID]); 1082d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling AddedNodes[ID].push_back(OverrideNode[ID]); 1083d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling } else if (ErrorNode[ID]) { 1084d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DstModFlags->addOperand(ErrorNode[ID]); 1085d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling AddedNodes[ID].push_back(ErrorNode[ID]); 1086d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling } else if (WarningNode[ID]) { 1087d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DstModFlags->addOperand(WarningNode[ID]); 1088d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling AddedNodes[ID].push_back(WarningNode[ID]); 1089d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling } 1090d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1091d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling for (SmallSetVector<MDNode*, 8>::iterator 1092d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling II = RequireNodes[ID].begin(), IE = RequireNodes[ID].end(); 1093d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling II != IE; ++II) 1094d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling DstModFlags->addOperand(*II); 1095d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling } 1096d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1097d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling // Now check that all of the requirements have been satisfied. 1098d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling for (SmallSetVector<MDString*, 16>::iterator 1099d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling I = SeenIDs.begin(), E = SeenIDs.end(); I != E; ++I) { 1100d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling MDString *ID = *I; 1101d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling SmallSetVector<MDNode*, 8> &Set = RequireNodes[ID]; 1102d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1103d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling for (SmallSetVector<MDNode*, 8>::iterator 1104d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling II = Set.begin(), IE = Set.end(); II != IE; ++II) { 1105d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling MDNode *Node = *II; 1106d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling assert(isa<MDNode>(Node->getOperand(2)) && 1107d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling "Module flag's third operand must be an MDNode!"); 1108d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling MDNode *Val = cast<MDNode>(Node->getOperand(2)); 1109d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1110d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling MDString *ReqID = cast<MDString>(Val->getOperand(0)); 1111d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling Value *ReqVal = Val->getOperand(1); 1112d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1113d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling bool HasValue = false; 1114d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling for (SmallVectorImpl<MDNode*>::iterator 1115d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling RI = AddedNodes[ReqID].begin(), RE = AddedNodes[ReqID].end(); 1116d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling RI != RE; ++RI) { 1117d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling MDNode *ReqNode = *RI; 1118d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling if (ReqNode->getOperand(2) == ReqVal) { 1119d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling HasValue = true; 1120d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling break; 1121d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling } 1122d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling } 1123d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1124d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling if (!HasValue) 112575b3d6886762bbbc9e1805793222c29cb39fbd2fBill Wendling HasErr = emitError("linking module flags '" + ReqID->getString() + 112675b3d6886762bbbc9e1805793222c29cb39fbd2fBill Wendling "': does not have the required value"); 1127d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling } 1128d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling } 1129d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 1130d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling return HasErr; 1131d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling} 11321afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 11331afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattnerbool ModuleLinker::run() { 1134d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling assert(DstM && "Null destination module"); 1135d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling assert(SrcM && "Null source module"); 113652f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 11371afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Inherit the target data from the source module if the destination module 11381afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // doesn't have one already. 11391afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DstM->getDataLayout().empty() && !SrcM->getDataLayout().empty()) 11401afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DstM->setDataLayout(SrcM->getDataLayout()); 1141873c5e7859c1534bf92c9e2747f2b70685059598Chris Lattner 1142f27dfcb210fec571d79bc881f5463e0b405707c0Chris Lattner // Copy the target triple from the source to dest if the dest's is empty. 11431afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DstM->getTargetTriple().empty() && !SrcM->getTargetTriple().empty()) 11441afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DstM->setTargetTriple(SrcM->getTargetTriple()); 1145eba2cb0d5aef5a8229facae5624c65d9fd65e9d1Mikhail Glushenkov 11461afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!SrcM->getDataLayout().empty() && !DstM->getDataLayout().empty() && 11471afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SrcM->getDataLayout() != DstM->getDataLayout()) 1148bdff548e4dd577a72094d57b282de4e765643b96Chris Lattner errs() << "WARNING: Linking two modules of different data layouts!\n"; 11491afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!SrcM->getTargetTriple().empty() && 11501afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DstM->getTargetTriple() != SrcM->getTargetTriple()) { 1151a797ee0210902669833720f9df7c3be5e58c1401Chris Lattner errs() << "WARNING: Linking two modules of different target triples: "; 11521afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!SrcM->getModuleIdentifier().empty()) 11531afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner errs() << SrcM->getModuleIdentifier() << ": "; 11541afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner errs() << "'" << SrcM->getTargetTriple() << "' and '" 11551afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner << DstM->getTargetTriple() << "'\n"; 1156a797ee0210902669833720f9df7c3be5e58c1401Chris Lattner } 1157f976c856fcc5055f3fc7d9f070d72c2d027c1d9dMisha Brukman 1158f27dfcb210fec571d79bc881f5463e0b405707c0Chris Lattner // Append the module inline asm string. 11591afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!SrcM->getModuleInlineAsm().empty()) { 11601afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (DstM->getModuleInlineAsm().empty()) 11611afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DstM->setModuleInlineAsm(SrcM->getModuleInlineAsm()); 1162e1b2e14f92e8e9da1eb4854511a881cf9c22af3cChris Lattner else 11631afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DstM->setModuleInlineAsm(DstM->getModuleInlineAsm()+"\n"+ 11641afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner SrcM->getModuleInlineAsm()); 1165e1b2e14f92e8e9da1eb4854511a881cf9c22af3cChris Lattner } 1166eba2cb0d5aef5a8229facae5624c65d9fd65e9d1Mikhail Glushenkov 1167719012d6254ee425464f034250176283fb96793bReid Spencer // Update the destination module's dependent libraries list with the libraries 116857a0efa32240ef03ea318f9ba7680fd2b8609c6eReid Spencer // from the source module. There's no opportunity for duplicates here as the 116957a0efa32240ef03ea318f9ba7680fd2b8609c6eReid Spencer // Module ensures that duplicate insertions are discarded. 11701afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (Module::lib_iterator SI = SrcM->lib_begin(), SE = SrcM->lib_end(); 1171eba2cb0d5aef5a8229facae5624c65d9fd65e9d1Mikhail Glushenkov SI != SE; ++SI) 11721afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DstM->addLibrary(*SI); 11731afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 11741afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If the source library's module id is in the dependent library list of the 11751afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // destination library, remove it since that module is now linked in. 11761afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner StringRef ModuleId = SrcM->getModuleIdentifier(); 11771afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (!ModuleId.empty()) 11781afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner DstM->removeLibrary(sys::path::stem(ModuleId)); 11791afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 11801afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Loop over all of the linked values to compute type mappings. 11811afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner computeTypeMapping(); 11822c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 11831afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Insert all of the globals in src into the DstM module... without linking 11848166e6eef6518da6f1f805e0d5e2bb22c15dd49cChris Lattner // initializers (which could refer to functions not yet mapped over). 11851afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (Module::global_iterator I = SrcM->global_begin(), 11861afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner E = SrcM->global_end(); I != E; ++I) 11871afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (linkGlobalProto(I)) 11881afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return true; 11895c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1190c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Link the functions together between the two modules, without doing function 11911afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // bodies... this just adds external function prototypes to the DstM 1192c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // function... We do this so that when we begin processing function bodies, 1193c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // all of the global values that may be referenced are available in our 1194c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // ValueMap. 11951afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (Module::iterator I = SrcM->begin(), E = SrcM->end(); I != E; ++I) 11961afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (linkFunctionProto(I)) 11971afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return true; 11986cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner 11991afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // If there were any aliases, link them now. 12001afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (Module::alias_iterator I = SrcM->alias_begin(), 12011afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner E = SrcM->alias_end(); I != E; ++I) 12021afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (linkAliasProto(I)) 12031afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return true; 120452f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 12051afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (unsigned i = 0, e = AppendingVars.size(); i != e; ++i) 12061afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner linkAppendingVarInit(AppendingVars[i]); 12071afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 12081afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Update the initializers in the DstM module now that all globals that may 12091afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // be referenced are in DstM. 12101afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner linkGlobalInits(); 12111afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 12121afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Link in the function bodies that are defined in the source module into 12131afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // DstM. 12141afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (Module::iterator SF = SrcM->begin(), E = SrcM->end(); SF != E; ++SF) { 12152b28a74bc69e33eedc60f438e4fe9ef9ae606f3cTanya Lattner // Skip if not linking from source. 12162b28a74bc69e33eedc60f438e4fe9ef9ae606f3cTanya Lattner if (DoNotLinkFromSource.count(SF)) continue; 12172b28a74bc69e33eedc60f438e4fe9ef9ae606f3cTanya Lattner 12182b28a74bc69e33eedc60f438e4fe9ef9ae606f3cTanya Lattner // Skip if no body (function is external) or materialize. 12192b28a74bc69e33eedc60f438e4fe9ef9ae606f3cTanya Lattner if (SF->isDeclaration()) { 12202b28a74bc69e33eedc60f438e4fe9ef9ae606f3cTanya Lattner if (!SF->isMaterializable()) 12212b28a74bc69e33eedc60f438e4fe9ef9ae606f3cTanya Lattner continue; 12222b28a74bc69e33eedc60f438e4fe9ef9ae606f3cTanya Lattner if (SF->Materialize(&ErrorMsg)) 12232b28a74bc69e33eedc60f438e4fe9ef9ae606f3cTanya Lattner return true; 12242b28a74bc69e33eedc60f438e4fe9ef9ae606f3cTanya Lattner } 12251afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 12261afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner linkFunctionBody(cast<Function>(ValueMap[SF]), SF); 12271afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 12288166e6eef6518da6f1f805e0d5e2bb22c15dd49cChris Lattner 12291afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Resolve all uses of aliases with aliasees. 12301afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner linkAliasBodies(); 12313db9191baf5f5229a2f4d204c6332ba27fff81d0Anton Korobeynikov 1232d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling // Remap all of the named MDNodes in Src into the DstM module. We do this 1233211da8f7a96e26cc8d53a0c2ea34f6b791513021Devang Patel // after linking GlobalValues so that MDNodes that reference GlobalValues 1234211da8f7a96e26cc8d53a0c2ea34f6b791513021Devang Patel // are properly remapped. 1235211da8f7a96e26cc8d53a0c2ea34f6b791513021Devang Patel linkNamedMDNodes(); 1236211da8f7a96e26cc8d53a0c2ea34f6b791513021Devang Patel 1237d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling // Merge the module flags into the DstM module. 1238d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling if (linkModuleFlagsMetadata()) 1239d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling return true; 1240d34cb1e09f5e4b3feb7305346655b83ad2f67773Bill Wendling 12419af37a3de8c8688adae383471379f0216287ce28Tanya Lattner // Process vector of lazily linked in functions. 12429af37a3de8c8688adae383471379f0216287ce28Tanya Lattner bool LinkedInAnyFunctions; 12439af37a3de8c8688adae383471379f0216287ce28Tanya Lattner do { 12449af37a3de8c8688adae383471379f0216287ce28Tanya Lattner LinkedInAnyFunctions = false; 12459af37a3de8c8688adae383471379f0216287ce28Tanya Lattner 12469af37a3de8c8688adae383471379f0216287ce28Tanya Lattner for(std::vector<Function*>::iterator I = LazilyLinkFunctions.begin(), 12479af37a3de8c8688adae383471379f0216287ce28Tanya Lattner E = LazilyLinkFunctions.end(); I != E; ++I) { 12489af37a3de8c8688adae383471379f0216287ce28Tanya Lattner if (!*I) 12499af37a3de8c8688adae383471379f0216287ce28Tanya Lattner continue; 12509af37a3de8c8688adae383471379f0216287ce28Tanya Lattner 12519af37a3de8c8688adae383471379f0216287ce28Tanya Lattner Function *SF = *I; 12529af37a3de8c8688adae383471379f0216287ce28Tanya Lattner Function *DF = cast<Function>(ValueMap[SF]); 12539af37a3de8c8688adae383471379f0216287ce28Tanya Lattner 12549af37a3de8c8688adae383471379f0216287ce28Tanya Lattner if (!DF->use_empty()) { 12559af37a3de8c8688adae383471379f0216287ce28Tanya Lattner 12569af37a3de8c8688adae383471379f0216287ce28Tanya Lattner // Materialize if necessary. 12579af37a3de8c8688adae383471379f0216287ce28Tanya Lattner if (SF->isDeclaration()) { 12589af37a3de8c8688adae383471379f0216287ce28Tanya Lattner if (!SF->isMaterializable()) 12599af37a3de8c8688adae383471379f0216287ce28Tanya Lattner continue; 12609af37a3de8c8688adae383471379f0216287ce28Tanya Lattner if (SF->Materialize(&ErrorMsg)) 12619af37a3de8c8688adae383471379f0216287ce28Tanya Lattner return true; 12629af37a3de8c8688adae383471379f0216287ce28Tanya Lattner } 12639af37a3de8c8688adae383471379f0216287ce28Tanya Lattner 12649af37a3de8c8688adae383471379f0216287ce28Tanya Lattner // Link in function body. 12659af37a3de8c8688adae383471379f0216287ce28Tanya Lattner linkFunctionBody(DF, SF); 12669af37a3de8c8688adae383471379f0216287ce28Tanya Lattner 12679af37a3de8c8688adae383471379f0216287ce28Tanya Lattner // "Remove" from vector by setting the element to 0. 12689af37a3de8c8688adae383471379f0216287ce28Tanya Lattner *I = 0; 12699af37a3de8c8688adae383471379f0216287ce28Tanya Lattner 12709af37a3de8c8688adae383471379f0216287ce28Tanya Lattner // Set flag to indicate we may have more functions to lazily link in 12719af37a3de8c8688adae383471379f0216287ce28Tanya Lattner // since we linked in a function. 12729af37a3de8c8688adae383471379f0216287ce28Tanya Lattner LinkedInAnyFunctions = true; 12739af37a3de8c8688adae383471379f0216287ce28Tanya Lattner } 12749af37a3de8c8688adae383471379f0216287ce28Tanya Lattner } 12759af37a3de8c8688adae383471379f0216287ce28Tanya Lattner } while (LinkedInAnyFunctions); 12769af37a3de8c8688adae383471379f0216287ce28Tanya Lattner 12779af37a3de8c8688adae383471379f0216287ce28Tanya Lattner // Remove any prototypes of functions that were not actually linked in. 12789af37a3de8c8688adae383471379f0216287ce28Tanya Lattner for(std::vector<Function*>::iterator I = LazilyLinkFunctions.begin(), 12799af37a3de8c8688adae383471379f0216287ce28Tanya Lattner E = LazilyLinkFunctions.end(); I != E; ++I) { 12809af37a3de8c8688adae383471379f0216287ce28Tanya Lattner if (!*I) 12819af37a3de8c8688adae383471379f0216287ce28Tanya Lattner continue; 12829af37a3de8c8688adae383471379f0216287ce28Tanya Lattner 12839af37a3de8c8688adae383471379f0216287ce28Tanya Lattner Function *SF = *I; 12849af37a3de8c8688adae383471379f0216287ce28Tanya Lattner Function *DF = cast<Function>(ValueMap[SF]); 12859af37a3de8c8688adae383471379f0216287ce28Tanya Lattner if (DF->use_empty()) 12869af37a3de8c8688adae383471379f0216287ce28Tanya Lattner DF->eraseFromParent(); 12879af37a3de8c8688adae383471379f0216287ce28Tanya Lattner } 12889af37a3de8c8688adae383471379f0216287ce28Tanya Lattner 12891afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // Now that all of the types from the source are used, resolve any structs 12901afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner // copied over to the dest that didn't exist there. 12911afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner TypeMap.linkDefinedTypeBodies(); 12921afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 129352f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner return false; 129452f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner} 12959466f5113ba859677a28887c3c7143065e702019Vikram S. Adve 12961afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner//===----------------------------------------------------------------------===// 12971afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner// LinkModules entrypoint. 12981afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner//===----------------------------------------------------------------------===// 12991afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 13001afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner// LinkModules - This function links two modules together, with the resulting 13011afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner// left module modified to be the composite of the two input modules. If an 13021afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner// error occurs, true is returned and ErrorMsg (if not null) is set to indicate 13031afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner// the problem. Upon failure, the Dest module could be in a modified state, and 13041afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner// shouldn't be relied on to be consistent. 1305f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattnerbool Linker::LinkModules(Module *Dest, Module *Src, unsigned Mode, 1306f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner std::string *ErrorMsg) { 1307f1f1a4f16128ffa2910f0b1d5c7052b3697f9fcdTanya Lattner ModuleLinker TheLinker(Dest, Src, Mode); 13081afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (TheLinker.run()) { 13091afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner if (ErrorMsg) *ErrorMsg = TheLinker.ErrorMsg; 13101afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return true; 13111afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner } 13121afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner 13131afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return false; 13141afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner} 1315