1 //===- Linker.cpp - Module Linker Implementation --------------------------===//
3 // This file implements the LLVM module linker.
6 // * Merges global variables between the two modules
7 // * Uninit + Uninit = Init, Init + Uninit = Init, Init + Init = Error if !=
8 // * Merges methods between two modules
10 //===----------------------------------------------------------------------===//
12 #include "llvm/Transforms/Linker.h"
13 #include "llvm/Module.h"
14 #include "llvm/Function.h"
15 #include "llvm/BasicBlock.h"
16 #include "llvm/GlobalVariable.h"
17 #include "llvm/SymbolTable.h"
18 #include "llvm/DerivedTypes.h"
19 #include "llvm/iOther.h"
20 #include "llvm/ConstantVals.h"
26 // Error - Simple wrapper function to conditionally assign to E and return true.
27 // This just makes error return conditions a little bit simpler...
29 static inline bool Error(string *E, string Message) {
34 // LinkTypes - Go through the symbol table of the Src module and see if any
35 // types are named in the src module that are not named in the Dst module.
36 // Make sure there are no type name conflicts.
38 static bool LinkTypes(Module *Dest, const Module *Src, string *Err = 0) {
39 // No symbol table? Can't have named types.
40 if (!Src->hasSymbolTable()) return false;
42 SymbolTable *DestST = Dest->getSymbolTableSure();
43 const SymbolTable *SrcST = Src->getSymbolTable();
45 // Look for a type plane for Type's...
46 SymbolTable::const_iterator PI = SrcST->find(Type::TypeTy);
47 if (PI == SrcST->end()) return false; // No named types, do nothing.
49 const SymbolTable::VarMap &VM = PI->second;
50 for (SymbolTable::type_const_iterator I = VM.begin(), E = VM.end();
52 const string &Name = I->first;
53 const Type *RHS = cast<Type>(I->second);
55 // Check to see if this type name is already in the dest module...
56 const Type *Entry = cast_or_null<Type>(DestST->lookup(Type::TypeTy, Name));
57 if (Entry) { // Yup, the value already exists...
58 if (Entry != RHS) // If it's the same, noop. Otherwise, error.
59 return Error(Err, "Type named '" + Name +
60 "' of different shape in modules.\n Src='" +
61 Entry->getDescription() + "'.\n Dst='" +
62 RHS->getDescription() + "'");
63 } else { // Type not in dest module. Add it now.
64 // TODO: FIXME WHEN TYPES AREN'T CONST
65 DestST->insert(Name, const_cast<Type*>(RHS));
71 static void PrintMap(const map<const Value*, Value*> &M) {
72 for (map<const Value*, Value*>::const_iterator I = M.begin(), E = M.end();
74 cerr << " Fr: " << (void*)I->first << " ";
76 cerr << " To: " << (void*)I->second << " ";
83 // RemapOperand - Use LocalMap and GlobalMap to convert references from one
84 // module to another. This is somewhat sophisticated in that it can
85 // automatically handle constant references correctly as well...
87 static Value *RemapOperand(const Value *In, map<const Value*, Value*> &LocalMap,
88 const map<const Value*, Value*> *GlobalMap = 0) {
89 map<const Value*,Value*>::const_iterator I = LocalMap.find(In);
90 if (I != LocalMap.end()) return I->second;
93 I = GlobalMap->find(In);
94 if (I != GlobalMap->end()) return I->second;
97 // Check to see if it's a constant that we are interesting in transforming...
98 if (Constant *CPV = dyn_cast<Constant>(In)) {
99 if (!isa<DerivedType>(CPV->getType()))
100 return CPV; // Simple constants stay identical...
102 Constant *Result = 0;
104 if (ConstantArray *CPA = dyn_cast<ConstantArray>(CPV)) {
105 const std::vector<Use> &Ops = CPA->getValues();
106 std::vector<Constant*> Operands(Ops.size());
107 for (unsigned i = 0; i < Ops.size(); ++i)
109 cast<Constant>(RemapOperand(Ops[i], LocalMap, GlobalMap));
110 Result = ConstantArray::get(cast<ArrayType>(CPA->getType()), Operands);
111 } else if (ConstantStruct *CPS = dyn_cast<ConstantStruct>(CPV)) {
112 const std::vector<Use> &Ops = CPS->getValues();
113 std::vector<Constant*> Operands(Ops.size());
114 for (unsigned i = 0; i < Ops.size(); ++i)
116 cast<Constant>(RemapOperand(Ops[i], LocalMap, GlobalMap));
117 Result = ConstantStruct::get(cast<StructType>(CPS->getType()), Operands);
118 } else if (isa<ConstantPointerNull>(CPV)) {
120 } else if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(CPV)) {
121 Value *V = RemapOperand(CPR->getValue(), LocalMap, GlobalMap);
122 Result = ConstantPointerRef::get(cast<GlobalValue>(V));
124 assert(0 && "Unknown type of derived type constant value!");
127 // Cache the mapping in our local map structure...
128 LocalMap.insert(std::make_pair(In, CPV));
132 cerr << "XXX LocalMap: \n";
136 cerr << "XXX GlobalMap: \n";
137 PrintMap(*GlobalMap);
140 cerr << "Couldn't remap value: " << (void*)In << " ";
143 assert(0 && "Couldn't remap value!");
148 // LinkGlobals - Loop through the global variables in the src module and merge
149 // them into the dest module...
151 static bool LinkGlobals(Module *Dest, const Module *Src,
152 map<const Value*, Value*> &ValueMap, string *Err = 0) {
153 // We will need a module level symbol table if the src module has a module
154 // level symbol table...
155 SymbolTable *ST = Src->getSymbolTable() ? Dest->getSymbolTableSure() : 0;
157 // Loop over all of the globals in the src module, mapping them over as we go
159 for (Module::const_giterator I = Src->gbegin(), E = Src->gend(); I != E; ++I){
160 const GlobalVariable *SGV = *I;
163 // If the global variable has a name, and that name is already in use in the
164 // Dest module, make sure that the name is a compatible global variable...
166 if (SGV->hasExternalLinkage() && SGV->hasName() &&
167 (V = ST->lookup(SGV->getType(), SGV->getName())) &&
168 cast<GlobalVariable>(V)->hasExternalLinkage()) {
169 // The same named thing is a global variable, because the only two things
170 // that may be in a module level symbol table are Global Vars and
171 // Functions, and they both have distinct, nonoverlapping, possible types.
173 GlobalVariable *DGV = cast<GlobalVariable>(V);
175 // Check to see if the two GV's have the same Const'ness...
176 if (SGV->isConstant() != DGV->isConstant())
177 return Error(Err, "Global Variable Collision on '" +
178 SGV->getType()->getDescription() + "':%" + SGV->getName() +
179 " - Global variables differ in const'ness");
181 // Okay, everything is cool, remember the mapping...
182 ValueMap.insert(std::make_pair(SGV, DGV));
184 // No linking to be performed, simply create an identical version of the
185 // symbol over in the dest module... the initializer will be filled in
186 // later by LinkGlobalInits...
188 GlobalVariable *DGV =
189 new GlobalVariable(SGV->getType()->getElementType(), SGV->isConstant(),
190 SGV->hasInternalLinkage(), 0, SGV->getName());
192 // Add the new global to the dest module
193 Dest->getGlobalList().push_back(DGV);
195 // Make sure to remember this mapping...
196 ValueMap.insert(std::make_pair(SGV, DGV));
203 // LinkGlobalInits - Update the initializers in the Dest module now that all
204 // globals that may be referenced are in Dest.
206 static bool LinkGlobalInits(Module *Dest, const Module *Src,
207 map<const Value*, Value*> &ValueMap,
210 // Loop over all of the globals in the src module, mapping them over as we go
212 for (Module::const_giterator I = Src->gbegin(), E = Src->gend(); I != E; ++I){
213 const GlobalVariable *SGV = *I;
215 if (SGV->hasInitializer()) { // Only process initialized GV's
216 // Figure out what the initializer looks like in the dest module...
218 cast<Constant>(RemapOperand(SGV->getInitializer(), ValueMap));
220 GlobalVariable *DGV = cast<GlobalVariable>(ValueMap[SGV]);
221 if (DGV->hasInitializer() && SGV->hasExternalLinkage() &&
222 DGV->hasExternalLinkage()) {
223 if (DGV->getInitializer() != DInit)
224 return Error(Err, "Global Variable Collision on '" +
225 SGV->getType()->getDescription() + "':%" +SGV->getName()+
226 " - Global variables have different initializers");
228 // Copy the initializer over now...
229 DGV->setInitializer(DInit);
236 // LinkFunctionProtos - Link the functions together between the two modules,
237 // without doing method bodies... this just adds external method prototypes to
238 // the Dest function...
240 static bool LinkFunctionProtos(Module *Dest, const Module *Src,
241 map<const Value*, Value*> &ValueMap,
243 // We will need a module level symbol table if the src module has a module
244 // level symbol table...
245 SymbolTable *ST = Src->getSymbolTable() ? Dest->getSymbolTableSure() : 0;
247 // Loop over all of the methods in the src module, mapping them over as we go
249 for (Module::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) {
250 const Function *SM = *I; // SrcFunction
253 // If the method has a name, and that name is already in use in the
254 // Dest module, make sure that the name is a compatible method...
256 if (SM->hasExternalLinkage() && SM->hasName() &&
257 (V = ST->lookup(SM->getType(), SM->getName())) &&
258 cast<Function>(V)->hasExternalLinkage()) {
259 // The same named thing is a Function, because the only two things
260 // that may be in a module level symbol table are Global Vars and
261 // Functions, and they both have distinct, nonoverlapping, possible types.
263 Function *DM = cast<Function>(V); // DestFunction
265 // Check to make sure the method is not defined in both modules...
266 if (!SM->isExternal() && !DM->isExternal())
267 return Error(Err, "Function '" +
268 SM->getFunctionType()->getDescription() + "':\"" +
269 SM->getName() + "\" - Function is already defined!");
271 // Otherwise, just remember this mapping...
272 ValueMap.insert(std::make_pair(SM, DM));
274 // Function does not already exist, simply insert an external method
275 // signature identical to SM into the dest module...
276 Function *DM = new Function(SM->getFunctionType(),
277 SM->hasInternalLinkage(),
280 // Add the method signature to the dest module...
281 Dest->getFunctionList().push_back(DM);
283 // ... and remember this mapping...
284 ValueMap.insert(std::make_pair(SM, DM));
290 // LinkFunctionBody - Copy the source method over into the dest method
291 // and fix up references to values. At this point we know that Dest
292 // is an external method, and that Src is not.
294 static bool LinkFunctionBody(Function *Dest, const Function *Src,
295 const map<const Value*, Value*> &GlobalMap,
297 assert(Src && Dest && Dest->isExternal() && !Src->isExternal());
298 map<const Value*, Value*> LocalMap; // Map for method local values
300 // Go through and convert method arguments over...
301 for (Function::ArgumentListType::const_iterator
302 I = Src->getArgumentList().begin(),
303 E = Src->getArgumentList().end(); I != E; ++I) {
304 const FunctionArgument *SMA = *I;
306 // Create the new method argument and add to the dest method...
307 FunctionArgument *DMA = new FunctionArgument(SMA->getType(),SMA->getName());
308 Dest->getArgumentList().push_back(DMA);
310 // Add a mapping to our local map
311 LocalMap.insert(std::make_pair(SMA, DMA));
314 // Loop over all of the basic blocks, copying the instructions over...
316 for (Function::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) {
317 const BasicBlock *SBB = *I;
319 // Create new basic block and add to mapping and the Dest method...
320 BasicBlock *DBB = new BasicBlock(SBB->getName(), Dest);
321 LocalMap.insert(std::make_pair(SBB, DBB));
323 // Loop over all of the instructions in the src basic block, copying them
324 // over. Note that this is broken in a strict sense because the cloned
325 // instructions will still be referencing values in the Src module, not
326 // the remapped values. In our case, however, we will not get caught and
327 // so we can delay patching the values up until later...
329 for (BasicBlock::const_iterator II = SBB->begin(), IE = SBB->end();
331 const Instruction *SI = *II;
332 Instruction *DI = SI->clone();
333 DI->setName(SI->getName());
334 DBB->getInstList().push_back(DI);
335 LocalMap.insert(std::make_pair(SI, DI));
339 // At this point, all of the instructions and values of the method are now
340 // copied over. The only problem is that they are still referencing values
341 // in the Source method as operands. Loop through all of the operands of the
342 // methods and patch them up to point to the local versions...
344 for (Function::iterator BI = Dest->begin(), BE = Dest->end();
346 BasicBlock *BB = *BI;
347 for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) {
348 Instruction *Inst = *I;
350 for (Instruction::op_iterator OI = Inst->op_begin(), OE = Inst->op_end();
352 *OI = RemapOperand(*OI, LocalMap, &GlobalMap);
360 // LinkFunctionBodies - Link in the method bodies that are defined in the source
361 // module into the DestModule. This consists basically of copying the method
362 // over and fixing up references to values.
364 static bool LinkFunctionBodies(Module *Dest, const Module *Src,
365 map<const Value*, Value*> &ValueMap,
368 // Loop over all of the methods in the src module, mapping them over as we go
370 for (Module::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) {
371 const Function *SM = *I; // Source Function
372 if (!SM->isExternal()) { // No body if method is external
373 Function *DM = cast<Function>(ValueMap[SM]); // Destination method
375 // DM not external SM external?
376 if (!DM->isExternal()) {
378 *Err = "Function '" + (SM->hasName() ? SM->getName() : string("")) +
379 "' body multiply defined!";
383 if (LinkFunctionBody(DM, SM, ValueMap, Err)) return true;
391 // LinkModules - This function links two modules together, with the resulting
392 // left module modified to be the composite of the two input modules. If an
393 // error occurs, true is returned and ErrorMsg (if not null) is set to indicate
394 // the problem. Upon failure, the Dest module could be in a modified state, and
395 // shouldn't be relied on to be consistent.
397 bool LinkModules(Module *Dest, const Module *Src, string *ErrorMsg = 0) {
399 // LinkTypes - Go through the symbol table of the Src module and see if any
400 // types are named in the src module that are not named in the Dst module.
401 // Make sure there are no type name conflicts.
403 if (LinkTypes(Dest, Src, ErrorMsg)) return true;
405 // ValueMap - Mapping of values from what they used to be in Src, to what they
408 map<const Value*, Value*> ValueMap;
410 // Insert all of the globals in src into the Dest module... without
412 if (LinkGlobals(Dest, Src, ValueMap, ErrorMsg)) return true;
414 // Update the initializers in the Dest module now that all globals that may
415 // be referenced are in Dest.
417 if (LinkGlobalInits(Dest, Src, ValueMap, ErrorMsg)) return true;
419 // Link the methods together between the two modules, without doing method
420 // bodies... this just adds external method prototypes to the Dest method...
421 // We do this so that when we begin processing method bodies, all of the
422 // global values that may be referenced are available in our ValueMap.
424 if (LinkFunctionProtos(Dest, Src, ValueMap, ErrorMsg)) return true;
426 // Link in the method bodies that are defined in the source module into the
427 // DestModule. This consists basically of copying the method over and fixing
428 // up references to values.
430 if (LinkFunctionBodies(Dest, Src, ValueMap, ErrorMsg)) return true;