Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 1 | //===- CloneModule.cpp - Clone an entire module ---------------------------===// |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 2 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 4ee451d | 2007-12-29 20:36:04 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | fd93908 | 2005-04-21 23:48:37 +0000 | [diff] [blame] | 7 | // |
John Criswell | b576c94 | 2003-10-20 19:43:21 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 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" |
Reid Spencer | 78d033e | 2007-01-06 07:24:44 +0000 | [diff] [blame] | 18 | #include "llvm/TypeSymbolTable.h" |
Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 19 | #include "llvm/Constant.h" |
Anton Korobeynikov | 344ef19 | 2007-11-09 12:27:04 +0000 | [diff] [blame] | 20 | #include "llvm/Transforms/Utils/ValueMapper.h" |
Chris Lattner | f7703df | 2004-01-09 06:12:26 +0000 | [diff] [blame] | 21 | using namespace llvm; |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 22 | |
Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 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 |
Misha Brukman | cf00c4a | 2003-10-10 17:57:28 +0000 | [diff] [blame] | 25 | /// variables and functions, and making their (initializers and references, |
Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 26 | /// respectively) refer to the right globals. |
| 27 | /// |
Chris Lattner | f7703df | 2004-01-09 06:12:26 +0000 | [diff] [blame] | 28 | Module *llvm::CloneModule(const Module *M) { |
Chris Lattner | 782e601 | 2006-05-17 18:05:35 +0000 | [diff] [blame] | 29 | // Create the value map that maps things from the old module over to the new |
| 30 | // module. |
Chris Lattner | 5e665f5 | 2007-02-03 00:08:31 +0000 | [diff] [blame] | 31 | DenseMap<const Value*, Value*> ValueMap; |
Chris Lattner | 782e601 | 2006-05-17 18:05:35 +0000 | [diff] [blame] | 32 | return CloneModule(M, ValueMap); |
| 33 | } |
| 34 | |
Chris Lattner | 5e665f5 | 2007-02-03 00:08:31 +0000 | [diff] [blame] | 35 | Module *llvm::CloneModule(const Module *M, |
| 36 | DenseMap<const Value*, Value*> &ValueMap) { |
Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 37 | // First off, we need to create the new module... |
Chris Lattner | 37f5941 | 2003-04-22 18:02:26 +0000 | [diff] [blame] | 38 | Module *New = new Module(M->getModuleIdentifier()); |
Reid Spencer | 26f2385 | 2007-01-26 08:11:39 +0000 | [diff] [blame] | 39 | New->setDataLayout(M->getDataLayout()); |
Chris Lattner | c4e8c9f | 2006-01-18 21:32:45 +0000 | [diff] [blame] | 40 | New->setTargetTriple(M->getTargetTriple()); |
Chris Lattner | 3e2fa7a | 2006-01-24 04:16:34 +0000 | [diff] [blame] | 41 | New->setModuleInlineAsm(M->getModuleInlineAsm()); |
Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 42 | |
Chris Lattner | c4e8c9f | 2006-01-18 21:32:45 +0000 | [diff] [blame] | 43 | // Copy all of the type symbol table entries over. |
Reid Spencer | 78d033e | 2007-01-06 07:24:44 +0000 | [diff] [blame] | 44 | const TypeSymbolTable &TST = M->getTypeSymbolTable(); |
| 45 | for (TypeSymbolTable::const_iterator TI = TST.begin(), TE = TST.end(); |
| 46 | TI != TE; ++TI) |
| 47 | New->addTypeName(TI->first, TI->second); |
Chris Lattner | c4e8c9f | 2006-01-18 21:32:45 +0000 | [diff] [blame] | 48 | |
| 49 | // Copy all of the dependent libraries over. |
| 50 | for (Module::lib_iterator I = M->lib_begin(), E = M->lib_end(); I != E; ++I) |
| 51 | New->addLibrary(*I); |
Chris Lattner | 892310e | 2003-04-24 17:15:33 +0000 | [diff] [blame] | 52 | |
Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 53 | // Loop over all of the global variables, making corresponding globals in the |
| 54 | // new module. Here we add them to the ValueMap and to the new Module. We |
| 55 | // don't worry about attributes or initializers, they will come later. |
| 56 | // |
Chris Lattner | c154cef | 2005-05-09 01:04:34 +0000 | [diff] [blame] | 57 | for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); |
| 58 | I != E; ++I) |
Chris Lattner | 4ad02e7 | 2003-04-16 20:28:45 +0000 | [diff] [blame] | 59 | ValueMap[I] = new GlobalVariable(I->getType()->getElementType(), false, |
| 60 | GlobalValue::ExternalLinkage, 0, |
| 61 | I->getName(), New); |
Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 62 | |
| 63 | // Loop over the functions in the module, making external functions as before |
Chris Lattner | c154cef | 2005-05-09 01:04:34 +0000 | [diff] [blame] | 64 | for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) { |
Jeff Cohen | 00b16889 | 2005-07-27 06:12:32 +0000 | [diff] [blame] | 65 | Function *NF = |
Gabor Greif | 051a950 | 2008-04-06 20:25:17 +0000 | [diff] [blame^] | 66 | Function::Create(cast<FunctionType>(I->getType()->getElementType()), |
| 67 | GlobalValue::ExternalLinkage, I->getName(), New); |
Chris Lattner | c154cef | 2005-05-09 01:04:34 +0000 | [diff] [blame] | 68 | NF->setCallingConv(I->getCallingConv()); |
Duncan Sands | dc02467 | 2007-11-27 13:23:08 +0000 | [diff] [blame] | 69 | NF->setParamAttrs(I->getParamAttrs()); |
Gordon Henriksen | 80a75bf | 2007-12-10 03:18:06 +0000 | [diff] [blame] | 70 | if (I->hasCollector()) |
| 71 | NF->setCollector(I->getCollector()); |
Chris Lattner | c154cef | 2005-05-09 01:04:34 +0000 | [diff] [blame] | 72 | ValueMap[I]= NF; |
| 73 | } |
Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 74 | |
Anton Korobeynikov | a289511 | 2007-07-10 19:07:35 +0000 | [diff] [blame] | 75 | // Loop over the aliases in the module |
| 76 | for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); |
| 77 | I != E; ++I) |
| 78 | ValueMap[I] = new GlobalAlias(I->getType(), GlobalAlias::ExternalLinkage, |
| 79 | I->getName(), NULL, New); |
| 80 | |
Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 81 | // Now that all of the things that global variable initializer can refer to |
| 82 | // have been created, loop through and copy the global variable referrers |
| 83 | // over... We also set the attributes on the global now. |
| 84 | // |
Chris Lattner | c154cef | 2005-05-09 01:04:34 +0000 | [diff] [blame] | 85 | for (Module::const_global_iterator I = M->global_begin(), E = M->global_end(); |
| 86 | I != E; ++I) { |
Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 87 | GlobalVariable *GV = cast<GlobalVariable>(ValueMap[I]); |
| 88 | if (I->hasInitializer()) |
| 89 | GV->setInitializer(cast<Constant>(MapValue(I->getInitializer(), |
| 90 | ValueMap))); |
Chris Lattner | 4ad02e7 | 2003-04-16 20:28:45 +0000 | [diff] [blame] | 91 | GV->setLinkage(I->getLinkage()); |
Lauro Ramos Venancio | c763552 | 2007-04-12 18:32:50 +0000 | [diff] [blame] | 92 | GV->setThreadLocal(I->isThreadLocal()); |
| 93 | GV->setConstant(I->isConstant()); |
Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 94 | } |
| 95 | |
| 96 | // Similarly, copy over function bodies now... |
| 97 | // |
| 98 | for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) { |
| 99 | Function *F = cast<Function>(ValueMap[I]); |
Reid Spencer | 5cbf985 | 2007-01-30 20:08:39 +0000 | [diff] [blame] | 100 | if (!I->isDeclaration()) { |
Chris Lattner | e4d5c44 | 2005-03-15 04:54:21 +0000 | [diff] [blame] | 101 | Function::arg_iterator DestI = F->arg_begin(); |
Chris Lattner | c154cef | 2005-05-09 01:04:34 +0000 | [diff] [blame] | 102 | for (Function::const_arg_iterator J = I->arg_begin(); J != I->arg_end(); |
| 103 | ++J) { |
Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 104 | DestI->setName(J->getName()); |
| 105 | ValueMap[J] = DestI++; |
| 106 | } |
| 107 | |
| 108 | std::vector<ReturnInst*> Returns; // Ignore returns cloned... |
| 109 | CloneFunctionInto(F, I, ValueMap, Returns); |
| 110 | } |
| 111 | |
Chris Lattner | 4ad02e7 | 2003-04-16 20:28:45 +0000 | [diff] [blame] | 112 | F->setLinkage(I->getLinkage()); |
Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 113 | } |
| 114 | |
Anton Korobeynikov | a289511 | 2007-07-10 19:07:35 +0000 | [diff] [blame] | 115 | // And aliases |
| 116 | for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end(); |
| 117 | I != E; ++I) { |
| 118 | GlobalAlias *GA = cast<GlobalAlias>(ValueMap[I]); |
| 119 | GA->setLinkage(I->getLinkage()); |
| 120 | if (const Constant* C = I->getAliasee()) |
| 121 | GA->setAliasee(cast<Constant>(MapValue(C, ValueMap))); |
| 122 | } |
| 123 | |
Chris Lattner | 51cbcbf | 2002-11-20 20:47:41 +0000 | [diff] [blame] | 124 | return New; |
| 125 | } |