LinkModules.cpp revision 79df7c0aaa18129e55968c8783ef8346807bd4af
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 != 88d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner// * Merges methods between two modules 952f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// 1052f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner//===----------------------------------------------------------------------===// 1152f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 1252f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner#include "llvm/Transforms/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" 20e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner#include "llvm/ConstantVals.h" 21697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner#include <iostream> 22697954c15da58bd8b186dbafdedd8b06db770201Chris Lattnerusing std::cerr; 23697954c15da58bd8b186dbafdedd8b06db770201Chris Lattnerusing std::string; 24697954c15da58bd8b186dbafdedd8b06db770201Chris Lattnerusing std::map; 255c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 265c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// Error - Simple wrapper function to conditionally assign to E and return true. 275c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// This just makes error return conditions a little bit simpler... 285c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 295c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattnerstatic inline bool Error(string *E, string Message) { 305c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (E) *E = Message; 315c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return true; 325c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 335c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 345c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner#include "llvm/Assembly/Writer.h" // TODO: REMOVE 355c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 362c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 372c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// LinkTypes - Go through the symbol table of the Src module and see if any 382c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// types are named in the src module that are not named in the Dst module. 392c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// Make sure there are no type name conflicts. 402c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// 412c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattnerstatic bool LinkTypes(Module *Dest, const Module *Src, string *Err = 0) { 422c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // No symbol table? Can't have named types. 432c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (!Src->hasSymbolTable()) return false; 442c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 452c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner SymbolTable *DestST = Dest->getSymbolTableSure(); 462c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const SymbolTable *SrcST = Src->getSymbolTable(); 472c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 482c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // Look for a type plane for Type's... 492c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner SymbolTable::const_iterator PI = SrcST->find(Type::TypeTy); 502c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (PI == SrcST->end()) return false; // No named types, do nothing. 512c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 522c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const SymbolTable::VarMap &VM = PI->second; 532c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner for (SymbolTable::type_const_iterator I = VM.begin(), E = VM.end(); 542c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner I != E; ++I) { 552c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const string &Name = I->first; 562c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const Type *RHS = cast<Type>(I->second); 572c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 582c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // Check to see if this type name is already in the dest module... 592c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const Type *Entry = cast_or_null<Type>(DestST->lookup(Type::TypeTy, Name)); 602c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (Entry) { // Yup, the value already exists... 612c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (Entry != RHS) // If it's the same, noop. Otherwise, error. 622c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner return Error(Err, "Type named '" + Name + 632c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner "' of different shape in modules.\n Src='" + 649b638019ca8870f418e3b42b39dd34dc7deebb2dChris Lattner Entry->getDescription() + "'.\n Dst='" + 652c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner RHS->getDescription() + "'"); 662c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner } else { // Type not in dest module. Add it now. 672c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // TODO: FIXME WHEN TYPES AREN'T CONST 682c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner DestST->insert(Name, const_cast<Type*>(RHS)); 692c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner } 702c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner } 712c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner return false; 722c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner} 732c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 742d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattnerstatic void PrintMap(const map<const Value*, Value*> &M) { 752d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner for (map<const Value*, Value*>::const_iterator I = M.begin(), E = M.end(); 762d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner I != E; ++I) { 772d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner cerr << " Fr: " << (void*)I->first << " " << I->first 78697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner << " To: " << (void*)I->second << " " << I->second << "\n"; 792d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner } 802d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner} 812d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner 822d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner 835c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// RemapOperand - Use LocalMap and GlobalMap to convert references from one 845c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// module to another. This is somewhat sophisticated in that it can 855c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// automatically handle constant references correctly as well... 865c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 878d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattnerstatic Value *RemapOperand(const Value *In, map<const Value*, Value*> &LocalMap, 885c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner const map<const Value*, Value*> *GlobalMap = 0) { 895c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner map<const Value*,Value*>::const_iterator I = LocalMap.find(In); 905c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (I != LocalMap.end()) return I->second; 915c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 925c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (GlobalMap) { 935c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner I = GlobalMap->find(In); 945c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (I != GlobalMap->end()) return I->second; 955c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 965c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 978d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Check to see if it's a constant that we are interesting in transforming... 98e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner if (Constant *CPV = dyn_cast<Constant>(In)) { 998d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner if (!isa<DerivedType>(CPV->getType())) 1008d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return CPV; // Simple constants stay identical... 1018d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 102e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Constant *Result = 0; 1038d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 104e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner if (ConstantArray *CPA = dyn_cast<ConstantArray>(CPV)) { 105697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner const std::vector<Use> &Ops = CPA->getValues(); 106697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner std::vector<Constant*> Operands(Ops.size()); 1078d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner for (unsigned i = 0; i < Ops.size(); ++i) 1088d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner Operands[i] = 109e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner cast<Constant>(RemapOperand(Ops[i], LocalMap, GlobalMap)); 110e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Result = ConstantArray::get(cast<ArrayType>(CPA->getType()), Operands); 111e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner } else if (ConstantStruct *CPS = dyn_cast<ConstantStruct>(CPV)) { 112697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner const std::vector<Use> &Ops = CPS->getValues(); 113697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner std::vector<Constant*> Operands(Ops.size()); 1148d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner for (unsigned i = 0; i < Ops.size(); ++i) 1158d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner Operands[i] = 116e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner cast<Constant>(RemapOperand(Ops[i], LocalMap, GlobalMap)); 117e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Result = ConstantStruct::get(cast<StructType>(CPS->getType()), Operands); 118e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner } else if (isa<ConstantPointerNull>(CPV)) { 1198d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner Result = CPV; 120e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner } else if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(CPV)) { 1218d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner Value *V = RemapOperand(CPR->getValue(), LocalMap, GlobalMap); 122e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Result = ConstantPointerRef::get(cast<GlobalValue>(V)); 1238d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } else { 1248d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner assert(0 && "Unknown type of derived type constant value!"); 1258d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 1268d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 1278d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Cache the mapping in our local map structure... 128697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner LocalMap.insert(std::make_pair(In, CPV)); 1298d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return Result; 1308d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 1312d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner 1322d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner cerr << "XXX LocalMap: \n"; 1332d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner PrintMap(LocalMap); 1342d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner 1352d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner if (GlobalMap) { 1362d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner cerr << "XXX GlobalMap: \n"; 1372d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner PrintMap(*GlobalMap); 1382d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner } 1392d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner 140697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner cerr << "Couldn't remap value: " << (void*)In << " " << In << "\n"; 1418d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner assert(0 && "Couldn't remap value!"); 1428d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return 0; 1435c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 1445c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1455c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1465c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// LinkGlobals - Loop through the global variables in the src module and merge 1475c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// them into the dest module... 1485c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 1495c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattnerstatic bool LinkGlobals(Module *Dest, const Module *Src, 1505c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner map<const Value*, Value*> &ValueMap, string *Err = 0) { 1515c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // We will need a module level symbol table if the src module has a module 1525c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // level symbol table... 1535c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner SymbolTable *ST = Src->getSymbolTable() ? Dest->getSymbolTableSure() : 0; 1545c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1555c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the globals in the src module, mapping them over as we go 1565c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 1575c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner for (Module::const_giterator I = Src->gbegin(), E = Src->gend(); I != E; ++I){ 1588d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner const GlobalVariable *SGV = *I; 1595c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner Value *V; 1605c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1615c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // If the global variable has a name, and that name is already in use in the 1625c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Dest module, make sure that the name is a compatible global variable... 1635c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 164e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner if (SGV->hasExternalLinkage() && SGV->hasName() && 165e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner (V = ST->lookup(SGV->getType(), SGV->getName())) && 166e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner cast<GlobalVariable>(V)->hasExternalLinkage()) { 1675c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // The same named thing is a global variable, because the only two things 16879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // that may be in a module level symbol table are Global Vars and 16979df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // Functions, and they both have distinct, nonoverlapping, possible types. 1705c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 1715c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner GlobalVariable *DGV = cast<GlobalVariable>(V); 1725c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1735c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Check to see if the two GV's have the same Const'ness... 1748d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner if (SGV->isConstant() != DGV->isConstant()) 1755c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return Error(Err, "Global Variable Collision on '" + 1768d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner SGV->getType()->getDescription() + "':%" + SGV->getName() + 1775c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner " - Global variables differ in const'ness"); 1785c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1798d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Okay, everything is cool, remember the mapping... 180697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner ValueMap.insert(std::make_pair(SGV, DGV)); 1815c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } else { 1825c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // No linking to be performed, simply create an identical version of the 1838d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // symbol over in the dest module... the initializer will be filled in 1848d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // later by LinkGlobalInits... 1858d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // 1868d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner GlobalVariable *DGV = 1877a1767520611d9ff6face702068de858e1cadf2cChris Lattner new GlobalVariable(SGV->getType()->getElementType(), SGV->isConstant(), 188e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner SGV->hasInternalLinkage(), 0, SGV->getName()); 1895c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1905c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Add the new global to the dest module 1918d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner Dest->getGlobalList().push_back(DGV); 1925c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1935c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Make sure to remember this mapping... 194697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner ValueMap.insert(std::make_pair(SGV, DGV)); 1955c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 1965c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 1975c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 1985c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 1995c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2005c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2018d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner// LinkGlobalInits - Update the initializers in the Dest module now that all 2028d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner// globals that may be referenced are in Dest. 2038d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner// 2048d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattnerstatic bool LinkGlobalInits(Module *Dest, const Module *Src, 2058d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner map<const Value*, Value*> &ValueMap, 2068d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner string *Err = 0) { 2078d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 2088d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Loop over all of the globals in the src module, mapping them over as we go 2098d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // 2108d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner for (Module::const_giterator I = Src->gbegin(), E = Src->gend(); I != E; ++I){ 2118d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner const GlobalVariable *SGV = *I; 2128d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 2138d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner if (SGV->hasInitializer()) { // Only process initialized GV's 2148d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Figure out what the initializer looks like in the dest module... 215e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Constant *DInit = 216e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner cast<Constant>(RemapOperand(SGV->getInitializer(), ValueMap)); 2178d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 2188d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner GlobalVariable *DGV = cast<GlobalVariable>(ValueMap[SGV]); 219e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner if (DGV->hasInitializer() && SGV->hasExternalLinkage() && 220e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner DGV->hasExternalLinkage()) { 2218d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner if (DGV->getInitializer() != DInit) 2228d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return Error(Err, "Global Variable Collision on '" + 2238d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner SGV->getType()->getDescription() + "':%" +SGV->getName()+ 2248d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner " - Global variables have different initializers"); 2258d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } else { 2268d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Copy the initializer over now... 2278d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner DGV->setInitializer(DInit); 2288d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 2298d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 2308d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 2318d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return false; 2328d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner} 2335c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 23479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// LinkFunctionProtos - Link the functions together between the two modules, 23579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// without doing method bodies... this just adds external method prototypes to 23679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// the Dest function... 2375c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 23879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattnerstatic bool LinkFunctionProtos(Module *Dest, const Module *Src, 23979df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner map<const Value*, Value*> &ValueMap, 24079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner string *Err = 0) { 2415c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // We will need a module level symbol table if the src module has a module 2425c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // level symbol table... 2435c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner SymbolTable *ST = Src->getSymbolTable() ? Dest->getSymbolTableSure() : 0; 2445c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2455c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the methods in the src module, mapping them over as we go 2465c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 2475c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner for (Module::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) { 24879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const Function *SM = *I; // SrcFunction 2495c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner Value *V; 2505c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2515c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // If the method has a name, and that name is already in use in the 2525c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Dest module, make sure that the name is a compatible method... 2535c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 254e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner if (SM->hasExternalLinkage() && SM->hasName() && 255e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner (V = ST->lookup(SM->getType(), SM->getName())) && 25679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner cast<Function>(V)->hasExternalLinkage()) { 25779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // The same named thing is a Function, because the only two things 25879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // that may be in a module level symbol table are Global Vars and 25979df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // Functions, and they both have distinct, nonoverlapping, possible types. 2605c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 26179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner Function *DM = cast<Function>(V); // DestFunction 2625c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2635c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Check to make sure the method is not defined in both modules... 2645c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (!SM->isExternal() && !DM->isExternal()) 26579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner return Error(Err, "Function '" + 2665c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner SM->getMethodType()->getDescription() + "':\"" + 26779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner SM->getName() + "\" - Function is already defined!"); 2685c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2695c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Otherwise, just remember this mapping... 270697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner ValueMap.insert(std::make_pair(SM, DM)); 2715c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } else { 27279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // Function does not already exist, simply insert an external method 2735c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // signature identical to SM into the dest module... 27479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner Function *DM = new Function(SM->getMethodType(), SM->hasInternalLinkage(), 27579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner SM->getName()); 2765c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2775c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Add the method signature to the dest module... 27879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner Dest->getFunctionList().push_back(DM); 2795c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2805c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // ... and remember this mapping... 281697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner ValueMap.insert(std::make_pair(SM, DM)); 2825c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 2835c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 2845c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 2855c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 2865c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 28779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// LinkFunctionBody - Copy the source method over into the dest method 28879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// and fix up references to values. At this point we know that Dest 28979df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// is an external method, and that Src is not. 2905c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 29179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattnerstatic bool LinkFunctionBody(Function *Dest, const Function *Src, 29279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const map<const Value*, Value*> &GlobalMap, 29379df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner string *Err = 0) { 2945c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner assert(Src && Dest && Dest->isExternal() && !Src->isExternal()); 2955c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner map<const Value*, Value*> LocalMap; // Map for method local values 2965c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2975c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Go through and convert method arguments over... 29879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner for (Function::ArgumentListType::const_iterator 2995c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner I = Src->getArgumentList().begin(), 3005c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner E = Src->getArgumentList().end(); I != E; ++I) { 30179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const FunctionArgument *SMA = *I; 3025c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3035c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Create the new method argument and add to the dest method... 30479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner FunctionArgument *DMA = new FunctionArgument(SMA->getType(),SMA->getName()); 3055c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner Dest->getArgumentList().push_back(DMA); 3065c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3075c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Add a mapping to our local map 308697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner LocalMap.insert(std::make_pair(SMA, DMA)); 3095c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3105c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3115c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the basic blocks, copying the instructions over... 3125c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 31379df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner for (Function::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) { 3145c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner const BasicBlock *SBB = *I; 3155c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3165c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Create new basic block and add to mapping and the Dest method... 3175c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner BasicBlock *DBB = new BasicBlock(SBB->getName(), Dest); 318697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner LocalMap.insert(std::make_pair(SBB, DBB)); 3195c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3205c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the instructions in the src basic block, copying them 3215c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // over. Note that this is broken in a strict sense because the cloned 3225c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // instructions will still be referencing values in the Src module, not 3235c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // the remapped values. In our case, however, we will not get caught and 3245c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // so we can delay patching the values up until later... 3255c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 3265c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner for (BasicBlock::const_iterator II = SBB->begin(), IE = SBB->end(); 3275c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner II != IE; ++II) { 3285c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner const Instruction *SI = *II; 3295c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner Instruction *DI = SI->clone(); 33043a6f2e332eb54796a2e85188aa89c0dfee03ef3Chris Lattner DI->setName(SI->getName()); 3315c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner DBB->getInstList().push_back(DI); 332697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner LocalMap.insert(std::make_pair(SI, DI)); 3335c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3345c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3355c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3365c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // At this point, all of the instructions and values of the method are now 3375c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // copied over. The only problem is that they are still referencing values 3385c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // in the Source method as operands. Loop through all of the operands of the 3395c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // methods and patch them up to point to the local versions... 3405c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 34179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner for (Function::iterator BI = Dest->begin(), BE = Dest->end(); 342221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner BI != BE; ++BI) { 343221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner BasicBlock *BB = *BI; 344221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) { 345221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner Instruction *Inst = *I; 346221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner 347221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner for (Instruction::op_iterator OI = Inst->op_begin(), OE = Inst->op_end(); 348221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner OI != OE; ++OI) 349221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner *OI = RemapOperand(*OI, LocalMap, &GlobalMap); 350221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner } 3515c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3525c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3535c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 3545c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 3555c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3565c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 35779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// LinkFunctionBodies - Link in the method bodies that are defined in the source 3585c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// module into the DestModule. This consists basically of copying the method 3595c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// over and fixing up references to values. 3605c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 36179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattnerstatic bool LinkFunctionBodies(Module *Dest, const Module *Src, 36279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner map<const Value*, Value*> &ValueMap, 36379df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner string *Err = 0) { 3645c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3655c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the methods in the src module, mapping them over as we go 3665c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 3675c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner for (Module::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) { 36879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const Function *SM = *I; // Source Function 369c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner if (!SM->isExternal()) { // No body if method is external 37079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner Function *DM = cast<Function>(ValueMap[SM]); // Destination method 371c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner 372c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner // DM not external SM external? 373c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner if (!DM->isExternal()) { 374c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner if (Err) 37579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner *Err = "Function '" + (SM->hasName() ? SM->getName() : string("")) + 376c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner "' body multiply defined!"; 377c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner return true; 378c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner } 3795c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 38079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner if (LinkFunctionBody(DM, SM, ValueMap, Err)) return true; 381c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner } 3825c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3835c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 3845c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 3855c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 38652f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 38752f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 38852f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// LinkModules - This function links two modules together, with the resulting 38952f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// left module modified to be the composite of the two input modules. If an 39052f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// error occurs, true is returned and ErrorMsg (if not null) is set to indicate 3915c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// the problem. Upon failure, the Dest module could be in a modified state, and 3925c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// shouldn't be relied on to be consistent. 39352f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// 39452f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattnerbool LinkModules(Module *Dest, const Module *Src, string *ErrorMsg = 0) { 3952c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 3962c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // LinkTypes - Go through the symbol table of the Src module and see if any 3972c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // types are named in the src module that are not named in the Dst module. 3982c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // Make sure there are no type name conflicts. 3992c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // 4002c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (LinkTypes(Dest, Src, ErrorMsg)) return true; 4012c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 4025c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // ValueMap - Mapping of values from what they used to be in Src, to what they 4035c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // are now in Dest. 4045c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 4055c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner map<const Value*, Value*> ValueMap; 4065c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 4078d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Insert all of the globals in src into the Dest module... without 4088d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // initializers 4095c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (LinkGlobals(Dest, Src, ValueMap, ErrorMsg)) return true; 4105c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 4118d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Update the initializers in the Dest module now that all globals that may 4128d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // be referenced are in Dest. 4138d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // 4148d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner if (LinkGlobalInits(Dest, Src, ValueMap, ErrorMsg)) return true; 4158d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 4165c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Link the methods together between the two modules, without doing method 4175c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // bodies... this just adds external method prototypes to the Dest method... 4185c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // We do this so that when we begin processing method bodies, all of the 4195c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // global values that may be referenced are available in our ValueMap. 4205c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 42179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner if (LinkFunctionProtos(Dest, Src, ValueMap, ErrorMsg)) return true; 4225c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 4235c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Link in the method bodies that are defined in the source module into the 4245c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // DestModule. This consists basically of copying the method over and fixing 4255c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // up references to values. 4265c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 42779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner if (LinkFunctionBodies(Dest, Src, ValueMap, ErrorMsg)) return true; 42852f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 42952f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner return false; 43052f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner} 4319466f5113ba859677a28887c3c7143065e702019Vikram S. Adve 432