1 //===- CloneModule.cpp - Clone an entire module ---------------------------===// 2 // 3 // The LLVM Compiler Infrastructure 4 // 5 // This file was developed by the LLVM research group and is distributed under 6 // the University of Illinois Open Source License. See LICENSE.TXT for details. 7 // 8 //===----------------------------------------------------------------------===// 9 // 10 // This file implements the CloneModule interface which makes a copy of an 11 // entire module. 12 // 13 //===----------------------------------------------------------------------===// 14 15 #include "llvm/Transforms/Utils/Cloning.h" 16 #include "llvm/Module.h" 17 #include "llvm/DerivedTypes.h" 18 #include "llvm/SymbolTable.h" 19 #include "llvm/Constant.h" 20 #include "ValueMapper.h" 21 using namespace llvm; 22 23 /// CloneModule - Return an exact copy of the specified module. This is not as 24 /// easy as it might seem because we have to worry about making copies of global 25 /// variables and functions, and making their (initializers and references, 26 /// respectively) refer to the right globals. 27 /// 28 Module *llvm::CloneModule(const Module *M) { 29 // First off, we need to create the new module... 30 Module *New = new Module(M->getModuleIdentifier()); 31 New->setEndianness(M->getEndianness()); 32 New->setPointerSize(M->getPointerSize()); 33 34 // Copy all of the type symbol table entries over... 35 const SymbolTable &SymTab = M->getSymbolTable(); 36 SymbolTable::const_iterator TypeI = SymTab.find(Type::TypeTy); 37 if (TypeI != SymTab.end()) 38 for (SymbolTable::VarMap::const_iterator I = TypeI->second.begin(), 39 E = TypeI->second.end(); I != E; ++I) 40 New->addTypeName(I->first, cast<Type>(I->second)); 41 42 // Create the value map that maps things from the old module over to the new 43 // module. 44 std::map<const Value*, Value*> ValueMap; 45 46 // Loop over all of the global variables, making corresponding globals in the 47 // new module. Here we add them to the ValueMap and to the new Module. We 48 // don't worry about attributes or initializers, they will come later. 49 // 50 for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I) 51 ValueMap[I] = new GlobalVariable(I->getType()->getElementType(), false, 52 GlobalValue::ExternalLinkage, 0, 53 I->getName(), New); 54 55 // Loop over the functions in the module, making external functions as before 56 for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) 57 ValueMap[I]=new Function(cast<FunctionType>(I->getType()->getElementType()), 58 GlobalValue::ExternalLinkage, I->getName(), New); 59 60 // Now that all of the things that global variable initializer can refer to 61 // have been created, loop through and copy the global variable referrers 62 // over... We also set the attributes on the global now. 63 // 64 for (Module::const_giterator I = M->gbegin(), E = M->gend(); I != E; ++I) { 65 GlobalVariable *GV = cast<GlobalVariable>(ValueMap[I]); 66 if (I->hasInitializer()) 67 GV->setInitializer(cast<Constant>(MapValue(I->getInitializer(), 68 ValueMap))); 69 GV->setLinkage(I->getLinkage()); 70 } 71 72 // Similarly, copy over function bodies now... 73 // 74 for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) { 75 Function *F = cast<Function>(ValueMap[I]); 76 if (!I->isExternal()) { 77 Function::aiterator DestI = F->abegin(); 78 for (Function::const_aiterator J = I->abegin(); J != I->aend(); ++J) { 79 DestI->setName(J->getName()); 80 ValueMap[J] = DestI++; 81 } 82 83 std::vector<ReturnInst*> Returns; // Ignore returns cloned... 84 CloneFunctionInto(F, I, ValueMap, Returns); 85 } 86 87 F->setLinkage(I->getLinkage()); 88 } 89 90 return New; 91 } 92