LinkModules.cpp revision 2719bac90525985f4ebb97324b4c087d47b54384
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" 145c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner#include "llvm/SymbolTable.h" 155c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner#include "llvm/DerivedTypes.h" 165c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner#include "llvm/iOther.h" 1731bcdb822fe9133b1973de51519d34e5813a6184Chris Lattner#include "llvm/Constants.h" 185c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 195c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// Error - Simple wrapper function to conditionally assign to E and return true. 205c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// This just makes error return conditions a little bit simpler... 215c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 225c2d335d86579941b71816196a95a64b277e8963Chris Lattnerstatic inline bool Error(std::string *E, std::string Message) { 235c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (E) *E = Message; 245c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return true; 255c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 265c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 272c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// LinkTypes - Go through the symbol table of the Src module and see if any 282c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// types are named in the src module that are not named in the Dst module. 292c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// Make sure there are no type name conflicts. 302c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner// 315c2d335d86579941b71816196a95a64b277e8963Chris Lattnerstatic bool LinkTypes(Module *Dest, const Module *Src, std::string *Err) { 326e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner SymbolTable *DestST = &Dest->getSymbolTable(); 336e6026b46569b01f8f6d4dcdb6c899c3a9c76b3eChris Lattner const SymbolTable *SrcST = &Src->getSymbolTable(); 342c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 352c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // Look for a type plane for Type's... 362c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner SymbolTable::const_iterator PI = SrcST->find(Type::TypeTy); 372c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (PI == SrcST->end()) return false; // No named types, do nothing. 382c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 392c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const SymbolTable::VarMap &VM = PI->second; 402c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner for (SymbolTable::type_const_iterator I = VM.begin(), E = VM.end(); 412c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner I != E; ++I) { 425c2d335d86579941b71816196a95a64b277e8963Chris Lattner const std::string &Name = I->first; 432c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const Type *RHS = cast<Type>(I->second); 442c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 452c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // Check to see if this type name is already in the dest module... 462c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner const Type *Entry = cast_or_null<Type>(DestST->lookup(Type::TypeTy, Name)); 475c2d335d86579941b71816196a95a64b277e8963Chris Lattner if (Entry && !isa<OpaqueType>(Entry)) { // Yup, the value already exists... 482f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner if (Entry != RHS) { 492f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner if (OpaqueType *OT = dyn_cast<OpaqueType>(const_cast<Type*>(RHS))) { 502f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner OT->refineAbstractTypeTo(Entry); 512f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner } else { 522f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner // If it's the same, noop. Otherwise, error. 532f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner return Error(Err, "Type named '" + Name + 542f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner "' of different shape in modules.\n Src='" + 552f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner Entry->getDescription() + "'.\n Dst='" + 562f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner RHS->getDescription() + "'"); 572f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner } 582f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner } 592c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner } else { // Type not in dest module. Add it now. 602f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner if (Entry) { 612f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner OpaqueType *OT = cast<OpaqueType>(const_cast<Type*>(Entry)); 622f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner OT->refineAbstractTypeTo(RHS); 632f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner } 642f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner 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 725c2d335d86579941b71816196a95a64b277e8963Chris Lattnerstatic void PrintMap(const std::map<const Value*, Value*> &M) { 735c2d335d86579941b71816196a95a64b277e8963Chris Lattner for (std::map<const Value*, Value*>::const_iterator I = M.begin(), E =M.end(); 742d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner I != E; ++I) { 755c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::cerr << " Fr: " << (void*)I->first << " "; 7687182ae6baf28ca6da6ee4bc00cf1857f293acfeChris Lattner I->first->dump(); 775c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::cerr << " To: " << (void*)I->second << " "; 7887182ae6baf28ca6da6ee4bc00cf1857f293acfeChris Lattner I->second->dump(); 795c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::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// 885c2d335d86579941b71816196a95a64b277e8963Chris Lattnerstatic Value *RemapOperand(const Value *In, 895c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::map<const Value*, Value*> &LocalMap, 905c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::map<const Value*, Value*> *GlobalMap) { 915c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::map<const Value*,Value*>::const_iterator I = LocalMap.find(In); 925c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (I != LocalMap.end()) return I->second; 935c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 945c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (GlobalMap) { 955c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner I = GlobalMap->find(In); 965c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (I != GlobalMap->end()) return I->second; 975c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 985c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 998d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Check to see if it's a constant that we are interesting in transforming... 10018961504fc2b299578dba817900a0696cf3ccc4dChris Lattner if (const Constant *CPV = dyn_cast<Constant>(In)) { 1016cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner if (!isa<DerivedType>(CPV->getType()) && !isa<ConstantExpr>(CPV)) 10218961504fc2b299578dba817900a0696cf3ccc4dChris Lattner return const_cast<Constant*>(CPV); // Simple constants stay identical... 1038d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 104e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Constant *Result = 0; 1058d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 10618961504fc2b299578dba817900a0696cf3ccc4dChris Lattner if (const ConstantArray *CPA = dyn_cast<ConstantArray>(CPV)) { 107697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner const std::vector<Use> &Ops = CPA->getValues(); 108697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner std::vector<Constant*> Operands(Ops.size()); 109e306d94782b1c608857738279852dcc050c66004Chris Lattner for (unsigned i = 0, e = Ops.size(); i != e; ++i) 1108d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner Operands[i] = 111e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner cast<Constant>(RemapOperand(Ops[i], LocalMap, GlobalMap)); 112e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Result = ConstantArray::get(cast<ArrayType>(CPA->getType()), Operands); 11318961504fc2b299578dba817900a0696cf3ccc4dChris Lattner } else if (const ConstantStruct *CPS = dyn_cast<ConstantStruct>(CPV)) { 114697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner const std::vector<Use> &Ops = CPS->getValues(); 115697954c15da58bd8b186dbafdedd8b06db770201Chris Lattner std::vector<Constant*> Operands(Ops.size()); 1168d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner for (unsigned i = 0; i < Ops.size(); ++i) 1178d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner Operands[i] = 118e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner cast<Constant>(RemapOperand(Ops[i], LocalMap, GlobalMap)); 119e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Result = ConstantStruct::get(cast<StructType>(CPS->getType()), Operands); 120e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner } else if (isa<ConstantPointerNull>(CPV)) { 12118961504fc2b299578dba817900a0696cf3ccc4dChris Lattner Result = const_cast<Constant*>(CPV); 12218961504fc2b299578dba817900a0696cf3ccc4dChris Lattner } else if (const ConstantPointerRef *CPR = 12318961504fc2b299578dba817900a0696cf3ccc4dChris Lattner dyn_cast<ConstantPointerRef>(CPV)) { 1248d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner Value *V = RemapOperand(CPR->getValue(), LocalMap, GlobalMap); 125e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner Result = ConstantPointerRef::get(cast<GlobalValue>(V)); 1266cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CPV)) { 127b319faff77a5bb12e753c45662f6c532b77f0b91Chris Lattner if (CE->getOpcode() == Instruction::GetElementPtr) { 128b319faff77a5bb12e753c45662f6c532b77f0b91Chris Lattner Value *Ptr = RemapOperand(CE->getOperand(0), LocalMap, GlobalMap); 129b319faff77a5bb12e753c45662f6c532b77f0b91Chris Lattner std::vector<Constant*> Indices; 130b319faff77a5bb12e753c45662f6c532b77f0b91Chris Lattner Indices.reserve(CE->getNumOperands()-1); 131b319faff77a5bb12e753c45662f6c532b77f0b91Chris Lattner for (unsigned i = 1, e = CE->getNumOperands(); i != e; ++i) 132b319faff77a5bb12e753c45662f6c532b77f0b91Chris Lattner Indices.push_back(cast<Constant>(RemapOperand(CE->getOperand(i), 133b319faff77a5bb12e753c45662f6c532b77f0b91Chris Lattner LocalMap, GlobalMap))); 134b319faff77a5bb12e753c45662f6c532b77f0b91Chris Lattner 135b319faff77a5bb12e753c45662f6c532b77f0b91Chris Lattner Result = ConstantExpr::getGetElementPtr(cast<Constant>(Ptr), Indices); 136b319faff77a5bb12e753c45662f6c532b77f0b91Chris Lattner } else if (CE->getNumOperands() == 1) { 137ad333484ea5ae976b83e35ccd3f6cfa6e71290e2Chris Lattner // Cast instruction 138ad333484ea5ae976b83e35ccd3f6cfa6e71290e2Chris Lattner assert(CE->getOpcode() == Instruction::Cast); 1396cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner Value *V = RemapOperand(CE->getOperand(0), LocalMap, GlobalMap); 140ad333484ea5ae976b83e35ccd3f6cfa6e71290e2Chris Lattner Result = ConstantExpr::getCast(cast<Constant>(V), CE->getType()); 1416cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner } else if (CE->getNumOperands() == 2) { 1426cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // Binary operator... 1436cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner Value *V1 = RemapOperand(CE->getOperand(0), LocalMap, GlobalMap); 1446cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner Value *V2 = RemapOperand(CE->getOperand(1), LocalMap, GlobalMap); 1456cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner 1466cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner Result = ConstantExpr::get(CE->getOpcode(), cast<Constant>(V1), 147e8e4605021141d689493132a9c7c6fce6294937fChris Lattner cast<Constant>(V2)); 1486cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner } else { 149b319faff77a5bb12e753c45662f6c532b77f0b91Chris Lattner assert(0 && "Unknown constant expr type!"); 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... 157d149c053cdbb406b7b5dff24127b4c509420893eChris Lattner if (GlobalMap) 158d149c053cdbb406b7b5dff24127b4c509420893eChris Lattner GlobalMap->insert(std::make_pair(In, Result)); 159d149c053cdbb406b7b5dff24127b4c509420893eChris Lattner else 160d149c053cdbb406b7b5dff24127b4c509420893eChris Lattner LocalMap.insert(std::make_pair(In, Result)); 1618d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return Result; 1628d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 1632d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner 1645c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::cerr << "XXX LocalMap: \n"; 1652d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner PrintMap(LocalMap); 1662d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner 1672d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner if (GlobalMap) { 1685c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::cerr << "XXX GlobalMap: \n"; 1692d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner PrintMap(*GlobalMap); 1702d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner } 1712d3e8bba628843bf2dffa21f69d9b45098d3bfc4Chris Lattner 1725c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::cerr << "Couldn't remap value: " << (void*)In << " " << *In << "\n"; 1738d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner assert(0 && "Couldn't remap value!"); 1748d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return 0; 1755c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 1765c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1775c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1785c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// LinkGlobals - Loop through the global variables in the src module and merge 1795c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// them into the dest module... 1805c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 1815c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattnerstatic bool LinkGlobals(Module *Dest, const Module *Src, 1825c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::map<const Value*, Value*> &ValueMap, 1835c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::string *Err) { 1845c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // We will need a module level symbol table if the src module has a module 1855c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // level symbol table... 186b91b657e026e86082b665cc875c2881ed075b68dChris Lattner SymbolTable *ST = (SymbolTable*)&Dest->getSymbolTable(); 1875c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 1885c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the globals in the src module, mapping them over as we go 1895c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 1905c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner for (Module::const_giterator I = Src->gbegin(), E = Src->gend(); I != E; ++I){ 19118961504fc2b299578dba817900a0696cf3ccc4dChris Lattner const GlobalVariable *SGV = I; 1924ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner GlobalVariable *DGV = 0; 1934ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (SGV->hasName()) { 1944ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner // A same named thing is a global variable, because the only two things 19579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // that may be in a module level symbol table are Global Vars and 19679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // Functions, and they both have distinct, nonoverlapping, possible types. 1975c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 1984ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner DGV = cast_or_null<GlobalVariable>(ST->lookup(SGV->getType(), 1994ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner SGV->getName())); 2004ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } 2015c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2024ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner assert(SGV->hasInitializer() || SGV->hasExternalLinkage() && 2034ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner "Global must either be external or have an initializer!"); 2045c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2050fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner bool SGExtern = SGV->isExternal(); 2060fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner bool DGExtern = DGV ? DGV->isExternal() : false; 2070fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner 2084ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (!DGV || DGV->hasInternalLinkage() || SGV->hasInternalLinkage()) { 2095c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // No linking to be performed, simply create an identical version of the 2108d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // symbol over in the dest module... the initializer will be filled in 2118d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // later by LinkGlobalInits... 2128d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // 2132719bac90525985f4ebb97324b4c087d47b54384Chris Lattner GlobalVariable *NewDGV = 2142719bac90525985f4ebb97324b4c087d47b54384Chris Lattner new GlobalVariable(SGV->getType()->getElementType(), 2152719bac90525985f4ebb97324b4c087d47b54384Chris Lattner SGV->isConstant(), SGV->getLinkage(), /*init*/0, 2162719bac90525985f4ebb97324b4c087d47b54384Chris Lattner SGV->getName(), Dest); 2172719bac90525985f4ebb97324b4c087d47b54384Chris Lattner 2182719bac90525985f4ebb97324b4c087d47b54384Chris Lattner // If the LLVM runtime renamed the global, but it is an externally visible 2192719bac90525985f4ebb97324b4c087d47b54384Chris Lattner // symbol, DGV must be an existing global with internal linkage. Rename 2202719bac90525985f4ebb97324b4c087d47b54384Chris Lattner // it. 2212719bac90525985f4ebb97324b4c087d47b54384Chris Lattner if (NewDGV->getName() != SGV->getName() && !NewDGV->hasInternalLinkage()){ 2222719bac90525985f4ebb97324b4c087d47b54384Chris Lattner assert(DGV && DGV->getName() == SGV->getName() && 2232719bac90525985f4ebb97324b4c087d47b54384Chris Lattner DGV->hasInternalLinkage()); 2242719bac90525985f4ebb97324b4c087d47b54384Chris Lattner DGV->setName(""); 2252719bac90525985f4ebb97324b4c087d47b54384Chris Lattner NewDGV->setName(SGV->getName()); // Force the name back 2262719bac90525985f4ebb97324b4c087d47b54384Chris Lattner DGV->setName(SGV->getName()); // This will cause a renaming 2272719bac90525985f4ebb97324b4c087d47b54384Chris Lattner assert(NewDGV->getName() == SGV->getName() && 2282719bac90525985f4ebb97324b4c087d47b54384Chris Lattner DGV->getName() != SGV->getName()); 2292719bac90525985f4ebb97324b4c087d47b54384Chris Lattner } 2305c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2315c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Make sure to remember this mapping... 2322719bac90525985f4ebb97324b4c087d47b54384Chris Lattner ValueMap.insert(std::make_pair(SGV, NewDGV)); 2330fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner } else if (!SGExtern && !DGExtern && SGV->getLinkage() !=DGV->getLinkage()){ 2344ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner return Error(Err, "Global variables named '" + SGV->getName() + 2354ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner "' have different linkage specifiers!"); 2364ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } else if (SGV->hasExternalLinkage() || SGV->hasLinkOnceLinkage() || 2374ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner SGV->hasAppendingLinkage()) { 2384ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner // If the global variable has a name, and that name is already in use in 2394ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner // the Dest module, make sure that the name is a compatible global 2404ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner // variable... 2414ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner // 2424ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner // Check to see if the two GV's have the same Const'ness... 2434ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (SGV->isConstant() != DGV->isConstant()) 2444ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner return Error(Err, "Global Variable Collision on '" + 2454ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner SGV->getType()->getDescription() + "':%" + SGV->getName() + 2464ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner " - Global variables differ in const'ness"); 2470fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner if (DGExtern) 2480fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner DGV->setLinkage(SGV->getLinkage()); 2490fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner 2504ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner // Okay, everything is cool, remember the mapping... 2514ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner ValueMap.insert(std::make_pair(SGV, DGV)); 2524ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } else { 2534ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner assert(0 && "Unknown linkage!"); 2545c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 2555c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 2565c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 2575c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 2585c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2595c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 2608d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner// LinkGlobalInits - Update the initializers in the Dest module now that all 2618d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner// globals that may be referenced are in Dest. 2628d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner// 2638d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattnerstatic bool LinkGlobalInits(Module *Dest, const Module *Src, 2645c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::map<const Value*, Value*> &ValueMap, 2655c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::string *Err) { 2668d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 2678d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Loop over all of the globals in the src module, mapping them over as we go 2688d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // 2698d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner for (Module::const_giterator I = Src->gbegin(), E = Src->gend(); I != E; ++I){ 27018961504fc2b299578dba817900a0696cf3ccc4dChris Lattner const GlobalVariable *SGV = I; 2718d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 2728d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner if (SGV->hasInitializer()) { // Only process initialized GV's 2738d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Figure out what the initializer looks like in the dest module... 2744ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner Constant *SInit = 2752f6bb2bce13084dfc4c8acf47f9eae0578267aaaChris Lattner cast<Constant>(RemapOperand(SGV->getInitializer(), ValueMap, 0)); 2768d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner 2778d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner GlobalVariable *DGV = cast<GlobalVariable>(ValueMap[SGV]); 2784ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (DGV->hasInitializer()) { 2794ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner assert(SGV->getLinkage() == DGV->getLinkage()); 2804ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (SGV->hasExternalLinkage()) { 2814ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (DGV->getInitializer() != SInit) 2824ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner return Error(Err, "Global Variable Collision on '" + 2834ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner SGV->getType()->getDescription() +"':%"+SGV->getName()+ 2844ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner " - Global variables have different initializers"); 2854ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } else if (DGV->hasLinkOnceLinkage()) { 2864ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner // Nothing is required, mapped values will take the new global 2874ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner // automatically. 2884ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } else if (DGV->hasAppendingLinkage()) { 2894ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner assert(0 && "Appending linkage unimplemented!"); 2904ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } else { 2914ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner assert(0 && "Unknown linkage!"); 2924ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } 2938d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } else { 2948d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Copy the initializer over now... 2954ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner DGV->setInitializer(SInit); 2968d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 2978d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 2988d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner } 2998d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner return false; 3008d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner} 3015c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 30279df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner// LinkFunctionProtos - Link the functions together between the two modules, 303c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// without doing function bodies... this just adds external function prototypes 304c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// to the Dest function... 3055c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 30679df7c0aaa18129e55968c8783ef8346807bd4afChris Lattnerstatic bool LinkFunctionProtos(Module *Dest, const Module *Src, 3075c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::map<const Value*, Value*> &ValueMap, 3085c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::string *Err) { 309b91b657e026e86082b665cc875c2881ed075b68dChris Lattner SymbolTable *ST = (SymbolTable*)&Dest->getSymbolTable(); 3105c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 311c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Loop over all of the functions in the src module, mapping them over as we 312c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // go 3135c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 3145c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner for (Module::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) { 31518961504fc2b299578dba817900a0696cf3ccc4dChris Lattner const Function *SF = I; // SrcFunction 3164ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner Function *DF = 0; 3174ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (SF->hasName()) 31879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // The same named thing is a Function, because the only two things 31979df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // that may be in a module level symbol table are Global Vars and 32079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner // Functions, and they both have distinct, nonoverlapping, possible types. 3215c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 3224ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner DF = cast_or_null<Function>(ST->lookup(SF->getType(), SF->getName())); 3235c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3240fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner bool SFExtern = SF->isExternal(); 3250fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner bool DFExtern = DF ? DF->isExternal() : false; 3260fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner 3274ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (!DF || SF->hasInternalLinkage() || DF->hasInternalLinkage()) { 3280fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner // Function does not already exist, simply insert an function signature 3290fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner // identical to SF into the dest module... 3302719bac90525985f4ebb97324b4c087d47b54384Chris Lattner Function *NewDF = new Function(SF->getFunctionType(), SF->getLinkage(), 3312719bac90525985f4ebb97324b4c087d47b54384Chris Lattner SF->getName(), Dest); 3322719bac90525985f4ebb97324b4c087d47b54384Chris Lattner 3332719bac90525985f4ebb97324b4c087d47b54384Chris Lattner // If the LLVM runtime renamed the function, but it is an externally 3342719bac90525985f4ebb97324b4c087d47b54384Chris Lattner // visible symbol, DF must be an existing function with internal linkage. 3352719bac90525985f4ebb97324b4c087d47b54384Chris Lattner // Rename it. 3362719bac90525985f4ebb97324b4c087d47b54384Chris Lattner if (NewDF->getName() != SF->getName() && !NewDF->hasInternalLinkage()) { 3372719bac90525985f4ebb97324b4c087d47b54384Chris Lattner assert(DF && DF->getName() == SF->getName() &&DF->hasInternalLinkage()); 3382719bac90525985f4ebb97324b4c087d47b54384Chris Lattner DF->setName(""); 3392719bac90525985f4ebb97324b4c087d47b54384Chris Lattner NewDF->setName(SF->getName()); // Force the name back 3402719bac90525985f4ebb97324b4c087d47b54384Chris Lattner DF->setName(SF->getName()); // This will cause a renaming 3412719bac90525985f4ebb97324b4c087d47b54384Chris Lattner assert(NewDF->getName() == SF->getName() && 3422719bac90525985f4ebb97324b4c087d47b54384Chris Lattner DF->getName() != SF->getName()); 3432719bac90525985f4ebb97324b4c087d47b54384Chris Lattner } 3444ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 3454ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner // ... and remember this mapping... 3462719bac90525985f4ebb97324b4c087d47b54384Chris Lattner ValueMap.insert(std::make_pair(SF, NewDF)); 3474ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } else if (SF->getLinkage() == GlobalValue::AppendingLinkage) { 3484ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner return Error(Err, "Functions named '" + SF->getName() + 3494ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner "' have appending linkage!"); 3500fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner } else if (!SFExtern && !DFExtern && SF->getLinkage() != DF->getLinkage()) { 3510fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner return Error(Err, "Functions named '" + SF->getName() + 3520fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner "' have different linkage specifiers!"); 3534ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } else if (SF->getLinkage() == GlobalValue::ExternalLinkage) { 3544ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner // If the function has a name, and that name is already in use in the Dest 3554ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner // module, make sure that the name is a compatible function... 3564ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner // 357c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Check to make sure the function is not defined in both modules... 35818961504fc2b299578dba817900a0696cf3ccc4dChris Lattner if (!SF->isExternal() && !DF->isExternal()) 35979df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner return Error(Err, "Function '" + 36018961504fc2b299578dba817900a0696cf3ccc4dChris Lattner SF->getFunctionType()->getDescription() + "':\"" + 36118961504fc2b299578dba817900a0696cf3ccc4dChris Lattner SF->getName() + "\" - Function is already defined!"); 3624ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner 3630fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner if (DFExtern) 3640fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner DF->setLinkage(SF->getLinkage()); 3650fec08eb58dd9fffeb72c584aa61a59d71111c8dChris Lattner 3665c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Otherwise, just remember this mapping... 36718961504fc2b299578dba817900a0696cf3ccc4dChris Lattner ValueMap.insert(std::make_pair(SF, DF)); 3684ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner } else if (SF->getLinkage() == GlobalValue::LinkOnceLinkage) { 3694ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner // Completely ignore the source function. 37018961504fc2b299578dba817900a0696cf3ccc4dChris Lattner ValueMap.insert(std::make_pair(SF, DF)); 3715c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3725c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3735c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 3745c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 3755c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 376c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// LinkFunctionBody - Copy the source function over into the dest function and 377c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// fix up references to values. At this point we know that Dest is an external 378c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// function, and that Src is not. 3795c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 38079df7c0aaa18129e55968c8783ef8346807bd4afChris Lattnerstatic bool LinkFunctionBody(Function *Dest, const Function *Src, 3815c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::map<const Value*, Value*> &GlobalMap, 3825c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::string *Err) { 3835c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner assert(Src && Dest && Dest->isExternal() && !Src->isExternal()); 3845c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::map<const Value*, Value*> LocalMap; // Map for function local values 3855c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 386c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Go through and convert function arguments over... 38769da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner Function::aiterator DI = Dest->abegin(); 38818961504fc2b299578dba817900a0696cf3ccc4dChris Lattner for (Function::const_aiterator I = Src->abegin(), E = Src->aend(); 38969da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner I != E; ++I, ++DI) { 39069da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner DI->setName(I->getName()); // Copy the name information over... 3915c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3925c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Add a mapping to our local map 39369da5cf26143e4542d4bf8c78ffac6d079efe5c9Chris Lattner LocalMap.insert(std::make_pair(I, DI)); 3945c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 3955c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 3965c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the basic blocks, copying the instructions over... 3975c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 39879df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner for (Function::const_iterator I = Src->begin(), E = Src->end(); I != E; ++I) { 399c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Create new basic block and add to mapping and the Dest function... 40018961504fc2b299578dba817900a0696cf3ccc4dChris Lattner BasicBlock *DBB = new BasicBlock(I->getName(), Dest); 40118961504fc2b299578dba817900a0696cf3ccc4dChris Lattner LocalMap.insert(std::make_pair(I, DBB)); 4025c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 4035c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // Loop over all of the instructions in the src basic block, copying them 4045c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // over. Note that this is broken in a strict sense because the cloned 4055c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // instructions will still be referencing values in the Src module, not 4065c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // the remapped values. In our case, however, we will not get caught and 4075c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // so we can delay patching the values up until later... 4085c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 40918961504fc2b299578dba817900a0696cf3ccc4dChris Lattner for (BasicBlock::const_iterator II = I->begin(), IE = I->end(); 4105c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner II != IE; ++II) { 41118961504fc2b299578dba817900a0696cf3ccc4dChris Lattner Instruction *DI = II->clone(); 41218961504fc2b299578dba817900a0696cf3ccc4dChris Lattner DI->setName(II->getName()); 4135c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner DBB->getInstList().push_back(DI); 41418961504fc2b299578dba817900a0696cf3ccc4dChris Lattner LocalMap.insert(std::make_pair(II, DI)); 4155c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 4165c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 4175c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 418c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // At this point, all of the instructions and values of the function are now 419c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // copied over. The only problem is that they are still referencing values in 420c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // the Source function as operands. Loop through all of the operands of the 421c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // functions and patch them up to point to the local versions... 4225c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 42318961504fc2b299578dba817900a0696cf3ccc4dChris Lattner for (Function::iterator BB = Dest->begin(), BE = Dest->end(); BB != BE; ++BB) 42418961504fc2b299578dba817900a0696cf3ccc4dChris Lattner for (BasicBlock::iterator I = BB->begin(), E = BB->end(); I != E; ++I) 42518961504fc2b299578dba817900a0696cf3ccc4dChris Lattner for (Instruction::op_iterator OI = I->op_begin(), OE = I->op_end(); 426221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner OI != OE; ++OI) 427221d688a5ef21a22c2368c9fff0e92d7966c95e5Chris Lattner *OI = RemapOperand(*OI, LocalMap, &GlobalMap); 4285c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 4295c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 4305c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 4315c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 4325c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 433c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// LinkFunctionBodies - Link in the function bodies that are defined in the 434c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// source module into the DestModule. This consists basically of copying the 435c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner// function over and fixing up references to values. 4365c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// 43779df7c0aaa18129e55968c8783ef8346807bd4afChris Lattnerstatic bool LinkFunctionBodies(Module *Dest, const Module *Src, 4385c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::map<const Value*, Value*> &ValueMap, 4395c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::string *Err) { 4405c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 441c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Loop over all of the functions in the src module, mapping them over as we 442c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // go 4435c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 44418961504fc2b299578dba817900a0696cf3ccc4dChris Lattner for (Module::const_iterator SF = Src->begin(), E = Src->end(); SF != E; ++SF){ 44518961504fc2b299578dba817900a0696cf3ccc4dChris Lattner if (!SF->isExternal()) { // No body if function is external 44618961504fc2b299578dba817900a0696cf3ccc4dChris Lattner Function *DF = cast<Function>(ValueMap[SF]); // Destination function 447c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner 44818961504fc2b299578dba817900a0696cf3ccc4dChris Lattner // DF not external SF external? 44918961504fc2b299578dba817900a0696cf3ccc4dChris Lattner if (!DF->isExternal()) { 4504ad02e726d9b634372b037d4b352d8b63bb9e849Chris Lattner if (DF->hasLinkOnceLinkage()) continue; // No relinkage for link-once! 451c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner if (Err) 4525c2d335d86579941b71816196a95a64b277e8963Chris Lattner *Err = "Function '" + (SF->hasName() ? SF->getName() :std::string("")) 4535c2d335d86579941b71816196a95a64b277e8963Chris Lattner + "' body multiply defined!"; 454c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner return true; 455c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner } 4565c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 45718961504fc2b299578dba817900a0696cf3ccc4dChris Lattner if (LinkFunctionBody(DF, SF, ValueMap, Err)) return true; 458c2d774b6c1d38421c435b6d3cfaa10402c900aebChris Lattner } 4595c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner } 4605c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner return false; 4615c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner} 4625c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 46352f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 46452f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 46552f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// LinkModules - This function links two modules together, with the resulting 46652f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// left module modified to be the composite of the two input modules. If an 46752f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// error occurs, true is returned and ErrorMsg (if not null) is set to indicate 4685c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// the problem. Upon failure, the Dest module could be in a modified state, and 4695c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner// shouldn't be relied on to be consistent. 47052f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner// 4715c2d335d86579941b71816196a95a64b277e8963Chris Lattnerbool LinkModules(Module *Dest, const Module *Src, std::string *ErrorMsg) { 4722c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 4732c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // LinkTypes - Go through the symbol table of the Src module and see if any 4742c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // types are named in the src module that are not named in the Dst module. 4752c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // Make sure there are no type name conflicts. 4762c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner // 4772c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner if (LinkTypes(Dest, Src, ErrorMsg)) return true; 4782c236f3e20a0fb84b5948efa6bb7bb60d759cb32Chris Lattner 4795c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // ValueMap - Mapping of values from what they used to be in Src, to what they 4805c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // are now in Dest. 4815c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 4825c2d335d86579941b71816196a95a64b277e8963Chris Lattner std::map<const Value*, Value*> ValueMap; 4835c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 4848d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // Insert all of the globals in src into the Dest module... without 4858d2de8a82cce67513debee7a3fa5aca0189b4105Chris Lattner // initializers 4865c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner if (LinkGlobals(Dest, Src, ValueMap, ErrorMsg)) return true; 4875c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 488c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Link the functions together between the two modules, without doing function 489c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // bodies... this just adds external function prototypes to the Dest 490c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // function... We do this so that when we begin processing function bodies, 491c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // all of the global values that may be referenced are available in our 492c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // ValueMap. 4935c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 49479df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner if (LinkFunctionProtos(Dest, Src, ValueMap, ErrorMsg)) return true; 4955c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner 4966cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // Update the initializers in the Dest module now that all globals that may 4976cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // be referenced are in Dest. 4986cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner // 4996cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner if (LinkGlobalInits(Dest, Src, ValueMap, ErrorMsg)) return true; 5006cdf1971bdf88ddd9a7d46b5f5f975497d68c38eChris Lattner 501c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // Link in the function bodies that are defined in the source module into the 502c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // DestModule. This consists basically of copying the function over and 503c8cc4cb03bd90f89be7fe1649542a2d5ae689632Chris Lattner // fixing up references to values. 5045c377c524a6929cdaa683f3f034b3fc01526b264Chris Lattner // 50579df7c0aaa18129e55968c8783ef8346807bd4afChris Lattner if (LinkFunctionBodies(Dest, Src, ValueMap, ErrorMsg)) return true; 50652f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner 50752f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner return false; 50852f7e908cb634f9b9b539d5c6670b8a065478915Chris Lattner} 5099466f5113ba859677a28887c3c7143065e702019Vikram S. Adve 510