LinkModules.cpp revision e306d94782b1c608857738279852dcc050c66004
152f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner//===- Linker.cpp - Module Linker Implementation --------------------------===// 252f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// 352f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// This file implements the LLVM module linker. 452f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// 552f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// Specifically, this: 68d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner// * Merges global variables between the two modules 78d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner// * Uninit + Uninit = Init, Init + Uninit = Init, Init + Init = Error if != 8c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// * Merges functions between two modules 952f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// 1052f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner//===----------------------------------------------------------------------===// 1152f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 12c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner#include "llvm/Transforms/Utils/Linker.h" 135c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner#include "llvm/Module.h" 1479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner#include "llvm/Function.h" 15221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner#include "llvm/BasicBlock.h" 165c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner#include "llvm/GlobalVariable.h" 175c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner#include "llvm/SymbolTable.h" 185c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner#include "llvm/DerivedTypes.h" 195c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner#include "llvm/iOther.h" 2031bcdb822fe9133b1973de51519d34e5813a6184Chris Lattner#include "llvm/Constants.h" 2173e214244f2403b5ba0ef81b8839600f3c8ffebcChris Lattner#include "llvm/Argument.h" 22697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner#include <iostream> 23697954c15da58bd8b186dbafdedd8b06db770201Chris Lattnerusing std::cerr; 24697954c15da58bd8b186dbafdedd8b06db770201Chris Lattnerusing std::string; 25697954c15da58bd8b186dbafdedd8b06db770201Chris Lattnerusing std::map; 265c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 275c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// Error - Simple wrapper function to conditionally assign to E and return true. 285c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// This just makes error return conditions a little bit simpler... 295c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 305c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattnerstatic inline bool Error(string *E, string Message) { 315c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (E) *E = Message; 325c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return true; 335c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 345c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 352c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// LinkTypes - Go through the symbol table of the Src module and see if any 362c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// types are named in the src module that are not named in the Dst module. 372c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// Make sure there are no type name conflicts. 382c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// 392c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattnerstatic bool LinkTypes(Module *Dest, const Module *Src, string *Err = 0) { 402c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // No symbol table? Can't have named types. 412c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (!Src->hasSymbolTable()) return false; 422c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 432c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner SymbolTable *DestST = Dest->getSymbolTableSure(); 442c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const SymbolTable *SrcST = Src->getSymbolTable(); 452c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 462c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // Look for a type plane for Type's... 472c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner SymbolTable::const_iterator PI = SrcST->find(Type::TypeTy); 482c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (PI == SrcST->end()) return false; // No named types, do nothing. 492c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 502c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const SymbolTable::VarMap &VM = PI->second; 512c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner for (SymbolTable::type_const_iterator I = VM.begin(), E = VM.end(); 522c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner I != E; ++I) { 532c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const string &Name = I->first; 542c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const Type *RHS = cast<Type>(I->second); 552c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 562c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // Check to see if this type name is already in the dest module... 572c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const Type *Entry = cast_or_null<Type>(DestST->lookup(Type::TypeTy, Name)); 582c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (Entry) { // Yup, the value already exists... 592c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (Entry != RHS) // If it's the same, noop. Otherwise, error. 602c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner return Error(Err, "Type named '" + Name + 612c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner "' of different shape in modules.\n Src='" + 629b638019ca8870f418e3b42b39dd34dc7deebb2dChris Lattner Entry->getDescription() + "'.\n Dst='" + 632c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner RHS->getDescription() + "'"); 642c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner } else { // Type not in dest module. Add it now. 652c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // TODO: FIXME WHEN TYPES AREN'T CONST 662c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner DestST->insert(Name, const_cast<Type*>(RHS)); 672c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner } 682c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner } 692c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner return false; 702c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner} 712c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 722d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattnerstatic void PrintMap(const map<const Value*, Value*> &M) { 732d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner for (map<const Value*, Value*>::const_iterator I = M.begin(), E = M.end(); 742d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner I != E; ++I) { 7587182ae6baf28ca6da6ee4bc00cf1857f293acfeChris Lattner cerr << " Fr: " << (void*)I->first << " "; 7687182ae6baf28ca6da6ee4bc00cf1857f293acfeChris Lattner I->first->dump(); 7787182ae6baf28ca6da6ee4bc00cf1857f293acfeChris Lattner cerr << " To: " << (void*)I->second << " "; 7887182ae6baf28ca6da6ee4bc00cf1857f293acfeChris Lattner I->second->dump(); 7987182ae6baf28ca6da6ee4bc00cf1857f293acfeChris Lattner cerr << "\n"; 802d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner } 812d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner} 822d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner 832d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner 845c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// RemapOperand - Use LocalMap and GlobalMap to convert references from one 855c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// module to another. This is somewhat sophisticated in that it can 865c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// automatically handle constant references correctly as well... 875c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 888d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattnerstatic Value *RemapOperand(const Value *In, map<const Value*, Value*> &LocalMap, 895c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner const map<const Value*, Value*> *GlobalMap = 0) { 905c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner map<const Value*,Value*>::const_iterator I = LocalMap.find(In); 915c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (I != LocalMap.end()) return I->second; 925c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 935c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (GlobalMap) { 945c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner I = GlobalMap->find(In); 955c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (I != GlobalMap->end()) return I->second; 965c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 975c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 988d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Check to see if it's a constant that we are interesting in transforming... 9918961504fc2b299578dba817900a0696cf3ccc4dChris Lattner if (const Constant *CPV = dyn_cast<Constant>(In)) { 1006cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner if (!isa<DerivedType>(CPV->getType()) && !isa<ConstantExpr>(CPV)) 10118961504fc2b299578dba817900a0696cf3ccc4dChris Lattner return const_cast<Constant*>(CPV); // Simple constants stay identical... 1028d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 103e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Constant *Result = 0; 1048d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 10518961504fc2b299578dba817900a0696cf3ccc4dChris Lattner if (const ConstantArray *CPA = dyn_cast<ConstantArray>(CPV)) { 106697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner const std::vector<Use> &Ops = CPA->getValues(); 107697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner std::vector<Constant*> Operands(Ops.size()); 108e306d94782b1c608857738279852dcc050c66004Chris Lattner for (unsigned i = 0, e = Ops.size(); i != e; ++i) 1098d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner Operands[i] = 110e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner cast<Constant>(RemapOperand(Ops[i], LocalMap, GlobalMap)); 111e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Result = ConstantArray::get(cast<ArrayType>(CPA->getType()), Operands); 11218961504fc2b299578dba817900a0696cf3ccc4dChris Lattner } else if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(CPV)) { 113697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner const std::vector<Use> &Ops = CPS->getValues(); 114697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner std::vector<Constant*> Operands(Ops.size()); 1158d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner for (unsigned i = 0; i < Ops.size(); ++i) 1168d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner Operands[i] = 117e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner cast<Constant>(RemapOperand(Ops[i], LocalMap, GlobalMap)); 118e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Result = ConstantStruct::get(cast<StructType>(CPS->getType()), Operands); 119e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner } else if (isa<ConstantPointerNull>(CPV)) { 12018961504fc2b299578dba817900a0696cf3ccc4dChris Lattner Result = const_cast<Constant*>(CPV); 12118961504fc2b299578dba817900a0696cf3ccc4dChris Lattner } else if (const ConstantPointerRef *CPR = 12218961504fc2b299578dba817900a0696cf3ccc4dChris Lattner dyn_cast<ConstantPointerRef>(CPV)) { 1238d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner Value *V = RemapOperand(CPR->getValue(), LocalMap, GlobalMap); 124e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Result = ConstantPointerRef::get(cast<GlobalValue>(V)); 1256cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) { 1266cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner if (CE->getNumOperands() == 1) { 1276cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // Cast instruction, unary operator 1286cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner Value *V = RemapOperand(CE->getOperand(0), LocalMap, GlobalMap); 1296cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner Result = ConstantExpr::get(CE->getOpcode(), cast<Constant>(V), 1306cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner CE->getType()); 1316cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner } else if (CE->getNumOperands() == 2) { 1326cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // Binary operator... 1336cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner Value *V1 = RemapOperand(CE->getOperand(0), LocalMap, GlobalMap); 1346cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner Value *V2 = RemapOperand(CE->getOperand(1), LocalMap, GlobalMap); 1356cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner 1366cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner Result = ConstantExpr::get(CE->getOpcode(), cast<Constant>(V1), 1376cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner cast<Constant>(V2), CE->getType()); 1386cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner } else { 1396cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // GetElementPtr Expression 1406cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner assert(CE->getOpcode() == Instruction::GetElementPtr); 1416cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner Value *Ptr = RemapOperand(CE->getOperand(0), LocalMap, GlobalMap); 1426cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner std::vector<Constant*> Indices; 1436cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner Indices.reserve(CE->getNumOperands()-1); 1446cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner for (unsigned i = 1, e = CE->getNumOperands(); i != e; ++i) 1456cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner Indices.push_back(cast<Constant>(RemapOperand(CE->getOperand(i), 1466cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner LocalMap, GlobalMap))); 1476cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner 1486cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner Result = ConstantExpr::get(CE->getOpcode(), cast<Constant>(Ptr), 1496cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner Indices, CE->getType()); 1506cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner } 1516cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner 1528d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } else { 1538d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner assert(0 && "Unknown type of derived type constant value!"); 1548d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 1558d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 1568d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Cache the mapping in our local map structure... 157e306d94782b1c608857738279852dcc050c66004Chris Lattner LocalMap.insert(std::make_pair(In, Result)); 1588d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return Result; 1598d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 1602d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner 1612d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner cerr << "XXX LocalMap: \n"; 1622d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner PrintMap(LocalMap); 1632d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner 1642d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner if (GlobalMap) { 1652d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner cerr << "XXX GlobalMap: \n"; 1662d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner PrintMap(*GlobalMap); 1672d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner } 1682d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner 1696cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner cerr << "Couldn't remap value: " << (void*)In << " " << *In << "\n"; 1708d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner assert(0 && "Couldn't remap value!"); 1718d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return 0; 1725c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 1735c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1745c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1755c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// LinkGlobals - Loop through the global variables in the src module and merge 1765c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// them into the dest module... 1775c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 1785c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattnerstatic bool LinkGlobals(Module *Dest, const Module *Src, 1795c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner map<const Value*, Value*> &ValueMap, string *Err = 0) { 1805c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // We will need a module level symbol table if the src module has a module 1815c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // level symbol table... 1825c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner SymbolTable *ST = Src->getSymbolTable() ? Dest->getSymbolTableSure() : 0; 1835c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1845c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the globals in the src module, mapping them over as we go 1855c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 1865c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner for (Module::const_giterator I = Src->gbegin(), E = Src->gend(); I != E; ++I){ 18718961504fc2b299578dba817900a0696cf3ccc4dChris Lattner const GlobalVariable *SGV = I; 1885c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner Value *V; 1895c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1905c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // If the global variable has a name, and that name is already in use in the 1915c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Dest module, make sure that the name is a compatible global variable... 1925c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 193e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner if (SGV->hasExternalLinkage() && SGV->hasName() && 194e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner (V = ST->lookup(SGV->getType(), SGV->getName())) && 195e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner cast<GlobalVariable>(V)->hasExternalLinkage()) { 1965c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // The same named thing is a global variable, because the only two things 19779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // that may be in a module level symbol table are Global Vars and 19879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // Functions, and they both have distinct, nonoverlapping, possible types. 1995c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 2005c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner GlobalVariable *DGV = cast<GlobalVariable>(V); 2015c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2025c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Check to see if the two GV's have the same Const'ness... 2038d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner if (SGV->isConstant() != DGV->isConstant()) 2045c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return Error(Err, "Global Variable Collision on '" + 2058d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner SGV->getType()->getDescription() + "':%" + SGV->getName() + 2065c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner " - Global variables differ in const'ness"); 2075c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2088d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Okay, everything is cool, remember the mapping... 209697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner ValueMap.insert(std::make_pair(SGV, DGV)); 2105c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } else { 2115c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // No linking to be performed, simply create an identical version of the 2128d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // symbol over in the dest module... the initializer will be filled in 2138d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // later by LinkGlobalInits... 2148d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // 2158d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner GlobalVariable *DGV = 2167a1767520611d9ff6face702068de858e1cadf2cChris Lattner new GlobalVariable(SGV->getType()->getElementType(), SGV->isConstant(), 217e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner SGV->hasInternalLinkage(), 0, SGV->getName()); 2185c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2195c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Add the new global to the dest module 2208d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner Dest->getGlobalList().push_back(DGV); 2215c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2225c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Make sure to remember this mapping... 223697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner ValueMap.insert(std::make_pair(SGV, DGV)); 2245c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 2255c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 2265c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 2275c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 2285c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2295c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2308d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner// LinkGlobalInits - Update the initializers in the Dest module now that all 2318d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner// globals that may be referenced are in Dest. 2328d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner// 2338d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattnerstatic bool LinkGlobalInits(Module *Dest, const Module *Src, 2348d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner map<const Value*, Value*> &ValueMap, 2358d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner string *Err = 0) { 2368d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 2378d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Loop over all of the globals in the src module, mapping them over as we go 2388d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // 2398d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner for (Module::const_giterator I = Src->gbegin(), E = Src->gend(); I != E; ++I){ 24018961504fc2b299578dba817900a0696cf3ccc4dChris Lattner const GlobalVariable *SGV = I; 2418d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 2428d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner if (SGV->hasInitializer()) { // Only process initialized GV's 2438d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Figure out what the initializer looks like in the dest module... 244e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Constant *DInit = 245e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner cast<Constant>(RemapOperand(SGV->getInitializer(), ValueMap)); 2468d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 2478d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner GlobalVariable *DGV = cast<GlobalVariable>(ValueMap[SGV]); 248e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner if (DGV->hasInitializer() && SGV->hasExternalLinkage() && 249e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner DGV->hasExternalLinkage()) { 2508d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner if (DGV->getInitializer() != DInit) 2518d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return Error(Err, "Global Variable Collision on '" + 2528d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner SGV->getType()->getDescription() + "':%" +SGV->getName()+ 2538d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner " - Global variables have different initializers"); 2548d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } else { 2558d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Copy the initializer over now... 2568d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner DGV->setInitializer(DInit); 2578d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 2588d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 2598d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 2608d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return false; 2618d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner} 2625c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 26379df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// LinkFunctionProtos - Link the functions together between the two modules, 264c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// without doing function bodies... this just adds external function prototypes 265c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// to the Dest function... 2665c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 26779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattnerstatic bool LinkFunctionProtos(Module *Dest, const Module *Src, 26879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner map<const Value*, Value*> &ValueMap, 26979df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner string *Err = 0) { 2705c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // We will need a module level symbol table if the src module has a module 2715c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // level symbol table... 2725c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner SymbolTable *ST = Src->getSymbolTable() ? Dest->getSymbolTableSure() : 0; 2735c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 274c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Loop over all of the functions in the src module, mapping them over as we 275c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // go 2765c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 2775c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner for (Module::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) { 27818961504fc2b299578dba817900a0696cf3ccc4dChris Lattner const Function *SF = I; // SrcFunction 2795c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner Value *V; 2805c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 281c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // If the function has a name, and that name is already in use in the Dest 282c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // module, make sure that the name is a compatible function... 2835c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 28418961504fc2b299578dba817900a0696cf3ccc4dChris Lattner if (SF->hasExternalLinkage() && SF->hasName() && 28518961504fc2b299578dba817900a0696cf3ccc4dChris Lattner (V = ST->lookup(SF->getType(), SF->getName())) && 28679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner cast<Function>(V)->hasExternalLinkage()) { 28779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // The same named thing is a Function, because the only two things 28879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // that may be in a module level symbol table are Global Vars and 28979df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // Functions, and they both have distinct, nonoverlapping, possible types. 2905c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 29118961504fc2b299578dba817900a0696cf3ccc4dChris Lattner Function *DF = cast<Function>(V); // DestFunction 2925c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 293c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Check to make sure the function is not defined in both modules... 29418961504fc2b299578dba817900a0696cf3ccc4dChris Lattner if (!SF->isExternal() && !DF->isExternal()) 29579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner return Error(Err, "Function '" + 29618961504fc2b299578dba817900a0696cf3ccc4dChris Lattner SF->getFunctionType()->getDescription() + "':\"" + 29718961504fc2b299578dba817900a0696cf3ccc4dChris Lattner SF->getName() + "\" - Function is already defined!"); 2985c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2995c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Otherwise, just remember this mapping... 30018961504fc2b299578dba817900a0696cf3ccc4dChris Lattner ValueMap.insert(std::make_pair(SF, DF)); 3015c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } else { 302c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Function does not already exist, simply insert an external function 30318961504fc2b299578dba817900a0696cf3ccc4dChris Lattner // signature identical to SF into the dest module... 30418961504fc2b299578dba817900a0696cf3ccc4dChris Lattner Function *DF = new Function(SF->getFunctionType(), 30518961504fc2b299578dba817900a0696cf3ccc4dChris Lattner SF->hasInternalLinkage(), 30618961504fc2b299578dba817900a0696cf3ccc4dChris Lattner SF->getName()); 3075c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 308c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Add the function signature to the dest module... 30918961504fc2b299578dba817900a0696cf3ccc4dChris Lattner Dest->getFunctionList().push_back(DF); 3105c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3115c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // ... and remember this mapping... 31218961504fc2b299578dba817900a0696cf3ccc4dChris Lattner ValueMap.insert(std::make_pair(SF, DF)); 3135c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3145c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3155c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 3165c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 3175c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 318c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// LinkFunctionBody - Copy the source function over into the dest function and 319c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// fix up references to values. At this point we know that Dest is an external 320c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// function, and that Src is not. 3215c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 32279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattnerstatic bool LinkFunctionBody(Function *Dest, const Function *Src, 32379df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const map<const Value*, Value*> &GlobalMap, 32479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner string *Err = 0) { 3255c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner assert(Src && Dest && Dest->isExternal() && !Src->isExternal()); 326c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner map<const Value*, Value*> LocalMap; // Map for function local values 3275c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 328c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Go through and convert function arguments over... 32918961504fc2b299578dba817900a0696cf3ccc4dChris Lattner for (Function::const_aiterator I = Src->abegin(), E = Src->aend(); 33018961504fc2b299578dba817900a0696cf3ccc4dChris Lattner I != E; ++I) { 331c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Create the new function argument and add to the dest function... 33218961504fc2b299578dba817900a0696cf3ccc4dChris Lattner Argument *DFA = new Argument(I->getType(), I->getName()); 33318961504fc2b299578dba817900a0696cf3ccc4dChris Lattner Dest->getArgumentList().push_back(DFA); 3345c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3355c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Add a mapping to our local map 33618961504fc2b299578dba817900a0696cf3ccc4dChris Lattner LocalMap.insert(std::make_pair(I, DFA)); 3375c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3385c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3395c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the basic blocks, copying the instructions over... 3405c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 34179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner for (Function::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) { 342c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Create new basic block and add to mapping and the Dest function... 34318961504fc2b299578dba817900a0696cf3ccc4dChris Lattner BasicBlock *DBB = new BasicBlock(I->getName(), Dest); 34418961504fc2b299578dba817900a0696cf3ccc4dChris Lattner LocalMap.insert(std::make_pair(I, DBB)); 3455c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3465c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the instructions in the src basic block, copying them 3475c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // over. Note that this is broken in a strict sense because the cloned 3485c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // instructions will still be referencing values in the Src module, not 3495c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // the remapped values. In our case, however, we will not get caught and 3505c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // so we can delay patching the values up until later... 3515c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 35218961504fc2b299578dba817900a0696cf3ccc4dChris Lattner for (BasicBlock::const_iterator II = I->begin(), IE = I->end(); 3535c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner II != IE; ++II) { 35418961504fc2b299578dba817900a0696cf3ccc4dChris Lattner Instruction *DI = II->clone(); 35518961504fc2b299578dba817900a0696cf3ccc4dChris Lattner DI->setName(II->getName()); 3565c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner DBB->getInstList().push_back(DI); 35718961504fc2b299578dba817900a0696cf3ccc4dChris Lattner LocalMap.insert(std::make_pair(II, DI)); 3585c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3595c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3605c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 361c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // At this point, all of the instructions and values of the function are now 362c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // copied over. The only problem is that they are still referencing values in 363c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // the Source function as operands. Loop through all of the operands of the 364c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // functions and patch them up to point to the local versions... 3655c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 36618961504fc2b299578dba817900a0696cf3ccc4dChris Lattner for (Function::iterator BB = Dest->begin(), BE = Dest->end(); BB != BE; ++BB) 36718961504fc2b299578dba817900a0696cf3ccc4dChris Lattner for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 36818961504fc2b299578dba817900a0696cf3ccc4dChris Lattner for (Instruction::op_iterator OI = I->op_begin(), OE = I->op_end(); 369221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner OI != OE; ++OI) 370221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner *OI = RemapOperand(*OI, LocalMap, &GlobalMap); 3715c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3725c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 3735c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 3745c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3755c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 376c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// LinkFunctionBodies - Link in the function bodies that are defined in the 377c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// source module into the DestModule. This consists basically of copying the 378c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// function over and fixing up references to values. 3795c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 38079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattnerstatic bool LinkFunctionBodies(Module *Dest, const Module *Src, 38179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner map<const Value*, Value*> &ValueMap, 38279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner string *Err = 0) { 3835c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 384c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Loop over all of the functions in the src module, mapping them over as we 385c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // go 3865c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 38718961504fc2b299578dba817900a0696cf3ccc4dChris Lattner for (Module::const_iterator SF = Src->begin(), E = Src->end(); SF != E; ++SF){ 38818961504fc2b299578dba817900a0696cf3ccc4dChris Lattner if (!SF->isExternal()) { // No body if function is external 38918961504fc2b299578dba817900a0696cf3ccc4dChris Lattner Function *DF = cast<Function>(ValueMap[SF]); // Destination function 390c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner 39118961504fc2b299578dba817900a0696cf3ccc4dChris Lattner // DF not external SF external? 39218961504fc2b299578dba817900a0696cf3ccc4dChris Lattner if (!DF->isExternal()) { 393c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner if (Err) 39418961504fc2b299578dba817900a0696cf3ccc4dChris Lattner *Err = "Function '" + (SF->hasName() ? SF->getName() : string("")) + 395c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner "' body multiply defined!"; 396c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner return true; 397c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner } 3985c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 39918961504fc2b299578dba817900a0696cf3ccc4dChris Lattner if (LinkFunctionBody(DF, SF, ValueMap, Err)) return true; 400c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner } 4015c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 4025c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 4035c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 4045c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 40552f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 40652f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 40752f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// LinkModules - This function links two modules together, with the resulting 40852f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// left module modified to be the composite of the two input modules. If an 40952f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// error occurs, true is returned and ErrorMsg (if not null) is set to indicate 4105c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// the problem. Upon failure, the Dest module could be in a modified state, and 4115c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// shouldn't be relied on to be consistent. 41252f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// 41352f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattnerbool LinkModules(Module *Dest, const Module *Src, string *ErrorMsg = 0) { 4142c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 4152c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // LinkTypes - Go through the symbol table of the Src module and see if any 4162c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // types are named in the src module that are not named in the Dst module. 4172c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // Make sure there are no type name conflicts. 4182c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // 4192c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (LinkTypes(Dest, Src, ErrorMsg)) return true; 4202c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 4215c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // ValueMap - Mapping of values from what they used to be in Src, to what they 4225c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // are now in Dest. 4235c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 4245c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner map<const Value*, Value*> ValueMap; 4255c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 4266cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // FIXME: 4276cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // FIXME: This should be a two step process: 4286cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // FIXME: 1. LinkGlobals & LinkFunctionProtos 4296cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // FIXME: 2. LinkGlobalContents 4306cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // FIXME: 4316cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // FIXME: Global variables and functions are the same! 4326cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // FIXME: 4336cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner 4346cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner 4358d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Insert all of the globals in src into the Dest module... without 4368d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // initializers 4375c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (LinkGlobals(Dest, Src, ValueMap, ErrorMsg)) return true; 4385c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 439c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Link the functions together between the two modules, without doing function 440c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // bodies... this just adds external function prototypes to the Dest 441c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // function... We do this so that when we begin processing function bodies, 442c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // all of the global values that may be referenced are available in our 443c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // ValueMap. 4445c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 44579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner if (LinkFunctionProtos(Dest, Src, ValueMap, ErrorMsg)) return true; 4465c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 4476cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // Update the initializers in the Dest module now that all globals that may 4486cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // be referenced are in Dest. 4496cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // 4506cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner if (LinkGlobalInits(Dest, Src, ValueMap, ErrorMsg)) return true; 4516cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner 452c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Link in the function bodies that are defined in the source module into the 453c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // DestModule. This consists basically of copying the function over and 454c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // fixing up references to values. 4555c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 45679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner if (LinkFunctionBodies(Dest, Src, ValueMap, ErrorMsg)) return true; 45752f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 45852f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner return false; 45952f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner} 4609466f5113ba859677a28887c3c7143065e702019Vikram S. Adve 461