blob: 55654ac25d693d9f56adea9eb7b7b8ea6b3f2273 [file] [log] [blame]
Mikhail Glushenkov59a5afa2009-03-03 10:04:23 +00001//===- lib/Linker/LinkModules.cpp - Module Linker Implementation ----------===//
Misha Brukman10468d82005-04-21 22:55:34 +00002//
Reid Spencer361e5132004-11-12 20:37:43 +00003// The LLVM Compiler Infrastructure
4//
Chris Lattnerf3ebc3f2007-12-29 20:36:04 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Misha Brukman10468d82005-04-21 22:55:34 +00007//
Reid Spencer361e5132004-11-12 20:37:43 +00008//===----------------------------------------------------------------------===//
9//
10// This file implements the LLVM module linker.
11//
Reid Spencer361e5132004-11-12 20:37:43 +000012//===----------------------------------------------------------------------===//
13
Chandler Carruth6cc07df2014-03-06 03:42:23 +000014#include "llvm/Linker/Linker.h"
Chandler Carruthed0881b2012-12-03 16:50:05 +000015#include "llvm-c/Linker.h"
Rafael Espindola23f8d642012-01-05 23:02:01 +000016#include "llvm/ADT/Optional.h"
Bill Wendling66f02412012-02-11 11:38:06 +000017#include "llvm/ADT/SetVector.h"
Eli Bendersky0f7fd362013-03-19 15:26:24 +000018#include "llvm/ADT/SmallString.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000019#include "llvm/IR/Constants.h"
Chandler Carruth9fb823b2013-01-02 11:36:10 +000020#include "llvm/IR/Module.h"
Chandler Carruthdcb603f2013-01-07 15:43:51 +000021#include "llvm/IR/TypeFinder.h"
Eli Benderskye17f3702014-02-06 18:01:56 +000022#include "llvm/Support/CommandLine.h"
Bill Wendlingb6af2f32012-03-22 20:28:27 +000023#include "llvm/Support/Debug.h"
Bill Wendlingb6af2f32012-03-22 20:28:27 +000024#include "llvm/Support/raw_ostream.h"
Tanya Lattnercbb91402011-10-11 00:24:54 +000025#include "llvm/Transforms/Utils/Cloning.h"
Will Dietz981af002013-10-12 00:55:57 +000026#include <cctype>
Reid Spencer361e5132004-11-12 20:37:43 +000027using namespace llvm;
28
Eli Benderskye17f3702014-02-06 18:01:56 +000029
Chris Lattnerb1ed91f2011-07-09 17:41:24 +000030//===----------------------------------------------------------------------===//
31// TypeMap implementation.
32//===----------------------------------------------------------------------===//
Reid Spencer361e5132004-11-12 20:37:43 +000033
Chris Lattnereee6f992008-06-16 21:00:18 +000034namespace {
Rafael Espindolaaa9918a2013-05-04 05:05:18 +000035 typedef SmallPtrSet<StructType*, 32> TypeSet;
36
Chris Lattnerb1ed91f2011-07-09 17:41:24 +000037class TypeMapTy : public ValueMapTypeRemapper {
38 /// MappedTypes - This is a mapping from a source type to a destination type
39 /// to use.
40 DenseMap<Type*, Type*> MappedTypes;
Mikhail Glushenkov766d4892009-03-03 07:22:23 +000041
Chris Lattnerb1ed91f2011-07-09 17:41:24 +000042 /// SpeculativeTypes - When checking to see if two subgraphs are isomorphic,
43 /// we speculatively add types to MappedTypes, but keep track of them here in
44 /// case we need to roll back.
45 SmallVector<Type*, 16> SpeculativeTypes;
46
Chris Lattner5e3bd972011-12-20 00:03:52 +000047 /// SrcDefinitionsToResolve - This is a list of non-opaque structs in the
48 /// source module that are mapped to an opaque struct in the destination
49 /// module.
50 SmallVector<StructType*, 16> SrcDefinitionsToResolve;
51
52 /// DstResolvedOpaqueTypes - This is the set of opaque types in the
53 /// destination modules who are getting a body from the source module.
54 SmallPtrSet<StructType*, 16> DstResolvedOpaqueTypes;
Bill Wendling8c2cc412012-03-22 20:30:41 +000055
Chris Lattner56cdea62008-06-16 23:06:51 +000056public:
Rafael Espindolaaa9918a2013-05-04 05:05:18 +000057 TypeMapTy(TypeSet &Set) : DstStructTypesSet(Set) {}
58
59 TypeSet &DstStructTypesSet;
Chris Lattnerb1ed91f2011-07-09 17:41:24 +000060 /// addTypeMapping - Indicate that the specified type in the destination
61 /// module is conceptually equivalent to the specified type in the source
62 /// module.
63 void addTypeMapping(Type *DstTy, Type *SrcTy);
64
65 /// linkDefinedTypeBodies - Produce a body for an opaque type in the dest
66 /// module from a type definition in the source module.
67 void linkDefinedTypeBodies();
68
69 /// get - Return the mapped type to use for the specified input type from the
70 /// source module.
71 Type *get(Type *SrcTy);
72
73 FunctionType *get(FunctionType *T) {return cast<FunctionType>(get((Type*)T));}
74
Bill Wendlingb6af2f32012-03-22 20:28:27 +000075 /// dump - Dump out the type map for debugging purposes.
76 void dump() const {
77 for (DenseMap<Type*, Type*>::const_iterator
78 I = MappedTypes.begin(), E = MappedTypes.end(); I != E; ++I) {
79 dbgs() << "TypeMap: ";
80 I->first->dump();
81 dbgs() << " => ";
82 I->second->dump();
83 dbgs() << '\n';
84 }
85 }
Bill Wendlingb6af2f32012-03-22 20:28:27 +000086
Chris Lattnerb1ed91f2011-07-09 17:41:24 +000087private:
88 Type *getImpl(Type *T);
89 /// remapType - Implement the ValueMapTypeRemapper interface.
Craig Topper85482992014-03-05 07:52:44 +000090 Type *remapType(Type *SrcTy) override {
Chris Lattnerb1ed91f2011-07-09 17:41:24 +000091 return get(SrcTy);
Chris Lattnereee6f992008-06-16 21:00:18 +000092 }
Chris Lattnerb1ed91f2011-07-09 17:41:24 +000093
94 bool areTypesIsomorphic(Type *DstTy, Type *SrcTy);
Chris Lattnereee6f992008-06-16 21:00:18 +000095};
96}
97
Chris Lattnerb1ed91f2011-07-09 17:41:24 +000098void TypeMapTy::addTypeMapping(Type *DstTy, Type *SrcTy) {
99 Type *&Entry = MappedTypes[SrcTy];
100 if (Entry) return;
101
102 if (DstTy == SrcTy) {
103 Entry = DstTy;
104 return;
105 }
Bill Wendlingd48b7782012-02-28 04:01:21 +0000106
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000107 // Check to see if these types are recursively isomorphic and establish a
108 // mapping between them if so.
Bill Wendlingd48b7782012-02-28 04:01:21 +0000109 if (!areTypesIsomorphic(DstTy, SrcTy)) {
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000110 // Oops, they aren't isomorphic. Just discard this request by rolling out
111 // any speculative mappings we've established.
112 for (unsigned i = 0, e = SpeculativeTypes.size(); i != e; ++i)
113 MappedTypes.erase(SpeculativeTypes[i]);
Bill Wendlingd48b7782012-02-28 04:01:21 +0000114 }
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000115 SpeculativeTypes.clear();
116}
Chris Lattnereee6f992008-06-16 21:00:18 +0000117
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000118/// areTypesIsomorphic - Recursively walk this pair of types, returning true
119/// if they are isomorphic, false if they are not.
120bool TypeMapTy::areTypesIsomorphic(Type *DstTy, Type *SrcTy) {
121 // Two types with differing kinds are clearly not isomorphic.
122 if (DstTy->getTypeID() != SrcTy->getTypeID()) return false;
Misha Brukman10468d82005-04-21 22:55:34 +0000123
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000124 // If we have an entry in the MappedTypes table, then we have our answer.
125 Type *&Entry = MappedTypes[SrcTy];
126 if (Entry)
127 return Entry == DstTy;
Misha Brukman10468d82005-04-21 22:55:34 +0000128
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000129 // Two identical types are clearly isomorphic. Remember this
130 // non-speculatively.
131 if (DstTy == SrcTy) {
132 Entry = DstTy;
Chris Lattnerfe677e92008-06-16 20:03:01 +0000133 return true;
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000134 }
Bill Wendlingd48b7782012-02-28 04:01:21 +0000135
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000136 // Okay, we have two types with identical kinds that we haven't seen before.
Mikhail Glushenkov766d4892009-03-03 07:22:23 +0000137
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000138 // If this is an opaque struct type, special case it.
139 if (StructType *SSTy = dyn_cast<StructType>(SrcTy)) {
140 // Mapping an opaque type to any struct, just keep the dest struct.
141 if (SSTy->isOpaque()) {
142 Entry = DstTy;
143 SpeculativeTypes.push_back(SrcTy);
Reid Spencer361e5132004-11-12 20:37:43 +0000144 return true;
Chris Lattner9be15892008-06-16 21:17:12 +0000145 }
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000146
Chris Lattner5e3bd972011-12-20 00:03:52 +0000147 // Mapping a non-opaque source type to an opaque dest. If this is the first
148 // type that we're mapping onto this destination type then we succeed. Keep
149 // the dest, but fill it in later. This doesn't need to be speculative. If
150 // this is the second (different) type that we're trying to map onto the
151 // same opaque type then we fail.
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000152 if (cast<StructType>(DstTy)->isOpaque()) {
Chris Lattner5e3bd972011-12-20 00:03:52 +0000153 // We can only map one source type onto the opaque destination type.
154 if (!DstResolvedOpaqueTypes.insert(cast<StructType>(DstTy)))
155 return false;
156 SrcDefinitionsToResolve.push_back(SSTy);
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000157 Entry = DstTy;
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000158 return true;
159 }
160 }
161
162 // If the number of subtypes disagree between the two types, then we fail.
163 if (SrcTy->getNumContainedTypes() != DstTy->getNumContainedTypes())
Reid Spencer361e5132004-11-12 20:37:43 +0000164 return false;
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000165
166 // Fail if any of the extra properties (e.g. array size) of the type disagree.
167 if (isa<IntegerType>(DstTy))
168 return false; // bitwidth disagrees.
169 if (PointerType *PT = dyn_cast<PointerType>(DstTy)) {
170 if (PT->getAddressSpace() != cast<PointerType>(SrcTy)->getAddressSpace())
171 return false;
Chris Lattnereaf9b762011-12-20 23:14:57 +0000172
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000173 } else if (FunctionType *FT = dyn_cast<FunctionType>(DstTy)) {
174 if (FT->isVarArg() != cast<FunctionType>(SrcTy)->isVarArg())
175 return false;
176 } else if (StructType *DSTy = dyn_cast<StructType>(DstTy)) {
177 StructType *SSTy = cast<StructType>(SrcTy);
Chris Lattner44f7ab42011-08-12 18:07:26 +0000178 if (DSTy->isLiteral() != SSTy->isLiteral() ||
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000179 DSTy->isPacked() != SSTy->isPacked())
180 return false;
181 } else if (ArrayType *DATy = dyn_cast<ArrayType>(DstTy)) {
182 if (DATy->getNumElements() != cast<ArrayType>(SrcTy)->getNumElements())
183 return false;
184 } else if (VectorType *DVTy = dyn_cast<VectorType>(DstTy)) {
Joey Gouly5fad3e92013-01-10 10:49:36 +0000185 if (DVTy->getNumElements() != cast<VectorType>(SrcTy)->getNumElements())
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000186 return false;
Reid Spencer361e5132004-11-12 20:37:43 +0000187 }
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000188
189 // Otherwise, we speculate that these two types will line up and recursively
190 // check the subelements.
191 Entry = DstTy;
192 SpeculativeTypes.push_back(SrcTy);
193
Bill Wendlingd48b7782012-02-28 04:01:21 +0000194 for (unsigned i = 0, e = SrcTy->getNumContainedTypes(); i != e; ++i)
195 if (!areTypesIsomorphic(DstTy->getContainedType(i),
196 SrcTy->getContainedType(i)))
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000197 return false;
198
199 // If everything seems to have lined up, then everything is great.
200 return true;
201}
202
203/// linkDefinedTypeBodies - Produce a body for an opaque type in the dest
204/// module from a type definition in the source module.
205void TypeMapTy::linkDefinedTypeBodies() {
206 SmallVector<Type*, 16> Elements;
207 SmallString<16> TmpName;
208
209 // Note that processing entries in this loop (calling 'get') can add new
Chris Lattner5e3bd972011-12-20 00:03:52 +0000210 // entries to the SrcDefinitionsToResolve vector.
211 while (!SrcDefinitionsToResolve.empty()) {
212 StructType *SrcSTy = SrcDefinitionsToResolve.pop_back_val();
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000213 StructType *DstSTy = cast<StructType>(MappedTypes[SrcSTy]);
214
215 // TypeMap is a many-to-one mapping, if there were multiple types that
216 // provide a body for DstSTy then previous iterations of this loop may have
217 // already handled it. Just ignore this case.
218 if (!DstSTy->isOpaque()) continue;
219 assert(!SrcSTy->isOpaque() && "Not resolving a definition?");
220
221 // Map the body of the source type over to a new body for the dest type.
222 Elements.resize(SrcSTy->getNumElements());
223 for (unsigned i = 0, e = Elements.size(); i != e; ++i)
224 Elements[i] = getImpl(SrcSTy->getElementType(i));
225
226 DstSTy->setBody(Elements, SrcSTy->isPacked());
227
228 // If DstSTy has no name or has a longer name than STy, then viciously steal
229 // STy's name.
230 if (!SrcSTy->hasName()) continue;
231 StringRef SrcName = SrcSTy->getName();
232
233 if (!DstSTy->hasName() || DstSTy->getName().size() > SrcName.size()) {
234 TmpName.insert(TmpName.end(), SrcName.begin(), SrcName.end());
235 SrcSTy->setName("");
236 DstSTy->setName(TmpName.str());
237 TmpName.clear();
238 }
239 }
Chris Lattner5e3bd972011-12-20 00:03:52 +0000240
241 DstResolvedOpaqueTypes.clear();
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000242}
243
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000244/// get - Return the mapped type to use for the specified input type from the
245/// source module.
246Type *TypeMapTy::get(Type *Ty) {
247 Type *Result = getImpl(Ty);
248
249 // If this caused a reference to any struct type, resolve it before returning.
Chris Lattner5e3bd972011-12-20 00:03:52 +0000250 if (!SrcDefinitionsToResolve.empty())
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000251 linkDefinedTypeBodies();
252 return Result;
253}
254
255/// getImpl - This is the recursive version of get().
256Type *TypeMapTy::getImpl(Type *Ty) {
257 // If we already have an entry for this type, return it.
258 Type **Entry = &MappedTypes[Ty];
259 if (*Entry) return *Entry;
Bill Wendlingd48b7782012-02-28 04:01:21 +0000260
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000261 // If this is not a named struct type, then just map all of the elements and
262 // then rebuild the type from inside out.
Chris Lattner44f7ab42011-08-12 18:07:26 +0000263 if (!isa<StructType>(Ty) || cast<StructType>(Ty)->isLiteral()) {
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000264 // If there are no element types to map, then the type is itself. This is
265 // true for the anonymous {} struct, things like 'float', integers, etc.
266 if (Ty->getNumContainedTypes() == 0)
267 return *Entry = Ty;
268
269 // Remap all of the elements, keeping track of whether any of them change.
270 bool AnyChange = false;
271 SmallVector<Type*, 4> ElementTypes;
272 ElementTypes.resize(Ty->getNumContainedTypes());
273 for (unsigned i = 0, e = Ty->getNumContainedTypes(); i != e; ++i) {
274 ElementTypes[i] = getImpl(Ty->getContainedType(i));
275 AnyChange |= ElementTypes[i] != Ty->getContainedType(i);
276 }
277
278 // If we found our type while recursively processing stuff, just use it.
279 Entry = &MappedTypes[Ty];
280 if (*Entry) return *Entry;
281
282 // If all of the element types mapped directly over, then the type is usable
283 // as-is.
284 if (!AnyChange)
285 return *Entry = Ty;
286
287 // Otherwise, rebuild a modified type.
288 switch (Ty->getTypeID()) {
Craig Toppera2886c22012-02-07 05:05:23 +0000289 default: llvm_unreachable("unknown derived type to remap");
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000290 case Type::ArrayTyID:
291 return *Entry = ArrayType::get(ElementTypes[0],
292 cast<ArrayType>(Ty)->getNumElements());
293 case Type::VectorTyID:
294 return *Entry = VectorType::get(ElementTypes[0],
295 cast<VectorType>(Ty)->getNumElements());
296 case Type::PointerTyID:
297 return *Entry = PointerType::get(ElementTypes[0],
298 cast<PointerType>(Ty)->getAddressSpace());
299 case Type::FunctionTyID:
300 return *Entry = FunctionType::get(ElementTypes[0],
Frits van Bommel717d7ed2011-07-18 12:00:32 +0000301 makeArrayRef(ElementTypes).slice(1),
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000302 cast<FunctionType>(Ty)->isVarArg());
303 case Type::StructTyID:
304 // Note that this is only reached for anonymous structs.
305 return *Entry = StructType::get(Ty->getContext(), ElementTypes,
306 cast<StructType>(Ty)->isPacked());
307 }
308 }
309
310 // Otherwise, this is an unmapped named struct. If the struct can be directly
311 // mapped over, just use it as-is. This happens in a case when the linked-in
312 // module has something like:
313 // %T = type {%T*, i32}
314 // @GV = global %T* null
315 // where T does not exist at all in the destination module.
316 //
317 // The other case we watch for is when the type is not in the destination
318 // module, but that it has to be rebuilt because it refers to something that
319 // is already mapped. For example, if the destination module has:
320 // %A = type { i32 }
321 // and the source module has something like
322 // %A' = type { i32 }
323 // %B = type { %A'* }
324 // @GV = global %B* null
325 // then we want to create a new type: "%B = type { %A*}" and have it take the
326 // pristine "%B" name from the source module.
327 //
328 // To determine which case this is, we have to recursively walk the type graph
329 // speculating that we'll be able to reuse it unmodified. Only if this is
330 // safe would we map the entire thing over. Because this is an optimization,
331 // and is not required for the prettiness of the linked module, we just skip
332 // it and always rebuild a type here.
333 StructType *STy = cast<StructType>(Ty);
334
335 // If the type is opaque, we can just use it directly.
Rafael Espindolaaa9918a2013-05-04 05:05:18 +0000336 if (STy->isOpaque()) {
337 // A named structure type from src module is used. Add it to the Set of
338 // identified structs in the destination module.
339 DstStructTypesSet.insert(STy);
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000340 return *Entry = STy;
Rafael Espindolaaa9918a2013-05-04 05:05:18 +0000341 }
Bill Wendlingd48b7782012-02-28 04:01:21 +0000342
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000343 // Otherwise we create a new type and resolve its body later. This will be
344 // resolved by the top level of get().
Chris Lattner5e3bd972011-12-20 00:03:52 +0000345 SrcDefinitionsToResolve.push_back(STy);
346 StructType *DTy = StructType::create(STy->getContext());
Rafael Espindolaaa9918a2013-05-04 05:05:18 +0000347 // A new identified structure type was created. Add it to the set of
348 // identified structs in the destination module.
349 DstStructTypesSet.insert(DTy);
Chris Lattner5e3bd972011-12-20 00:03:52 +0000350 DstResolvedOpaqueTypes.insert(DTy);
351 return *Entry = DTy;
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000352}
353
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000354//===----------------------------------------------------------------------===//
355// ModuleLinker implementation.
356//===----------------------------------------------------------------------===//
357
358namespace {
James Molloyf6f121e2013-05-28 15:17:05 +0000359 class ModuleLinker;
360
361 /// ValueMaterializerTy - Creates prototypes for functions that are lazily
362 /// linked on the fly. This speeds up linking for modules with many
363 /// lazily linked functions of which few get used.
364 class ValueMaterializerTy : public ValueMaterializer {
365 TypeMapTy &TypeMap;
366 Module *DstM;
367 std::vector<Function*> &LazilyLinkFunctions;
368 public:
369 ValueMaterializerTy(TypeMapTy &TypeMap, Module *DstM,
370 std::vector<Function*> &LazilyLinkFunctions) :
371 ValueMaterializer(), TypeMap(TypeMap), DstM(DstM),
372 LazilyLinkFunctions(LazilyLinkFunctions) {
373 }
374
Craig Topper85482992014-03-05 07:52:44 +0000375 Value *materializeValueFor(Value *V) override;
James Molloyf6f121e2013-05-28 15:17:05 +0000376 };
377
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000378 /// ModuleLinker - This is an implementation class for the LinkModules
379 /// function, which is the entrypoint for this file.
380 class ModuleLinker {
381 Module *DstM, *SrcM;
382
383 TypeMapTy TypeMap;
James Molloyf6f121e2013-05-28 15:17:05 +0000384 ValueMaterializerTy ValMaterializer;
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000385
386 /// ValueMap - Mapping of values from what they used to be in Src, to what
387 /// they are now in DstM. ValueToValueMapTy is a ValueMap, which involves
388 /// some overhead due to the use of Value handles which the Linker doesn't
389 /// actually need, but this allows us to reuse the ValueMapper code.
390 ValueToValueMapTy ValueMap;
391
392 struct AppendingVarInfo {
393 GlobalVariable *NewGV; // New aggregate global in dest module.
394 Constant *DstInit; // Old initializer from dest module.
395 Constant *SrcInit; // Old initializer from src module.
396 };
397
398 std::vector<AppendingVarInfo> AppendingVars;
399
Tanya Lattnercbb91402011-10-11 00:24:54 +0000400 unsigned Mode; // Mode to treat source module.
401
402 // Set of items not to link in from source.
403 SmallPtrSet<const Value*, 16> DoNotLinkFromSource;
404
Tanya Lattner0a48b872011-11-02 00:24:56 +0000405 // Vector of functions to lazily link in.
Bill Wendlingfa2287822013-03-27 17:54:41 +0000406 std::vector<Function*> LazilyLinkFunctions;
Eli Bendersky7da92ed2014-02-20 22:19:24 +0000407
408 bool SuppressWarnings;
Tanya Lattner0a48b872011-11-02 00:24:56 +0000409
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000410 public:
411 std::string ErrorMsg;
Eli Bendersky7da92ed2014-02-20 22:19:24 +0000412
413 ModuleLinker(Module *dstM, TypeSet &Set, Module *srcM, unsigned mode,
414 bool SuppressWarnings=false)
415 : DstM(dstM), SrcM(srcM), TypeMap(Set),
416 ValMaterializer(TypeMap, DstM, LazilyLinkFunctions), Mode(mode),
417 SuppressWarnings(SuppressWarnings) {}
418
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000419 bool run();
420
421 private:
422 /// emitError - Helper method for setting a message and returning an error
423 /// code.
424 bool emitError(const Twine &Message) {
425 ErrorMsg = Message.str();
Chris Lattner99953022008-06-16 18:27:53 +0000426 return true;
Chris Lattner9be15892008-06-16 21:17:12 +0000427 }
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000428
429 /// getLinkageResult - This analyzes the two global values and determines
430 /// what the result will look like in the destination module.
431 bool getLinkageResult(GlobalValue *Dest, const GlobalValue *Src,
Rafael Espindola23f8d642012-01-05 23:02:01 +0000432 GlobalValue::LinkageTypes &LT,
433 GlobalValue::VisibilityTypes &Vis,
434 bool &LinkFromSrc);
Mikhail Glushenkov766d4892009-03-03 07:22:23 +0000435
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000436 /// getLinkedToGlobal - Given a global in the source module, return the
437 /// global in the destination module that is being linked to, if any.
438 GlobalValue *getLinkedToGlobal(GlobalValue *SrcGV) {
439 // If the source has no name it can't link. If it has local linkage,
440 // there is no name match-up going on.
441 if (!SrcGV->hasName() || SrcGV->hasLocalLinkage())
Craig Topper2617dcc2014-04-15 06:32:26 +0000442 return nullptr;
Bill Wendlingd48b7782012-02-28 04:01:21 +0000443
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000444 // Otherwise see if we have a match in the destination module's symtab.
445 GlobalValue *DGV = DstM->getNamedValue(SrcGV->getName());
Craig Topper2617dcc2014-04-15 06:32:26 +0000446 if (!DGV) return nullptr;
Bill Wendlingd48b7782012-02-28 04:01:21 +0000447
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000448 // If we found a global with the same name in the dest module, but it has
449 // internal linkage, we are really not doing any linkage here.
450 if (DGV->hasLocalLinkage())
Craig Topper2617dcc2014-04-15 06:32:26 +0000451 return nullptr;
Mikhail Glushenkov766d4892009-03-03 07:22:23 +0000452
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000453 // Otherwise, we do in fact link to the destination global.
454 return DGV;
455 }
456
457 void computeTypeMapping();
458
459 bool linkAppendingVarProto(GlobalVariable *DstGV, GlobalVariable *SrcGV);
460 bool linkGlobalProto(GlobalVariable *SrcGV);
461 bool linkFunctionProto(Function *SrcF);
462 bool linkAliasProto(GlobalAlias *SrcA);
Bill Wendling66f02412012-02-11 11:38:06 +0000463 bool linkModuleFlagsMetadata();
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000464
465 void linkAppendingVarInit(const AppendingVarInfo &AVI);
466 void linkGlobalInits();
467 void linkFunctionBody(Function *Dst, Function *Src);
468 void linkAliasBodies();
469 void linkNamedMDNodes();
470 };
Bill Wendlingd48b7782012-02-28 04:01:21 +0000471}
472
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000473/// forceRenaming - The LLVM SymbolTable class autorenames globals that conflict
Reid Spencer90246aa2007-02-04 04:29:21 +0000474/// in the symbol table. This is good for all clients except for us. Go
475/// through the trouble to force this back.
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000476static void forceRenaming(GlobalValue *GV, StringRef Name) {
477 // If the global doesn't force its name or if it already has the right name,
478 // there is nothing for us to do.
479 if (GV->hasLocalLinkage() || GV->getName() == Name)
480 return;
481
482 Module *M = GV->getParent();
Reid Spencer361e5132004-11-12 20:37:43 +0000483
484 // If there is a conflict, rename the conflict.
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000485 if (GlobalValue *ConflictGV = M->getNamedValue(Name)) {
Chris Lattner2a8d2e02007-02-11 00:39:38 +0000486 GV->takeName(ConflictGV);
487 ConflictGV->setName(Name); // This will cause ConflictGV to get renamed
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000488 assert(ConflictGV->getName() != Name && "forceRenaming didn't work");
Chris Lattner2a8d2e02007-02-11 00:39:38 +0000489 } else {
490 GV->setName(Name); // Force the name back
Reid Spencer3aaaa0b2007-02-05 20:47:22 +0000491 }
Reid Spencer3aaaa0b2007-02-05 20:47:22 +0000492}
Reid Spencer90246aa2007-02-04 04:29:21 +0000493
Bill Wendlingb6af2f32012-03-22 20:28:27 +0000494/// copyGVAttributes - copy additional attributes (those not needed to construct
Mikhail Glushenkov766d4892009-03-03 07:22:23 +0000495/// a GlobalValue) from the SrcGV to the DestGV.
Bill Wendlingb6af2f32012-03-22 20:28:27 +0000496static void copyGVAttributes(GlobalValue *DestGV, const GlobalValue *SrcGV) {
Duncan Sandsdd7daee2008-05-26 19:58:59 +0000497 // Use the maximum alignment, rather than just copying the alignment of SrcGV.
Rafael Espindolaa7d9c692014-05-06 14:51:36 +0000498 unsigned Alignment;
499 bool IsAlias = isa<GlobalAlias>(DestGV);
500 if (!IsAlias)
501 Alignment = std::max(DestGV->getAlignment(), SrcGV->getAlignment());
502
Duncan Sandsdd7daee2008-05-26 19:58:59 +0000503 DestGV->copyAttributesFrom(SrcGV);
Rafael Espindolaa7d9c692014-05-06 14:51:36 +0000504
505 if (!IsAlias)
506 DestGV->setAlignment(Alignment);
507
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000508 forceRenaming(DestGV, SrcGV->getName());
Reid Spencer361e5132004-11-12 20:37:43 +0000509}
510
Rafael Espindola23f8d642012-01-05 23:02:01 +0000511static bool isLessConstraining(GlobalValue::VisibilityTypes a,
512 GlobalValue::VisibilityTypes b) {
513 if (a == GlobalValue::HiddenVisibility)
514 return false;
515 if (b == GlobalValue::HiddenVisibility)
516 return true;
517 if (a == GlobalValue::ProtectedVisibility)
518 return false;
519 if (b == GlobalValue::ProtectedVisibility)
520 return true;
521 return false;
522}
523
James Molloyf6f121e2013-05-28 15:17:05 +0000524Value *ValueMaterializerTy::materializeValueFor(Value *V) {
525 Function *SF = dyn_cast<Function>(V);
526 if (!SF)
Craig Topper2617dcc2014-04-15 06:32:26 +0000527 return nullptr;
James Molloyf6f121e2013-05-28 15:17:05 +0000528
529 Function *DF = Function::Create(TypeMap.get(SF->getFunctionType()),
530 SF->getLinkage(), SF->getName(), DstM);
531 copyGVAttributes(DF, SF);
532
533 LazilyLinkFunctions.push_back(SF);
534 return DF;
535}
536
537
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000538/// getLinkageResult - This analyzes the two global values and determines what
Chris Lattnerfc61de32004-12-03 22:18:41 +0000539/// the result will look like in the destination module. In particular, it
Rafael Espindola23f8d642012-01-05 23:02:01 +0000540/// computes the resultant linkage type and visibility, computes whether the
541/// global in the source should be copied over to the destination (replacing
542/// the existing one), and computes whether this linkage is an error or not.
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000543bool ModuleLinker::getLinkageResult(GlobalValue *Dest, const GlobalValue *Src,
Rafael Espindola23f8d642012-01-05 23:02:01 +0000544 GlobalValue::LinkageTypes &LT,
545 GlobalValue::VisibilityTypes &Vis,
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000546 bool &LinkFromSrc) {
547 assert(Dest && "Must have two globals being queried");
548 assert(!Src->hasLocalLinkage() &&
Chris Lattnerfc61de32004-12-03 22:18:41 +0000549 "If Src has internal linkage, Dest shouldn't be set!");
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000550
Peter Collingbourne8bb15d82011-10-30 17:46:34 +0000551 bool SrcIsDeclaration = Src->isDeclaration() && !Src->isMaterializable();
Chris Lattner0c134b52011-07-14 20:23:05 +0000552 bool DestIsDeclaration = Dest->isDeclaration();
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000553
554 if (SrcIsDeclaration) {
Anton Korobeynikov1f93c502008-03-10 22:33:22 +0000555 // If Src is external or if both Src & Dest are external.. Just link the
Chris Lattnerfc61de32004-12-03 22:18:41 +0000556 // external globals, we aren't adding anything.
Nico Rieck7157bb72014-01-14 15:22:47 +0000557 if (Src->hasDLLImportStorageClass()) {
558 // If one of GVs is marked as DLLImport, result should be dllimport'ed.
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000559 if (DestIsDeclaration) {
Anton Korobeynikovd61d39e2006-09-14 18:23:27 +0000560 LinkFromSrc = true;
561 LT = Src->getLinkage();
Mikhail Glushenkov766d4892009-03-03 07:22:23 +0000562 }
Andrew Lenharthe06036d2006-12-15 17:35:32 +0000563 } else if (Dest->hasExternalWeakLinkage()) {
Duncan Sands12da8ce2009-03-07 15:45:40 +0000564 // If the Dest is weak, use the source linkage.
Andrew Lenharthe06036d2006-12-15 17:35:32 +0000565 LinkFromSrc = true;
566 LT = Src->getLinkage();
Anton Korobeynikovd61d39e2006-09-14 18:23:27 +0000567 } else {
568 LinkFromSrc = false;
569 LT = Dest->getLinkage();
570 }
Nico Rieck7157bb72014-01-14 15:22:47 +0000571 } else if (DestIsDeclaration && !Dest->hasDLLImportStorageClass()) {
Chris Lattnerfc61de32004-12-03 22:18:41 +0000572 // If Dest is external but Src is not:
573 LinkFromSrc = true;
574 LT = Src->getLinkage();
Duncan Sandsd725c992009-03-08 13:35:23 +0000575 } else if (Src->isWeakForLinker()) {
Dale Johannesence4396b2008-05-14 20:12:51 +0000576 // At this point we know that Dest has LinkOnce, External*, Weak, Common,
577 // or DLL* linkage.
Chris Lattner184f1be2009-04-13 05:44:34 +0000578 if (Dest->hasExternalWeakLinkage() ||
579 Dest->hasAvailableExternallyLinkage() ||
580 (Dest->hasLinkOnceLinkage() &&
581 (Src->hasWeakLinkage() || Src->hasCommonLinkage()))) {
Chris Lattnerfc61de32004-12-03 22:18:41 +0000582 LinkFromSrc = true;
583 LT = Src->getLinkage();
584 } else {
585 LinkFromSrc = false;
586 LT = Dest->getLinkage();
587 }
Duncan Sandsd725c992009-03-08 13:35:23 +0000588 } else if (Dest->isWeakForLinker()) {
Anton Korobeynikov12c94942006-12-01 00:25:12 +0000589 // At this point we know that Src has External* or DLL* linkage.
590 if (Src->hasExternalWeakLinkage()) {
591 LinkFromSrc = false;
592 LT = Dest->getLinkage();
593 } else {
594 LinkFromSrc = true;
595 LT = GlobalValue::ExternalLinkage;
596 }
Chris Lattnerfc61de32004-12-03 22:18:41 +0000597 } else {
Nico Rieck7157bb72014-01-14 15:22:47 +0000598 assert((Dest->hasExternalLinkage() || Dest->hasExternalWeakLinkage()) &&
599 (Src->hasExternalLinkage() || Src->hasExternalWeakLinkage()) &&
Chris Lattnerfc61de32004-12-03 22:18:41 +0000600 "Unexpected linkage type!");
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000601 return emitError("Linking globals named '" + Src->getName() +
Chris Lattnerfc61de32004-12-03 22:18:41 +0000602 "': symbol multiply defined!");
603 }
Anton Korobeynikov31fc4f92007-04-29 20:56:48 +0000604
Rafael Espindola23f8d642012-01-05 23:02:01 +0000605 // Compute the visibility. We follow the rules in the System V Application
606 // Binary Interface.
607 Vis = isLessConstraining(Src->getVisibility(), Dest->getVisibility()) ?
608 Dest->getVisibility() : Src->getVisibility();
Chris Lattnerfc61de32004-12-03 22:18:41 +0000609 return false;
610}
Reid Spencer361e5132004-11-12 20:37:43 +0000611
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000612/// computeTypeMapping - Loop over all of the linked values to compute type
613/// mappings. For example, if we link "extern Foo *x" and "Foo *x = NULL", then
614/// we have two struct types 'Foo' but one got renamed when the module was
615/// loaded into the same LLVMContext.
616void ModuleLinker::computeTypeMapping() {
617 // Incorporate globals.
618 for (Module::global_iterator I = SrcM->global_begin(),
619 E = SrcM->global_end(); I != E; ++I) {
620 GlobalValue *DGV = getLinkedToGlobal(I);
Craig Topper2617dcc2014-04-15 06:32:26 +0000621 if (!DGV) continue;
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000622
623 if (!DGV->hasAppendingLinkage() || !I->hasAppendingLinkage()) {
624 TypeMap.addTypeMapping(DGV->getType(), I->getType());
625 continue;
626 }
627
628 // Unify the element type of appending arrays.
629 ArrayType *DAT = cast<ArrayType>(DGV->getType()->getElementType());
630 ArrayType *SAT = cast<ArrayType>(I->getType()->getElementType());
631 TypeMap.addTypeMapping(DAT->getElementType(), SAT->getElementType());
Devang Patel5c310be2009-08-11 18:01:24 +0000632 }
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000633
634 // Incorporate functions.
635 for (Module::iterator I = SrcM->begin(), E = SrcM->end(); I != E; ++I) {
636 if (GlobalValue *DGV = getLinkedToGlobal(I))
637 TypeMap.addTypeMapping(DGV->getType(), I->getType());
638 }
Bill Wendling7b464612012-02-27 22:34:19 +0000639
Bill Wendlingd48b7782012-02-28 04:01:21 +0000640 // Incorporate types by name, scanning all the types in the source module.
641 // At this point, the destination module may have a type "%foo = { i32 }" for
Bill Wendling2b3f61a2012-02-27 23:48:30 +0000642 // example. When the source module got loaded into the same LLVMContext, if
643 // it had the same type, it would have been renamed to "%foo.42 = { i32 }".
Bill Wendling8555a372012-08-03 00:30:35 +0000644 TypeFinder SrcStructTypes;
645 SrcStructTypes.run(*SrcM, true);
Bill Wendling2b3f61a2012-02-27 23:48:30 +0000646 SmallPtrSet<StructType*, 32> SrcStructTypesSet(SrcStructTypes.begin(),
647 SrcStructTypes.end());
Bill Wendling87374802012-03-23 23:17:38 +0000648
Bill Wendling2b3f61a2012-02-27 23:48:30 +0000649 for (unsigned i = 0, e = SrcStructTypes.size(); i != e; ++i) {
650 StructType *ST = SrcStructTypes[i];
651 if (!ST->hasName()) continue;
652
653 // Check to see if there is a dot in the name followed by a digit.
Bill Wendlingd48b7782012-02-28 04:01:21 +0000654 size_t DotPos = ST->getName().rfind('.');
655 if (DotPos == 0 || DotPos == StringRef::npos ||
Guy Benyei83c74e92013-02-12 21:21:59 +0000656 ST->getName().back() == '.' ||
657 !isdigit(static_cast<unsigned char>(ST->getName()[DotPos+1])))
Bill Wendlingd48b7782012-02-28 04:01:21 +0000658 continue;
Bill Wendling2b3f61a2012-02-27 23:48:30 +0000659
660 // Check to see if the destination module has a struct with the prefix name.
Bill Wendlingd48b7782012-02-28 04:01:21 +0000661 if (StructType *DST = DstM->getTypeByName(ST->getName().substr(0, DotPos)))
Bill Wendling87374802012-03-23 23:17:38 +0000662 // Don't use it if this actually came from the source module. They're in
663 // the same LLVMContext after all. Also don't use it unless the type is
664 // actually used in the destination module. This can happen in situations
665 // like this:
666 //
667 // Module A Module B
668 // -------- --------
669 // %Z = type { %A } %B = type { %C.1 }
670 // %A = type { %B.1, [7 x i8] } %C.1 = type { i8* }
671 // %B.1 = type { %C } %A.2 = type { %B.3, [5 x i8] }
672 // %C = type { i8* } %B.3 = type { %C.1 }
673 //
674 // When we link Module B with Module A, the '%B' in Module B is
675 // used. However, that would then use '%C.1'. But when we process '%C.1',
676 // we prefer to take the '%C' version. So we are then left with both
677 // '%C.1' and '%C' being used for the same types. This leads to some
678 // variables using one type and some using the other.
Rafael Espindolaaa9918a2013-05-04 05:05:18 +0000679 if (!SrcStructTypesSet.count(DST) && TypeMap.DstStructTypesSet.count(DST))
Bill Wendling2b3f61a2012-02-27 23:48:30 +0000680 TypeMap.addTypeMapping(DST, ST);
681 }
682
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000683 // Don't bother incorporating aliases, they aren't generally typed well.
Bill Wendlingd48b7782012-02-28 04:01:21 +0000684
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000685 // Now that we have discovered all of the type equivalences, get a body for
686 // any 'opaque' types in the dest module that are now resolved.
687 TypeMap.linkDefinedTypeBodies();
Devang Patel5c310be2009-08-11 18:01:24 +0000688}
689
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000690/// linkAppendingVarProto - If there were any appending global variables, link
691/// them together now. Return true on error.
692bool ModuleLinker::linkAppendingVarProto(GlobalVariable *DstGV,
693 GlobalVariable *SrcGV) {
Bill Wendlingd48b7782012-02-28 04:01:21 +0000694
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000695 if (!SrcGV->hasAppendingLinkage() || !DstGV->hasAppendingLinkage())
696 return emitError("Linking globals named '" + SrcGV->getName() +
697 "': can only link appending global with another appending global!");
698
699 ArrayType *DstTy = cast<ArrayType>(DstGV->getType()->getElementType());
700 ArrayType *SrcTy =
701 cast<ArrayType>(TypeMap.get(SrcGV->getType()->getElementType()));
702 Type *EltTy = DstTy->getElementType();
703
704 // Check to see that they two arrays agree on type.
705 if (EltTy != SrcTy->getElementType())
706 return emitError("Appending variables with different element types!");
707 if (DstGV->isConstant() != SrcGV->isConstant())
708 return emitError("Appending variables linked with different const'ness!");
709
710 if (DstGV->getAlignment() != SrcGV->getAlignment())
711 return emitError(
712 "Appending variables with different alignment need to be linked!");
713
714 if (DstGV->getVisibility() != SrcGV->getVisibility())
715 return emitError(
716 "Appending variables with different visibility need to be linked!");
Rafael Espindolafac3a012013-09-04 15:33:34 +0000717
718 if (DstGV->hasUnnamedAddr() != SrcGV->hasUnnamedAddr())
719 return emitError(
720 "Appending variables with different unnamed_addr need to be linked!");
721
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000722 if (DstGV->getSection() != SrcGV->getSection())
723 return emitError(
724 "Appending variables with different section name need to be linked!");
725
726 uint64_t NewSize = DstTy->getNumElements() + SrcTy->getNumElements();
727 ArrayType *NewType = ArrayType::get(EltTy, NewSize);
728
729 // Create the new global variable.
730 GlobalVariable *NG =
731 new GlobalVariable(*DstGV->getParent(), NewType, SrcGV->isConstant(),
Craig Topper2617dcc2014-04-15 06:32:26 +0000732 DstGV->getLinkage(), /*init*/nullptr, /*name*/"", DstGV,
Hans Wennborgcbe34b42012-06-23 11:37:03 +0000733 DstGV->getThreadLocalMode(),
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000734 DstGV->getType()->getAddressSpace());
735
736 // Propagate alignment, visibility and section info.
Bill Wendlingb6af2f32012-03-22 20:28:27 +0000737 copyGVAttributes(NG, DstGV);
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000738
739 AppendingVarInfo AVI;
740 AVI.NewGV = NG;
741 AVI.DstInit = DstGV->getInitializer();
742 AVI.SrcInit = SrcGV->getInitializer();
743 AppendingVars.push_back(AVI);
Mikhail Glushenkov766d4892009-03-03 07:22:23 +0000744
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000745 // Replace any uses of the two global variables with uses of the new
746 // global.
747 ValueMap[SrcGV] = ConstantExpr::getBitCast(NG, TypeMap.get(SrcGV->getType()));
Anton Korobeynikove79f4c72008-03-10 22:34:28 +0000748
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000749 DstGV->replaceAllUsesWith(ConstantExpr::getBitCast(NG, DstGV->getType()));
750 DstGV->eraseFromParent();
751
Tanya Lattnercbb91402011-10-11 00:24:54 +0000752 // Track the source variable so we don't try to link it.
753 DoNotLinkFromSource.insert(SrcGV);
754
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000755 return false;
756}
Mikhail Glushenkov766d4892009-03-03 07:22:23 +0000757
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000758/// linkGlobalProto - Loop through the global variables in the src module and
759/// merge them into the dest module.
760bool ModuleLinker::linkGlobalProto(GlobalVariable *SGV) {
761 GlobalValue *DGV = getLinkedToGlobal(SGV);
Rafael Espindola23f8d642012-01-05 23:02:01 +0000762 llvm::Optional<GlobalValue::VisibilityTypes> NewVisibility;
Rafael Espindolad4885da2013-09-04 14:05:09 +0000763 bool HasUnnamedAddr = SGV->hasUnnamedAddr();
Mikhail Glushenkov766d4892009-03-03 07:22:23 +0000764
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000765 if (DGV) {
766 // Concatenation of appending linkage variables is magic and handled later.
767 if (DGV->hasAppendingLinkage() || SGV->hasAppendingLinkage())
768 return linkAppendingVarProto(cast<GlobalVariable>(DGV), SGV);
769
770 // Determine whether linkage of these two globals follows the source
771 // module's definition or the destination module's definition.
Chris Lattner1b9633d2006-11-09 05:18:12 +0000772 GlobalValue::LinkageTypes NewLinkage = GlobalValue::InternalLinkage;
Rafael Espindola23f8d642012-01-05 23:02:01 +0000773 GlobalValue::VisibilityTypes NV;
Chris Lattner1b9633d2006-11-09 05:18:12 +0000774 bool LinkFromSrc = false;
Rafael Espindola23f8d642012-01-05 23:02:01 +0000775 if (getLinkageResult(DGV, SGV, NewLinkage, NV, LinkFromSrc))
Chris Lattnerfc61de32004-12-03 22:18:41 +0000776 return true;
Rafael Espindola23f8d642012-01-05 23:02:01 +0000777 NewVisibility = NV;
Rafael Espindolafd9a9412013-09-04 14:59:03 +0000778 HasUnnamedAddr = HasUnnamedAddr && DGV->hasUnnamedAddr();
Reid Spencer361e5132004-11-12 20:37:43 +0000779
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000780 // If we're not linking from the source, then keep the definition that we
781 // have.
782 if (!LinkFromSrc) {
783 // Special case for const propagation.
784 if (GlobalVariable *DGVar = dyn_cast<GlobalVariable>(DGV))
785 if (DGVar->isDeclaration() && SGV->isConstant() && !DGVar->isConstant())
786 DGVar->setConstant(true);
Rafael Espindolad4885da2013-09-04 14:05:09 +0000787
788 // Set calculated linkage, visibility and unnamed_addr.
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000789 DGV->setLinkage(NewLinkage);
Rafael Espindola23f8d642012-01-05 23:02:01 +0000790 DGV->setVisibility(*NewVisibility);
Rafael Espindolad4885da2013-09-04 14:05:09 +0000791 DGV->setUnnamedAddr(HasUnnamedAddr);
Rafael Espindola23f8d642012-01-05 23:02:01 +0000792
Chris Lattner0ead7a52008-07-14 07:23:24 +0000793 // Make sure to remember this mapping.
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000794 ValueMap[SGV] = ConstantExpr::getBitCast(DGV,TypeMap.get(SGV->getType()));
795
Tanya Lattnercbb91402011-10-11 00:24:54 +0000796 // Track the source global so that we don't attempt to copy it over when
797 // processing global initializers.
798 DoNotLinkFromSource.insert(SGV);
799
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000800 return false;
Chris Lattner0ead7a52008-07-14 07:23:24 +0000801 }
Reid Spencer361e5132004-11-12 20:37:43 +0000802 }
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000803
804 // No linking to be performed or linking from the source: simply create an
805 // identical version of the symbol over in the dest module... the
806 // initializer will be filled in later by LinkGlobalInits.
807 GlobalVariable *NewDGV =
808 new GlobalVariable(*DstM, TypeMap.get(SGV->getType()->getElementType()),
Craig Topper2617dcc2014-04-15 06:32:26 +0000809 SGV->isConstant(), SGV->getLinkage(), /*init*/nullptr,
810 SGV->getName(), /*insertbefore*/nullptr,
Hans Wennborgcbe34b42012-06-23 11:37:03 +0000811 SGV->getThreadLocalMode(),
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000812 SGV->getType()->getAddressSpace());
813 // Propagate alignment, visibility and section info.
Bill Wendlingb6af2f32012-03-22 20:28:27 +0000814 copyGVAttributes(NewDGV, SGV);
Rafael Espindola23f8d642012-01-05 23:02:01 +0000815 if (NewVisibility)
816 NewDGV->setVisibility(*NewVisibility);
Rafael Espindolad4885da2013-09-04 14:05:09 +0000817 NewDGV->setUnnamedAddr(HasUnnamedAddr);
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000818
819 if (DGV) {
820 DGV->replaceAllUsesWith(ConstantExpr::getBitCast(NewDGV, DGV->getType()));
821 DGV->eraseFromParent();
822 }
823
824 // Make sure to remember this mapping.
825 ValueMap[SGV] = NewDGV;
Reid Spencer361e5132004-11-12 20:37:43 +0000826 return false;
827}
828
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000829/// linkFunctionProto - Link the function in the source module into the
830/// destination module if needed, setting up mapping information.
831bool ModuleLinker::linkFunctionProto(Function *SF) {
832 GlobalValue *DGV = getLinkedToGlobal(SF);
Rafael Espindola23f8d642012-01-05 23:02:01 +0000833 llvm::Optional<GlobalValue::VisibilityTypes> NewVisibility;
Rafael Espindolafd9a9412013-09-04 14:59:03 +0000834 bool HasUnnamedAddr = SF->hasUnnamedAddr();
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000835
836 if (DGV) {
837 GlobalValue::LinkageTypes NewLinkage = GlobalValue::InternalLinkage;
838 bool LinkFromSrc = false;
Rafael Espindola23f8d642012-01-05 23:02:01 +0000839 GlobalValue::VisibilityTypes NV;
840 if (getLinkageResult(DGV, SF, NewLinkage, NV, LinkFromSrc))
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000841 return true;
Rafael Espindola23f8d642012-01-05 23:02:01 +0000842 NewVisibility = NV;
Rafael Espindolafd9a9412013-09-04 14:59:03 +0000843 HasUnnamedAddr = HasUnnamedAddr && DGV->hasUnnamedAddr();
Rafael Espindola23f8d642012-01-05 23:02:01 +0000844
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000845 if (!LinkFromSrc) {
846 // Set calculated linkage
847 DGV->setLinkage(NewLinkage);
Rafael Espindola23f8d642012-01-05 23:02:01 +0000848 DGV->setVisibility(*NewVisibility);
Rafael Espindolafd9a9412013-09-04 14:59:03 +0000849 DGV->setUnnamedAddr(HasUnnamedAddr);
Rafael Espindola23f8d642012-01-05 23:02:01 +0000850
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000851 // Make sure to remember this mapping.
852 ValueMap[SF] = ConstantExpr::getBitCast(DGV, TypeMap.get(SF->getType()));
853
Tanya Lattnercbb91402011-10-11 00:24:54 +0000854 // Track the function from the source module so we don't attempt to remap
855 // it.
856 DoNotLinkFromSource.insert(SF);
857
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000858 return false;
859 }
Anton Korobeynikovdac5fa92008-03-05 22:22:46 +0000860 }
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000861
James Molloyf6f121e2013-05-28 15:17:05 +0000862 // If the function is to be lazily linked, don't create it just yet.
863 // The ValueMaterializerTy will deal with creating it if it's used.
864 if (!DGV && (SF->hasLocalLinkage() || SF->hasLinkOnceLinkage() ||
865 SF->hasAvailableExternallyLinkage())) {
866 DoNotLinkFromSource.insert(SF);
867 return false;
868 }
869
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000870 // If there is no linkage to be performed or we are linking from the source,
871 // bring SF over.
872 Function *NewDF = Function::Create(TypeMap.get(SF->getFunctionType()),
873 SF->getLinkage(), SF->getName(), DstM);
Bill Wendlingb6af2f32012-03-22 20:28:27 +0000874 copyGVAttributes(NewDF, SF);
Rafael Espindola23f8d642012-01-05 23:02:01 +0000875 if (NewVisibility)
876 NewDF->setVisibility(*NewVisibility);
Rafael Espindolafd9a9412013-09-04 14:59:03 +0000877 NewDF->setUnnamedAddr(HasUnnamedAddr);
Anton Korobeynikovdac5fa92008-03-05 22:22:46 +0000878
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000879 if (DGV) {
880 // Any uses of DF need to change to NewDF, with cast.
881 DGV->replaceAllUsesWith(ConstantExpr::getBitCast(NewDF, DGV->getType()));
882 DGV->eraseFromParent();
Lauro Ramos Venanciob00c9c02007-06-28 19:02:54 +0000883 }
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000884
885 ValueMap[SF] = NewDF;
Lauro Ramos Venanciob00c9c02007-06-28 19:02:54 +0000886 return false;
887}
888
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000889/// LinkAliasProto - Set up prototypes for any aliases that come over from the
890/// source module.
891bool ModuleLinker::linkAliasProto(GlobalAlias *SGA) {
892 GlobalValue *DGV = getLinkedToGlobal(SGA);
Rafael Espindola23f8d642012-01-05 23:02:01 +0000893 llvm::Optional<GlobalValue::VisibilityTypes> NewVisibility;
894
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000895 if (DGV) {
896 GlobalValue::LinkageTypes NewLinkage = GlobalValue::InternalLinkage;
Rafael Espindola23f8d642012-01-05 23:02:01 +0000897 GlobalValue::VisibilityTypes NV;
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000898 bool LinkFromSrc = false;
Rafael Espindola23f8d642012-01-05 23:02:01 +0000899 if (getLinkageResult(DGV, SGA, NewLinkage, NV, LinkFromSrc))
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000900 return true;
Rafael Espindola23f8d642012-01-05 23:02:01 +0000901 NewVisibility = NV;
902
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000903 if (!LinkFromSrc) {
904 // Set calculated linkage.
905 DGV->setLinkage(NewLinkage);
Rafael Espindola23f8d642012-01-05 23:02:01 +0000906 DGV->setVisibility(*NewVisibility);
907
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000908 // Make sure to remember this mapping.
909 ValueMap[SGA] = ConstantExpr::getBitCast(DGV,TypeMap.get(SGA->getType()));
910
Tanya Lattnercbb91402011-10-11 00:24:54 +0000911 // Track the alias from the source module so we don't attempt to remap it.
912 DoNotLinkFromSource.insert(SGA);
913
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000914 return false;
915 }
916 }
917
918 // If there is no linkage to be performed or we're linking from the source,
919 // bring over SGA.
920 GlobalAlias *NewDA = new GlobalAlias(TypeMap.get(SGA->getType()),
921 SGA->getLinkage(), SGA->getName(),
Craig Topper2617dcc2014-04-15 06:32:26 +0000922 /*aliasee*/nullptr, DstM);
Bill Wendlingb6af2f32012-03-22 20:28:27 +0000923 copyGVAttributes(NewDA, SGA);
Rafael Espindola23f8d642012-01-05 23:02:01 +0000924 if (NewVisibility)
925 NewDA->setVisibility(*NewVisibility);
Reid Spencer361e5132004-11-12 20:37:43 +0000926
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000927 if (DGV) {
928 // Any uses of DGV need to change to NewDA, with cast.
929 DGV->replaceAllUsesWith(ConstantExpr::getBitCast(NewDA, DGV->getType()));
930 DGV->eraseFromParent();
931 }
932
933 ValueMap[SGA] = NewDA;
934 return false;
935}
936
Chris Lattner00245f42012-01-24 13:41:11 +0000937static void getArrayElements(Constant *C, SmallVectorImpl<Constant*> &Dest) {
Chris Lattner67058832012-01-25 06:48:06 +0000938 unsigned NumElements = cast<ArrayType>(C->getType())->getNumElements();
939
940 for (unsigned i = 0; i != NumElements; ++i)
941 Dest.push_back(C->getAggregateElement(i));
Chris Lattner00245f42012-01-24 13:41:11 +0000942}
943
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000944void ModuleLinker::linkAppendingVarInit(const AppendingVarInfo &AVI) {
945 // Merge the initializer.
946 SmallVector<Constant*, 16> Elements;
Chris Lattner00245f42012-01-24 13:41:11 +0000947 getArrayElements(AVI.DstInit, Elements);
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000948
James Molloyf6f121e2013-05-28 15:17:05 +0000949 Constant *SrcInit = MapValue(AVI.SrcInit, ValueMap, RF_None, &TypeMap, &ValMaterializer);
Chris Lattner00245f42012-01-24 13:41:11 +0000950 getArrayElements(SrcInit, Elements);
951
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000952 ArrayType *NewType = cast<ArrayType>(AVI.NewGV->getType()->getElementType());
953 AVI.NewGV->setInitializer(ConstantArray::get(NewType, Elements));
954}
955
Bill Wendlingb6af2f32012-03-22 20:28:27 +0000956/// linkGlobalInits - Update the initializers in the Dest module now that all
957/// globals that may be referenced are in Dest.
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000958void ModuleLinker::linkGlobalInits() {
Reid Spencer361e5132004-11-12 20:37:43 +0000959 // Loop over all of the globals in the src module, mapping them over as we go
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000960 for (Module::const_global_iterator I = SrcM->global_begin(),
961 E = SrcM->global_end(); I != E; ++I) {
Tanya Lattnercbb91402011-10-11 00:24:54 +0000962
963 // Only process initialized GV's or ones not already in dest.
964 if (!I->hasInitializer() || DoNotLinkFromSource.count(I)) continue;
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000965
966 // Grab destination global variable.
967 GlobalVariable *DGV = cast<GlobalVariable>(ValueMap[I]);
968 // Figure out what the initializer looks like in the dest module.
969 DGV->setInitializer(MapValue(I->getInitializer(), ValueMap,
James Molloyf6f121e2013-05-28 15:17:05 +0000970 RF_None, &TypeMap, &ValMaterializer));
Reid Spencer361e5132004-11-12 20:37:43 +0000971 }
Reid Spencer361e5132004-11-12 20:37:43 +0000972}
973
Bill Wendlingb6af2f32012-03-22 20:28:27 +0000974/// linkFunctionBody - Copy the source function over into the dest function and
975/// fix up references to values. At this point we know that Dest is an external
976/// function, and that Src is not.
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000977void ModuleLinker::linkFunctionBody(Function *Dst, Function *Src) {
978 assert(Src && Dst && Dst->isDeclaration() && !Src->isDeclaration());
Reid Spencer361e5132004-11-12 20:37:43 +0000979
Chris Lattner7391dde2004-11-16 17:12:38 +0000980 // Go through and convert function arguments over, remembering the mapping.
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000981 Function::arg_iterator DI = Dst->arg_begin();
Chris Lattner531f9e92005-03-15 04:54:21 +0000982 for (Function::arg_iterator I = Src->arg_begin(), E = Src->arg_end();
Reid Spencer361e5132004-11-12 20:37:43 +0000983 I != E; ++I, ++DI) {
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000984 DI->setName(I->getName()); // Copy the name over.
Reid Spencer361e5132004-11-12 20:37:43 +0000985
Chris Lattnerb1ed91f2011-07-09 17:41:24 +0000986 // Add a mapping to our mapping.
Anton Korobeynikov66a62712008-03-10 22:36:08 +0000987 ValueMap[I] = DI;
Reid Spencer361e5132004-11-12 20:37:43 +0000988 }
989
Tanya Lattnercbb91402011-10-11 00:24:54 +0000990 if (Mode == Linker::DestroySource) {
991 // Splice the body of the source function into the dest function.
992 Dst->getBasicBlockList().splice(Dst->end(), Src->getBasicBlockList());
993
994 // At this point, all of the instructions and values of the function are now
995 // copied over. The only problem is that they are still referencing values in
996 // the Source function as operands. Loop through all of the operands of the
997 // functions and patch them up to point to the local versions.
998 for (Function::iterator BB = Dst->begin(), BE = Dst->end(); BB != BE; ++BB)
999 for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I)
James Molloyf6f121e2013-05-28 15:17:05 +00001000 RemapInstruction(I, ValueMap, RF_IgnoreMissingEntries,
1001 &TypeMap, &ValMaterializer);
Tanya Lattnercbb91402011-10-11 00:24:54 +00001002
1003 } else {
1004 // Clone the body of the function into the dest function.
1005 SmallVector<ReturnInst*, 8> Returns; // Ignore returns.
Craig Topper2617dcc2014-04-15 06:32:26 +00001006 CloneFunctionInto(Dst, Src, ValueMap, false, Returns, "", nullptr,
James Molloyf6f121e2013-05-28 15:17:05 +00001007 &TypeMap, &ValMaterializer);
Tanya Lattnercbb91402011-10-11 00:24:54 +00001008 }
1009
Chris Lattner7391dde2004-11-16 17:12:38 +00001010 // There is no need to map the arguments anymore.
Chris Lattner44ab8ae2006-06-16 01:24:04 +00001011 for (Function::arg_iterator I = Src->arg_begin(), E = Src->arg_end();
1012 I != E; ++I)
Reid Spencer3aaaa0b2007-02-05 20:47:22 +00001013 ValueMap.erase(I);
Tanya Lattnercbb91402011-10-11 00:24:54 +00001014
Reid Spencer361e5132004-11-12 20:37:43 +00001015}
1016
Bill Wendlingb6af2f32012-03-22 20:28:27 +00001017/// linkAliasBodies - Insert all of the aliases in Src into the Dest module.
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001018void ModuleLinker::linkAliasBodies() {
1019 for (Module::alias_iterator I = SrcM->alias_begin(), E = SrcM->alias_end();
Tanya Lattnercbb91402011-10-11 00:24:54 +00001020 I != E; ++I) {
1021 if (DoNotLinkFromSource.count(I))
1022 continue;
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001023 if (Constant *Aliasee = I->getAliasee()) {
1024 GlobalAlias *DA = cast<GlobalAlias>(ValueMap[I]);
James Molloyf6f121e2013-05-28 15:17:05 +00001025 DA->setAliasee(MapValue(Aliasee, ValueMap, RF_None,
1026 &TypeMap, &ValMaterializer));
David Chisnall2c4a34a2010-01-09 16:27:31 +00001027 }
Tanya Lattnercbb91402011-10-11 00:24:54 +00001028 }
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001029}
Anton Korobeynikov26098882008-03-05 23:21:39 +00001030
Bill Wendlingb6af2f32012-03-22 20:28:27 +00001031/// linkNamedMDNodes - Insert all of the named MDNodes in Src into the Dest
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001032/// module.
1033void ModuleLinker::linkNamedMDNodes() {
Bill Wendling66f02412012-02-11 11:38:06 +00001034 const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata();
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001035 for (Module::const_named_metadata_iterator I = SrcM->named_metadata_begin(),
1036 E = SrcM->named_metadata_end(); I != E; ++I) {
Bill Wendling66f02412012-02-11 11:38:06 +00001037 // Don't link module flags here. Do them separately.
1038 if (&*I == SrcModFlags) continue;
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001039 NamedMDNode *DestNMD = DstM->getOrInsertNamedMetadata(I->getName());
1040 // Add Src elements into Dest node.
1041 for (unsigned i = 0, e = I->getNumOperands(); i != e; ++i)
1042 DestNMD->addOperand(MapValue(I->getOperand(i), ValueMap,
James Molloyf6f121e2013-05-28 15:17:05 +00001043 RF_None, &TypeMap, &ValMaterializer));
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001044 }
1045}
Bill Wendling66f02412012-02-11 11:38:06 +00001046
Bill Wendling66f02412012-02-11 11:38:06 +00001047/// linkModuleFlagsMetadata - Merge the linker flags in Src into the Dest
1048/// module.
1049bool ModuleLinker::linkModuleFlagsMetadata() {
Daniel Dunbar0ec72bb2013-01-16 18:39:23 +00001050 // If the source module has no module flags, we are done.
Bill Wendling66f02412012-02-11 11:38:06 +00001051 const NamedMDNode *SrcModFlags = SrcM->getModuleFlagsMetadata();
1052 if (!SrcModFlags) return false;
1053
Bill Wendling66f02412012-02-11 11:38:06 +00001054 // If the destination module doesn't have module flags yet, then just copy
1055 // over the source module's flags.
Daniel Dunbar0ec72bb2013-01-16 18:39:23 +00001056 NamedMDNode *DstModFlags = DstM->getOrInsertModuleFlagsMetadata();
Bill Wendling66f02412012-02-11 11:38:06 +00001057 if (DstModFlags->getNumOperands() == 0) {
1058 for (unsigned I = 0, E = SrcModFlags->getNumOperands(); I != E; ++I)
1059 DstModFlags->addOperand(SrcModFlags->getOperand(I));
1060
1061 return false;
1062 }
1063
Daniel Dunbar0ec72bb2013-01-16 18:39:23 +00001064 // First build a map of the existing module flags and requirements.
1065 DenseMap<MDString*, MDNode*> Flags;
1066 SmallSetVector<MDNode*, 16> Requirements;
1067 for (unsigned I = 0, E = DstModFlags->getNumOperands(); I != E; ++I) {
1068 MDNode *Op = DstModFlags->getOperand(I);
1069 ConstantInt *Behavior = cast<ConstantInt>(Op->getOperand(0));
1070 MDString *ID = cast<MDString>(Op->getOperand(1));
Bill Wendling66f02412012-02-11 11:38:06 +00001071
Daniel Dunbar0ec72bb2013-01-16 18:39:23 +00001072 if (Behavior->getZExtValue() == Module::Require) {
1073 Requirements.insert(cast<MDNode>(Op->getOperand(2)));
1074 } else {
1075 Flags[ID] = Op;
1076 }
Bill Wendling66f02412012-02-11 11:38:06 +00001077 }
1078
Daniel Dunbar0ec72bb2013-01-16 18:39:23 +00001079 // Merge in the flags from the source module, and also collect its set of
1080 // requirements.
1081 bool HasErr = false;
1082 for (unsigned I = 0, E = SrcModFlags->getNumOperands(); I != E; ++I) {
1083 MDNode *SrcOp = SrcModFlags->getOperand(I);
1084 ConstantInt *SrcBehavior = cast<ConstantInt>(SrcOp->getOperand(0));
1085 MDString *ID = cast<MDString>(SrcOp->getOperand(1));
1086 MDNode *DstOp = Flags.lookup(ID);
1087 unsigned SrcBehaviorValue = SrcBehavior->getZExtValue();
Bill Wendling66f02412012-02-11 11:38:06 +00001088
Daniel Dunbar0ec72bb2013-01-16 18:39:23 +00001089 // If this is a requirement, add it and continue.
1090 if (SrcBehaviorValue == Module::Require) {
1091 // If the destination module does not already have this requirement, add
1092 // it.
1093 if (Requirements.insert(cast<MDNode>(SrcOp->getOperand(2)))) {
1094 DstModFlags->addOperand(SrcOp);
1095 }
1096 continue;
Bill Wendling66f02412012-02-11 11:38:06 +00001097 }
1098
Daniel Dunbar0ec72bb2013-01-16 18:39:23 +00001099 // If there is no existing flag with this ID, just add it.
1100 if (!DstOp) {
1101 Flags[ID] = SrcOp;
1102 DstModFlags->addOperand(SrcOp);
1103 continue;
1104 }
1105
1106 // Otherwise, perform a merge.
1107 ConstantInt *DstBehavior = cast<ConstantInt>(DstOp->getOperand(0));
1108 unsigned DstBehaviorValue = DstBehavior->getZExtValue();
1109
1110 // If either flag has override behavior, handle it first.
1111 if (DstBehaviorValue == Module::Override) {
1112 // Diagnose inconsistent flags which both have override behavior.
1113 if (SrcBehaviorValue == Module::Override &&
1114 SrcOp->getOperand(2) != DstOp->getOperand(2)) {
1115 HasErr |= emitError("linking module flags '" + ID->getString() +
1116 "': IDs have conflicting override values");
1117 }
1118 continue;
1119 } else if (SrcBehaviorValue == Module::Override) {
1120 // Update the destination flag to that of the source.
1121 DstOp->replaceOperandWith(0, SrcBehavior);
1122 DstOp->replaceOperandWith(2, SrcOp->getOperand(2));
1123 continue;
1124 }
1125
1126 // Diagnose inconsistent merge behavior types.
1127 if (SrcBehaviorValue != DstBehaviorValue) {
1128 HasErr |= emitError("linking module flags '" + ID->getString() +
1129 "': IDs have conflicting behaviors");
1130 continue;
1131 }
1132
1133 // Perform the merge for standard behavior types.
1134 switch (SrcBehaviorValue) {
1135 case Module::Require:
1136 case Module::Override: assert(0 && "not possible"); break;
1137 case Module::Error: {
1138 // Emit an error if the values differ.
1139 if (SrcOp->getOperand(2) != DstOp->getOperand(2)) {
1140 HasErr |= emitError("linking module flags '" + ID->getString() +
1141 "': IDs have conflicting values");
1142 }
1143 continue;
1144 }
1145 case Module::Warning: {
1146 // Emit a warning if the values differ.
1147 if (SrcOp->getOperand(2) != DstOp->getOperand(2)) {
Eli Benderskye17f3702014-02-06 18:01:56 +00001148 if (!SuppressWarnings) {
1149 errs() << "WARNING: linking module flags '" << ID->getString()
1150 << "': IDs have conflicting values";
1151 }
Daniel Dunbar0ec72bb2013-01-16 18:39:23 +00001152 }
1153 continue;
1154 }
Daniel Dunbard77d9fb2013-01-16 21:38:56 +00001155 case Module::Append: {
1156 MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2));
1157 MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2));
1158 unsigned NumOps = DstValue->getNumOperands() + SrcValue->getNumOperands();
1159 Value **VP, **Values = VP = new Value*[NumOps];
1160 for (unsigned i = 0, e = DstValue->getNumOperands(); i != e; ++i, ++VP)
1161 *VP = DstValue->getOperand(i);
1162 for (unsigned i = 0, e = SrcValue->getNumOperands(); i != e; ++i, ++VP)
1163 *VP = SrcValue->getOperand(i);
1164 DstOp->replaceOperandWith(2, MDNode::get(DstM->getContext(),
1165 ArrayRef<Value*>(Values,
1166 NumOps)));
1167 delete[] Values;
1168 break;
1169 }
1170 case Module::AppendUnique: {
1171 SmallSetVector<Value*, 16> Elts;
1172 MDNode *DstValue = cast<MDNode>(DstOp->getOperand(2));
1173 MDNode *SrcValue = cast<MDNode>(SrcOp->getOperand(2));
1174 for (unsigned i = 0, e = DstValue->getNumOperands(); i != e; ++i)
1175 Elts.insert(DstValue->getOperand(i));
1176 for (unsigned i = 0, e = SrcValue->getNumOperands(); i != e; ++i)
1177 Elts.insert(SrcValue->getOperand(i));
1178 DstOp->replaceOperandWith(2, MDNode::get(DstM->getContext(),
1179 ArrayRef<Value*>(Elts.begin(),
1180 Elts.end())));
1181 break;
1182 }
Daniel Dunbar0ec72bb2013-01-16 18:39:23 +00001183 }
Bill Wendling66f02412012-02-11 11:38:06 +00001184 }
1185
Daniel Dunbar0ec72bb2013-01-16 18:39:23 +00001186 // Check all of the requirements.
1187 for (unsigned I = 0, E = Requirements.size(); I != E; ++I) {
1188 MDNode *Requirement = Requirements[I];
1189 MDString *Flag = cast<MDString>(Requirement->getOperand(0));
1190 Value *ReqValue = Requirement->getOperand(1);
Bill Wendling66f02412012-02-11 11:38:06 +00001191
Daniel Dunbar0ec72bb2013-01-16 18:39:23 +00001192 MDNode *Op = Flags[Flag];
1193 if (!Op || Op->getOperand(2) != ReqValue) {
1194 HasErr |= emitError("linking module flags '" + Flag->getString() +
1195 "': does not have the required value");
1196 continue;
Bill Wendling66f02412012-02-11 11:38:06 +00001197 }
1198 }
1199
1200 return HasErr;
1201}
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001202
1203bool ModuleLinker::run() {
Bill Wendling66f02412012-02-11 11:38:06 +00001204 assert(DstM && "Null destination module");
1205 assert(SrcM && "Null source module");
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001206
1207 // Inherit the target data from the source module if the destination module
1208 // doesn't have one already.
Rafael Espindolaf863ee22014-02-25 20:01:08 +00001209 if (!DstM->getDataLayout() && SrcM->getDataLayout())
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001210 DstM->setDataLayout(SrcM->getDataLayout());
1211
1212 // Copy the target triple from the source to dest if the dest's is empty.
1213 if (DstM->getTargetTriple().empty() && !SrcM->getTargetTriple().empty())
1214 DstM->setTargetTriple(SrcM->getTargetTriple());
1215
Rafael Espindolaf863ee22014-02-25 20:01:08 +00001216 if (SrcM->getDataLayout() && DstM->getDataLayout() &&
Rafael Espindolaae593f12014-02-26 17:02:08 +00001217 *SrcM->getDataLayout() != *DstM->getDataLayout()) {
Eli Benderskye17f3702014-02-06 18:01:56 +00001218 if (!SuppressWarnings) {
JF Bastien026fc5f2014-03-05 21:26:42 +00001219 errs() << "WARNING: Linking two modules of different data layouts: '"
1220 << SrcM->getModuleIdentifier() << "' is '"
1221 << SrcM->getDataLayoutStr() << "' whereas '"
1222 << DstM->getModuleIdentifier() << "' is '"
1223 << DstM->getDataLayoutStr() << "'\n";
Eli Benderskye17f3702014-02-06 18:01:56 +00001224 }
1225 }
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001226 if (!SrcM->getTargetTriple().empty() &&
1227 DstM->getTargetTriple() != SrcM->getTargetTriple()) {
Eli Benderskye17f3702014-02-06 18:01:56 +00001228 if (!SuppressWarnings) {
JF Bastien026fc5f2014-03-05 21:26:42 +00001229 errs() << "WARNING: Linking two modules of different target triples: "
1230 << SrcM->getModuleIdentifier() << "' is '"
1231 << SrcM->getTargetTriple() << "' whereas '"
1232 << DstM->getModuleIdentifier() << "' is '"
Eli Benderskye17f3702014-02-06 18:01:56 +00001233 << DstM->getTargetTriple() << "'\n";
1234 }
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001235 }
1236
1237 // Append the module inline asm string.
1238 if (!SrcM->getModuleInlineAsm().empty()) {
1239 if (DstM->getModuleInlineAsm().empty())
1240 DstM->setModuleInlineAsm(SrcM->getModuleInlineAsm());
1241 else
1242 DstM->setModuleInlineAsm(DstM->getModuleInlineAsm()+"\n"+
1243 SrcM->getModuleInlineAsm());
1244 }
1245
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001246 // Loop over all of the linked values to compute type mappings.
1247 computeTypeMapping();
1248
1249 // Insert all of the globals in src into the DstM module... without linking
1250 // initializers (which could refer to functions not yet mapped over).
1251 for (Module::global_iterator I = SrcM->global_begin(),
1252 E = SrcM->global_end(); I != E; ++I)
1253 if (linkGlobalProto(I))
1254 return true;
1255
1256 // Link the functions together between the two modules, without doing function
1257 // bodies... this just adds external function prototypes to the DstM
1258 // function... We do this so that when we begin processing function bodies,
1259 // all of the global values that may be referenced are available in our
1260 // ValueMap.
1261 for (Module::iterator I = SrcM->begin(), E = SrcM->end(); I != E; ++I)
1262 if (linkFunctionProto(I))
1263 return true;
1264
1265 // If there were any aliases, link them now.
1266 for (Module::alias_iterator I = SrcM->alias_begin(),
1267 E = SrcM->alias_end(); I != E; ++I)
1268 if (linkAliasProto(I))
1269 return true;
1270
1271 for (unsigned i = 0, e = AppendingVars.size(); i != e; ++i)
1272 linkAppendingVarInit(AppendingVars[i]);
1273
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001274 // Link in the function bodies that are defined in the source module into
1275 // DstM.
1276 for (Module::iterator SF = SrcM->begin(), E = SrcM->end(); SF != E; ++SF) {
Tanya Lattnerea166d42011-10-14 22:17:46 +00001277 // Skip if not linking from source.
1278 if (DoNotLinkFromSource.count(SF)) continue;
1279
Peter Collingbourne3fa50f92013-09-16 01:08:15 +00001280 Function *DF = cast<Function>(ValueMap[SF]);
1281 if (SF->hasPrefixData()) {
1282 // Link in the prefix data.
1283 DF->setPrefixData(MapValue(
1284 SF->getPrefixData(), ValueMap, RF_None, &TypeMap, &ValMaterializer));
1285 }
1286
Tanya Lattnerea166d42011-10-14 22:17:46 +00001287 // Skip if no body (function is external) or materialize.
1288 if (SF->isDeclaration()) {
1289 if (!SF->isMaterializable())
1290 continue;
1291 if (SF->Materialize(&ErrorMsg))
1292 return true;
1293 }
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001294
Peter Collingbourne3fa50f92013-09-16 01:08:15 +00001295 linkFunctionBody(DF, SF);
Bill Wendling00623782012-03-23 07:22:49 +00001296 SF->Dematerialize();
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001297 }
1298
1299 // Resolve all uses of aliases with aliasees.
1300 linkAliasBodies();
1301
Bill Wendling66f02412012-02-11 11:38:06 +00001302 // Remap all of the named MDNodes in Src into the DstM module. We do this
Devang Patel6ddbb2e2011-08-04 19:44:28 +00001303 // after linking GlobalValues so that MDNodes that reference GlobalValues
1304 // are properly remapped.
1305 linkNamedMDNodes();
1306
Bill Wendling66f02412012-02-11 11:38:06 +00001307 // Merge the module flags into the DstM module.
1308 if (linkModuleFlagsMetadata())
1309 return true;
1310
Bill Wendling91686d62014-01-16 06:29:36 +00001311 // Update the initializers in the DstM module now that all globals that may
1312 // be referenced are in DstM.
1313 linkGlobalInits();
1314
Tanya Lattner0a48b872011-11-02 00:24:56 +00001315 // Process vector of lazily linked in functions.
1316 bool LinkedInAnyFunctions;
1317 do {
1318 LinkedInAnyFunctions = false;
1319
Bill Wendlingfa2287822013-03-27 17:54:41 +00001320 for(std::vector<Function*>::iterator I = LazilyLinkFunctions.begin(),
James Molloyf6f121e2013-05-28 15:17:05 +00001321 E = LazilyLinkFunctions.end(); I != E; ++I) {
Bill Wendlingfa2287822013-03-27 17:54:41 +00001322 Function *SF = *I;
James Molloyf6f121e2013-05-28 15:17:05 +00001323 if (!SF)
1324 continue;
Bill Wendling00623782012-03-23 07:22:49 +00001325
James Molloyf6f121e2013-05-28 15:17:05 +00001326 Function *DF = cast<Function>(ValueMap[SF]);
Peter Collingbourne3fa50f92013-09-16 01:08:15 +00001327 if (SF->hasPrefixData()) {
1328 // Link in the prefix data.
1329 DF->setPrefixData(MapValue(SF->getPrefixData(),
1330 ValueMap,
1331 RF_None,
1332 &TypeMap,
1333 &ValMaterializer));
1334 }
James Molloyf6f121e2013-05-28 15:17:05 +00001335
1336 // Materialize if necessary.
1337 if (SF->isDeclaration()) {
1338 if (!SF->isMaterializable())
1339 continue;
1340 if (SF->Materialize(&ErrorMsg))
1341 return true;
Tanya Lattner0a48b872011-11-02 00:24:56 +00001342 }
James Molloyf6f121e2013-05-28 15:17:05 +00001343
1344 // Erase from vector *before* the function body is linked - linkFunctionBody could
1345 // invalidate I.
1346 LazilyLinkFunctions.erase(I);
1347
1348 // Link in function body.
1349 linkFunctionBody(DF, SF);
1350 SF->Dematerialize();
1351
1352 // Set flag to indicate we may have more functions to lazily link in
1353 // since we linked in a function.
1354 LinkedInAnyFunctions = true;
1355 break;
Tanya Lattner0a48b872011-11-02 00:24:56 +00001356 }
1357 } while (LinkedInAnyFunctions);
1358
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001359 // Now that all of the types from the source are used, resolve any structs
1360 // copied over to the dest that didn't exist there.
1361 TypeMap.linkDefinedTypeBodies();
1362
Anton Korobeynikov26098882008-03-05 23:21:39 +00001363 return false;
1364}
Reid Spencer361e5132004-11-12 20:37:43 +00001365
Eli Bendersky7da92ed2014-02-20 22:19:24 +00001366Linker::Linker(Module *M, bool SuppressWarnings)
1367 : Composite(M), SuppressWarnings(SuppressWarnings) {
Rafael Espindolaaa9918a2013-05-04 05:05:18 +00001368 TypeFinder StructTypes;
1369 StructTypes.run(*M, true);
1370 IdentifiedStructTypes.insert(StructTypes.begin(), StructTypes.end());
1371}
Rafael Espindola3df61b72013-05-04 03:48:37 +00001372
1373Linker::~Linker() {
1374}
1375
Bill Wendling91e6f6e2013-10-16 08:59:57 +00001376void Linker::deleteModule() {
1377 delete Composite;
Craig Topper2617dcc2014-04-15 06:32:26 +00001378 Composite = nullptr;
Bill Wendling91e6f6e2013-10-16 08:59:57 +00001379}
1380
Rafael Espindola3df61b72013-05-04 03:48:37 +00001381bool Linker::linkInModule(Module *Src, unsigned Mode, std::string *ErrorMsg) {
Eli Bendersky7da92ed2014-02-20 22:19:24 +00001382 ModuleLinker TheLinker(Composite, IdentifiedStructTypes, Src, Mode,
1383 SuppressWarnings);
Rafael Espindola287f18b2013-05-04 04:08:02 +00001384 if (TheLinker.run()) {
1385 if (ErrorMsg)
1386 *ErrorMsg = TheLinker.ErrorMsg;
1387 return true;
1388 }
1389 return false;
Rafael Espindola3df61b72013-05-04 03:48:37 +00001390}
1391
Chris Lattnerb1ed91f2011-07-09 17:41:24 +00001392//===----------------------------------------------------------------------===//
1393// LinkModules entrypoint.
1394//===----------------------------------------------------------------------===//
1395
Bill Wendlingb6af2f32012-03-22 20:28:27 +00001396/// LinkModules - This function links two modules together, with the resulting
Eli Bendersky970cc632013-03-08 22:29:44 +00001397/// Dest module modified to be the composite of the two input modules. If an
Bill Wendlingb6af2f32012-03-22 20:28:27 +00001398/// error occurs, true is returned and ErrorMsg (if not null) is set to indicate
1399/// the problem. Upon failure, the Dest module could be in a modified state,
1400/// and shouldn't be relied on to be consistent.
Tanya Lattnercbb91402011-10-11 00:24:54 +00001401bool Linker::LinkModules(Module *Dest, Module *Src, unsigned Mode,
1402 std::string *ErrorMsg) {
Rafael Espindola287f18b2013-05-04 04:08:02 +00001403 Linker L(Dest);
1404 return L.linkInModule(Src, Mode, ErrorMsg);
Reid Spencer361e5132004-11-12 20:37:43 +00001405}
Bill Wendlinga3aeb982012-05-09 08:55:40 +00001406
1407//===----------------------------------------------------------------------===//
1408// C API.
1409//===----------------------------------------------------------------------===//
1410
1411LLVMBool LLVMLinkModules(LLVMModuleRef Dest, LLVMModuleRef Src,
1412 LLVMLinkerMode Mode, char **OutMessages) {
1413 std::string Messages;
1414 LLVMBool Result = Linker::LinkModules(unwrap(Dest), unwrap(Src),
Craig Topper2617dcc2014-04-15 06:32:26 +00001415 Mode, OutMessages? &Messages : nullptr);
Bill Wendlinga3aeb982012-05-09 08:55:40 +00001416 if (OutMessages)
1417 *OutMessages = strdup(Messages.c_str());
1418 return Result;
1419}