1 //===- CloneModule.cpp - Clone an entire module ---------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // 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/TypeSymbolTable.h"
19 #include "llvm/Constant.h"
20 #include "llvm/Transforms/Utils/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   // Create the value map that maps things from the old module over to the new
30   // module.
31   DenseMap<const Value*, Value*> ValueMap;
32   return CloneModule(M, ValueMap);
33 }
34 
35 Module *llvm::CloneModule(const Module *M,
36                           DenseMap<const Value*, Value*> &ValueMap) {
37   // First off, we need to create the new module...
38   Module *New = new Module(M->getModuleIdentifier());
39   New->setDataLayout(M->getDataLayout());
40   New->setTargetTriple(M->getTargetTriple());
41   New->setModuleInlineAsm(M->getModuleInlineAsm());
42 
43   // Copy all of the type symbol table entries over.
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);
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);
52 
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   //
57   for (Module::const_global_iterator I = M->global_begin(), E = M->global_end();
58        I != E; ++I) {
59     GlobalVariable *GV = new GlobalVariable(I->getType()->getElementType(),
60                                             false,
61                                             GlobalValue::ExternalLinkage, 0,
62                                             I->getName(), New);
63     GV->setAlignment(I->getAlignment());
64     ValueMap[I] = GV;
65   }
66 
67   // Loop over the functions in the module, making external functions as before
68   for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) {
69     Function *NF =
70       Function::Create(cast<FunctionType>(I->getType()->getElementType()),
71                        GlobalValue::ExternalLinkage, I->getName(), New);
72     NF->copyAttributesFrom(I);
73     ValueMap[I] = NF;
74   }
75 
76   // Loop over the aliases in the module
77   for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
78        I != E; ++I)
79     ValueMap[I] = new GlobalAlias(I->getType(), GlobalAlias::ExternalLinkage,
80                                   I->getName(), NULL, New);
81 
82   // Now that all of the things that global variable initializer can refer to
83   // have been created, loop through and copy the global variable referrers
84   // over...  We also set the attributes on the global now.
85   //
86   for (Module::const_global_iterator I = M->global_begin(), E = M->global_end();
87        I != E; ++I) {
88     GlobalVariable *GV = cast<GlobalVariable>(ValueMap[I]);
89     if (I->hasInitializer())
90       GV->setInitializer(cast<Constant>(MapValue(I->getInitializer(),
91                                                  ValueMap)));
92     GV->setLinkage(I->getLinkage());
93     GV->setThreadLocal(I->isThreadLocal());
94     GV->setConstant(I->isConstant());
95   }
96 
97   // Similarly, copy over function bodies now...
98   //
99   for (Module::const_iterator I = M->begin(), E = M->end(); I != E; ++I) {
100     Function *F = cast<Function>(ValueMap[I]);
101     if (!I->isDeclaration()) {
102       Function::arg_iterator DestI = F->arg_begin();
103       for (Function::const_arg_iterator J = I->arg_begin(); J != I->arg_end();
104            ++J) {
105         DestI->setName(J->getName());
106         ValueMap[J] = DestI++;
107       }
108 
109       std::vector<ReturnInst*> Returns;  // Ignore returns cloned...
110       CloneFunctionInto(F, I, ValueMap, Returns);
111     }
112 
113     F->setLinkage(I->getLinkage());
114   }
115 
116   // And aliases
117   for (Module::const_alias_iterator I = M->alias_begin(), E = M->alias_end();
118        I != E; ++I) {
119     GlobalAlias *GA = cast<GlobalAlias>(ValueMap[I]);
120     GA->setLinkage(I->getLinkage());
121     if (const Constant* C = I->getAliasee())
122       GA->setAliasee(cast<Constant>(MapValue(C, ValueMap)));
123   }
124 
125   return New;
126 }
127