LinkModules.cpp revision 87182ae6baf28ca6da6ee4bc00cf1857f293acfe
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 342c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// LinkTypes - Go through the symbol table of the Src module and see if any 352c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// types are named in the src module that are not named in the Dst module. 362c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// Make sure there are no type name conflicts. 372c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// 382c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattnerstatic bool LinkTypes(Module *Dest, const Module *Src, string *Err = 0) { 392c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // No symbol table? Can't have named types. 402c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (!Src->hasSymbolTable()) return false; 412c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 422c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner SymbolTable *DestST = Dest->getSymbolTableSure(); 432c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const SymbolTable *SrcST = Src->getSymbolTable(); 442c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 452c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // Look for a type plane for Type's... 462c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner SymbolTable::const_iterator PI = SrcST->find(Type::TypeTy); 472c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (PI == SrcST->end()) return false; // No named types, do nothing. 482c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 492c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const SymbolTable::VarMap &VM = PI->second; 502c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner for (SymbolTable::type_const_iterator I = VM.begin(), E = VM.end(); 512c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner I != E; ++I) { 522c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const string &Name = I->first; 532c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const Type *RHS = cast<Type>(I->second); 542c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 552c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // Check to see if this type name is already in the dest module... 562c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const Type *Entry = cast_or_null<Type>(DestST->lookup(Type::TypeTy, Name)); 572c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (Entry) { // Yup, the value already exists... 582c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (Entry != RHS) // If it's the same, noop. Otherwise, error. 592c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner return Error(Err, "Type named '" + Name + 602c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner "' of different shape in modules.\n Src='" + 619b638019ca8870f418e3b42b39dd34dc7deebb2dChris Lattner Entry->getDescription() + "'.\n Dst='" + 622c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner RHS->getDescription() + "'"); 632c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner } else { // Type not in dest module. Add it now. 642c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // TODO: FIXME WHEN TYPES AREN'T CONST 652c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner DestST->insert(Name, const_cast<Type*>(RHS)); 662c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner } 672c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner } 682c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner return false; 692c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner} 702c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 712d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattnerstatic void PrintMap(const map<const Value*, Value*> &M) { 722d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner for (map<const Value*, Value*>::const_iterator I = M.begin(), E = M.end(); 732d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner I != E; ++I) { 7487182ae6baf28ca6da6ee4bc00cf1857f293acfeChris Lattner cerr << " Fr: " << (void*)I->first << " "; 7587182ae6baf28ca6da6ee4bc00cf1857f293acfeChris Lattner I->first->dump(); 7687182ae6baf28ca6da6ee4bc00cf1857f293acfeChris Lattner cerr << " To: " << (void*)I->second << " "; 7787182ae6baf28ca6da6ee4bc00cf1857f293acfeChris Lattner I->second->dump(); 7887182ae6baf28ca6da6ee4bc00cf1857f293acfeChris Lattner cerr << "\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 14087182ae6baf28ca6da6ee4bc00cf1857f293acfeChris Lattner cerr << "Couldn't remap value: " << (void*)In << " "; 14187182ae6baf28ca6da6ee4bc00cf1857f293acfeChris Lattner In->dump(); 14287182ae6baf28ca6da6ee4bc00cf1857f293acfeChris Lattner cerr << "\n"; 1438d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner assert(0 && "Couldn't remap value!"); 1448d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return 0; 1455c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 1465c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1475c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1485c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// LinkGlobals - Loop through the global variables in the src module and merge 1495c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// them into the dest module... 1505c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 1515c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattnerstatic bool LinkGlobals(Module *Dest, const Module *Src, 1525c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner map<const Value*, Value*> &ValueMap, string *Err = 0) { 1535c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // We will need a module level symbol table if the src module has a module 1545c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // level symbol table... 1555c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner SymbolTable *ST = Src->getSymbolTable() ? Dest->getSymbolTableSure() : 0; 1565c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1575c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the globals in the src module, mapping them over as we go 1585c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 1595c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner for (Module::const_giterator I = Src->gbegin(), E = Src->gend(); I != E; ++I){ 1608d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner const GlobalVariable *SGV = *I; 1615c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner Value *V; 1625c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1635c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // If the global variable has a name, and that name is already in use in the 1645c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Dest module, make sure that the name is a compatible global variable... 1655c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 166e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner if (SGV->hasExternalLinkage() && SGV->hasName() && 167e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner (V = ST->lookup(SGV->getType(), SGV->getName())) && 168e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner cast<GlobalVariable>(V)->hasExternalLinkage()) { 1695c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // The same named thing is a global variable, because the only two things 17079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // that may be in a module level symbol table are Global Vars and 17179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // Functions, and they both have distinct, nonoverlapping, possible types. 1725c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 1735c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner GlobalVariable *DGV = cast<GlobalVariable>(V); 1745c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1755c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Check to see if the two GV's have the same Const'ness... 1768d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner if (SGV->isConstant() != DGV->isConstant()) 1775c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return Error(Err, "Global Variable Collision on '" + 1788d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner SGV->getType()->getDescription() + "':%" + SGV->getName() + 1795c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner " - Global variables differ in const'ness"); 1805c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1818d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Okay, everything is cool, remember the mapping... 182697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner ValueMap.insert(std::make_pair(SGV, DGV)); 1835c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } else { 1845c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // No linking to be performed, simply create an identical version of the 1858d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // symbol over in the dest module... the initializer will be filled in 1868d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // later by LinkGlobalInits... 1878d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // 1888d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner GlobalVariable *DGV = 1897a1767520611d9ff6face702068de858e1cadf2cChris Lattner new GlobalVariable(SGV->getType()->getElementType(), SGV->isConstant(), 190e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner SGV->hasInternalLinkage(), 0, SGV->getName()); 1915c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1925c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Add the new global to the dest module 1938d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner Dest->getGlobalList().push_back(DGV); 1945c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1955c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Make sure to remember this mapping... 196697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner ValueMap.insert(std::make_pair(SGV, DGV)); 1975c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 1985c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 1995c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 2005c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 2015c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2025c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2038d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner// LinkGlobalInits - Update the initializers in the Dest module now that all 2048d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner// globals that may be referenced are in Dest. 2058d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner// 2068d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattnerstatic bool LinkGlobalInits(Module *Dest, const Module *Src, 2078d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner map<const Value*, Value*> &ValueMap, 2088d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner string *Err = 0) { 2098d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 2108d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Loop over all of the globals in the src module, mapping them over as we go 2118d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // 2128d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner for (Module::const_giterator I = Src->gbegin(), E = Src->gend(); I != E; ++I){ 2138d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner const GlobalVariable *SGV = *I; 2148d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 2158d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner if (SGV->hasInitializer()) { // Only process initialized GV's 2168d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Figure out what the initializer looks like in the dest module... 217e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Constant *DInit = 218e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner cast<Constant>(RemapOperand(SGV->getInitializer(), ValueMap)); 2198d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 2208d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner GlobalVariable *DGV = cast<GlobalVariable>(ValueMap[SGV]); 221e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner if (DGV->hasInitializer() && SGV->hasExternalLinkage() && 222e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner DGV->hasExternalLinkage()) { 2238d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner if (DGV->getInitializer() != DInit) 2248d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return Error(Err, "Global Variable Collision on '" + 2258d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner SGV->getType()->getDescription() + "':%" +SGV->getName()+ 2268d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner " - Global variables have different initializers"); 2278d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } else { 2288d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Copy the initializer over now... 2298d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner DGV->setInitializer(DInit); 2308d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 2318d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 2328d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 2338d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return false; 2348d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner} 2355c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 23679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// LinkFunctionProtos - Link the functions together between the two modules, 23779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// without doing method bodies... this just adds external method prototypes to 23879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// the Dest function... 2395c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 24079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattnerstatic bool LinkFunctionProtos(Module *Dest, const Module *Src, 24179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner map<const Value*, Value*> &ValueMap, 24279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner string *Err = 0) { 2435c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // We will need a module level symbol table if the src module has a module 2445c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // level symbol table... 2455c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner SymbolTable *ST = Src->getSymbolTable() ? Dest->getSymbolTableSure() : 0; 2465c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2475c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the methods in the src module, mapping them over as we go 2485c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 2495c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner for (Module::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) { 25079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const Function *SM = *I; // SrcFunction 2515c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner Value *V; 2525c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2535c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // If the method has a name, and that name is already in use in the 2545c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Dest module, make sure that the name is a compatible method... 2555c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 256e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner if (SM->hasExternalLinkage() && SM->hasName() && 257e4d25aad16bfc2a26595f6255fc2bfdaa6c532a7Chris Lattner (V = ST->lookup(SM->getType(), SM->getName())) && 25879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner cast<Function>(V)->hasExternalLinkage()) { 25979df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // The same named thing is a Function, because the only two things 26079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // that may be in a module level symbol table are Global Vars and 26179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // Functions, and they both have distinct, nonoverlapping, possible types. 2625c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 26379df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner Function *DM = cast<Function>(V); // DestFunction 2645c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2655c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Check to make sure the method is not defined in both modules... 2665c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (!SM->isExternal() && !DM->isExternal()) 26779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner return Error(Err, "Function '" + 2686bfd6a578a3a4fa95c585c988ee712ba880f9923Chris Lattner SM->getFunctionType()->getDescription() + "':\"" + 26979df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner SM->getName() + "\" - Function is already defined!"); 2705c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2715c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Otherwise, just remember this mapping... 272697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner ValueMap.insert(std::make_pair(SM, DM)); 2735c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } else { 27479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // Function does not already exist, simply insert an external method 2755c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // signature identical to SM into the dest module... 2766bfd6a578a3a4fa95c585c988ee712ba880f9923Chris Lattner Function *DM = new Function(SM->getFunctionType(), 2776bfd6a578a3a4fa95c585c988ee712ba880f9923Chris Lattner SM->hasInternalLinkage(), 27879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner SM->getName()); 2795c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2805c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Add the method signature to the dest module... 28179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner Dest->getFunctionList().push_back(DM); 2825c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2835c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // ... and remember this mapping... 284697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner ValueMap.insert(std::make_pair(SM, DM)); 2855c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 2865c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 2875c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 2885c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 2895c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 29079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// LinkFunctionBody - Copy the source method over into the dest method 29179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// and fix up references to values. At this point we know that Dest 29279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// is an external method, and that Src is not. 2935c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 29479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattnerstatic bool LinkFunctionBody(Function *Dest, const Function *Src, 29579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const map<const Value*, Value*> &GlobalMap, 29679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner string *Err = 0) { 2975c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner assert(Src && Dest && Dest->isExternal() && !Src->isExternal()); 2985c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner map<const Value*, Value*> LocalMap; // Map for method local values 2995c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3005c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Go through and convert method arguments over... 30179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner for (Function::ArgumentListType::const_iterator 3025c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner I = Src->getArgumentList().begin(), 3035c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner E = Src->getArgumentList().end(); I != E; ++I) { 30479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const FunctionArgument *SMA = *I; 3055c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3065c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Create the new method argument and add to the dest method... 30779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner FunctionArgument *DMA = new FunctionArgument(SMA->getType(),SMA->getName()); 3085c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner Dest->getArgumentList().push_back(DMA); 3095c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3105c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Add a mapping to our local map 311697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner LocalMap.insert(std::make_pair(SMA, DMA)); 3125c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3135c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3145c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the basic blocks, copying the instructions over... 3155c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 31679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner for (Function::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) { 3175c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner const BasicBlock *SBB = *I; 3185c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3195c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Create new basic block and add to mapping and the Dest method... 3205c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner BasicBlock *DBB = new BasicBlock(SBB->getName(), Dest); 321697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner LocalMap.insert(std::make_pair(SBB, DBB)); 3225c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3235c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the instructions in the src basic block, copying them 3245c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // over. Note that this is broken in a strict sense because the cloned 3255c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // instructions will still be referencing values in the Src module, not 3265c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // the remapped values. In our case, however, we will not get caught and 3275c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // so we can delay patching the values up until later... 3285c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 3295c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner for (BasicBlock::const_iterator II = SBB->begin(), IE = SBB->end(); 3305c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner II != IE; ++II) { 3315c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner const Instruction *SI = *II; 3325c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner Instruction *DI = SI->clone(); 33343a6f2e332eb54796a2e85188aa89c0dfee03ef3Chris Lattner DI->setName(SI->getName()); 3345c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner DBB->getInstList().push_back(DI); 335697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner LocalMap.insert(std::make_pair(SI, DI)); 3365c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3375c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3385c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3395c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // At this point, all of the instructions and values of the method are now 3405c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // copied over. The only problem is that they are still referencing values 3415c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // in the Source method as operands. Loop through all of the operands of the 3425c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // methods and patch them up to point to the local versions... 3435c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 34479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner for (Function::iterator BI = Dest->begin(), BE = Dest->end(); 345221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner BI != BE; ++BI) { 346221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner BasicBlock *BB = *BI; 347221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) { 348221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner Instruction *Inst = *I; 349221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner 350221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner for (Instruction::op_iterator OI = Inst->op_begin(), OE = Inst->op_end(); 351221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner OI != OE; ++OI) 352221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner *OI = RemapOperand(*OI, LocalMap, &GlobalMap); 353221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner } 3545c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3555c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3565c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 3575c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 3585c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3595c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 36079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// LinkFunctionBodies - Link in the method bodies that are defined in the source 3615c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// module into the DestModule. This consists basically of copying the method 3625c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// over and fixing up references to values. 3635c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 36479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattnerstatic bool LinkFunctionBodies(Module *Dest, const Module *Src, 36579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner map<const Value*, Value*> &ValueMap, 36679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner string *Err = 0) { 3675c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3685c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the methods in the src module, mapping them over as we go 3695c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 3705c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner for (Module::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) { 37179df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner const Function *SM = *I; // Source Function 372c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner if (!SM->isExternal()) { // No body if method is external 37379df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner Function *DM = cast<Function>(ValueMap[SM]); // Destination method 374c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner 375c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner // DM not external SM external? 376c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner if (!DM->isExternal()) { 377c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner if (Err) 37879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner *Err = "Function '" + (SM->hasName() ? SM->getName() : string("")) + 379c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner "' body multiply defined!"; 380c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner return true; 381c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner } 3825c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 38379df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner if (LinkFunctionBody(DM, SM, ValueMap, Err)) return true; 384c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner } 3855c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3865c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 3875c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 3885c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 38952f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 39052f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 39152f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// LinkModules - This function links two modules together, with the resulting 39252f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// left module modified to be the composite of the two input modules. If an 39352f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// error occurs, true is returned and ErrorMsg (if not null) is set to indicate 3945c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// the problem. Upon failure, the Dest module could be in a modified state, and 3955c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// shouldn't be relied on to be consistent. 39652f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// 39752f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattnerbool LinkModules(Module *Dest, const Module *Src, string *ErrorMsg = 0) { 3982c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 3992c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // LinkTypes - Go through the symbol table of the Src module and see if any 4002c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // types are named in the src module that are not named in the Dst module. 4012c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // Make sure there are no type name conflicts. 4022c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // 4032c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (LinkTypes(Dest, Src, ErrorMsg)) return true; 4042c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 4055c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // ValueMap - Mapping of values from what they used to be in Src, to what they 4065c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // are now in Dest. 4075c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 4085c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner map<const Value*, Value*> ValueMap; 4095c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 4108d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Insert all of the globals in src into the Dest module... without 4118d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // initializers 4125c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (LinkGlobals(Dest, Src, ValueMap, ErrorMsg)) return true; 4135c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 4148d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Update the initializers in the Dest module now that all globals that may 4158d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // be referenced are in Dest. 4168d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // 4178d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner if (LinkGlobalInits(Dest, Src, ValueMap, ErrorMsg)) return true; 4188d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 4195c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Link the methods together between the two modules, without doing method 4205c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // bodies... this just adds external method prototypes to the Dest method... 4215c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // We do this so that when we begin processing method bodies, all of the 4225c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // global values that may be referenced are available in our ValueMap. 4235c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 42479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner if (LinkFunctionProtos(Dest, Src, ValueMap, ErrorMsg)) return true; 4255c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 4265c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Link in the method bodies that are defined in the source module into the 4275c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // DestModule. This consists basically of copying the method over and fixing 4285c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // up references to values. 4295c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 43079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner if (LinkFunctionBodies(Dest, Src, ValueMap, ErrorMsg)) return true; 43152f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 43252f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner return false; 43352f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner} 4349466f5113ba859677a28887c3c7143065e702019Vikram S. Adve 435