1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
|
//===- CloneModule.cpp - Clone an entire module ---------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file implements the CloneModule interface which makes a copy of an
// entire module.
//
//===----------------------------------------------------------------------===//
#include "llvm/IR/Constant.h"
#include "llvm/IR/DerivedTypes.h"
#include "llvm/IR/Module.h"
#include "llvm/Transforms/Utils/Cloning.h"
#include "llvm/Transforms/Utils/ValueMapper.h"
using namespace llvm;
static void copyComdat(GlobalObject *Dst, const GlobalObject *Src) {
const Comdat *SC = Src->getComdat();
if (!SC)
return;
Comdat *DC = Dst->getParent()->getOrInsertComdat(SC->getName());
DC->setSelectionKind(SC->getSelectionKind());
Dst->setComdat(DC);
}
/// This is not as easy as it might seem because we have to worry about making
/// copies of global variables and functions, and making their (initializers and
/// references, respectively) refer to the right globals.
///
std::unique_ptr<Module> llvm::CloneModule(const Module &M) {
// Create the value map that maps things from the old module over to the new
// module.
ValueToValueMapTy VMap;
return CloneModule(M, VMap);
}
std::unique_ptr<Module> llvm::CloneModule(const Module &M,
ValueToValueMapTy &VMap) {
return CloneModule(M, VMap, [](const GlobalValue *GV) { return true; });
}
std::unique_ptr<Module> llvm::CloneModule(
const Module &M, ValueToValueMapTy &VMap,
function_ref<bool(const GlobalValue *)> ShouldCloneDefinition) {
// First off, we need to create the new module.
std::unique_ptr<Module> New =
std::make_unique<Module>(M.getModuleIdentifier(), M.getContext());
New->setSourceFileName(M.getSourceFileName());
New->setDataLayout(M.getDataLayout());
New->setTargetTriple(M.getTargetTriple());
New->setModuleInlineAsm(M.getModuleInlineAsm());
// Loop over all of the global variables, making corresponding globals in the
// new module. Here we add them to the VMap and to the new Module. We
// don't worry about attributes or initializers, they will come later.
//
for (const GlobalVariable &I : M.globals()) {
GlobalVariable *NewGV = new GlobalVariable(
*New, I.getValueType(), I.isConstant(), I.getLinkage(),
(Constant *)nullptr, I.getName(), (GlobalVariable *)nullptr,
I.getThreadLocalMode(), I.getType()->getAddressSpace());
NewGV->copyAttributesFrom(&I);
VMap[&I] = NewGV;
}
// Loop over the functions in the module, making external functions as before
for (const Function &I : M) {
Function *NF =
Function::Create(cast<FunctionType>(I.getValueType()), I.getLinkage(),
I.getAddressSpace(), I.getName(), New.get());
NF->copyAttributesFrom(&I);
VMap[&I] = NF;
}
// Loop over the aliases in the module
for (const GlobalAlias &I : M.aliases()) {
if (!ShouldCloneDefinition(&I)) {
// An alias cannot act as an external reference, so we need to create
// either a function or a global variable depending on the value type.
// FIXME: Once pointee types are gone we can probably pick one or the
// other.
GlobalValue *GV;
if (I.getValueType()->isFunctionTy())
GV = Function::Create(cast<FunctionType>(I.getValueType()),
GlobalValue::ExternalLinkage, I.getAddressSpace(),
I.getName(), New.get());
else
GV = new GlobalVariable(*New, I.getValueType(), false,
GlobalValue::ExternalLinkage, nullptr,
I.getName(), nullptr, I.getThreadLocalMode(),
I.getType()->getAddressSpace());
VMap[&I] = GV;
// We do not copy attributes (mainly because copying between different
// kinds of globals is forbidden), but this is generally not required for
// correctness.
continue;
}
auto *GA = GlobalAlias::create(I.getValueType(),
I.getType()->getPointerAddressSpace(),
I.getLinkage(), I.getName(), New.get());
GA->copyAttributesFrom(&I);
VMap[&I] = GA;
}
// Now that all of the things that global variable initializer can refer to
// have been created, loop through and copy the global variable referrers
// over... We also set the attributes on the global now.
//
for (const GlobalVariable &G : M.globals()) {
GlobalVariable *GV = cast<GlobalVariable>(VMap[&G]);
SmallVector<std::pair<unsigned, MDNode *>, 1> MDs;
G.getAllMetadata(MDs);
for (auto MD : MDs)
GV->addMetadata(MD.first, *MapMetadata(MD.second, VMap));
if (G.isDeclaration())
continue;
if (!ShouldCloneDefinition(&G)) {
// Skip after setting the correct linkage for an external reference.
GV->setLinkage(GlobalValue::ExternalLinkage);
continue;
}
if (G.hasInitializer())
GV->setInitializer(MapValue(G.getInitializer(), VMap));
copyComdat(GV, &G);
}
// Similarly, copy over function bodies now...
//
for (const Function &I : M) {
Function *F = cast<Function>(VMap[&I]);
if (I.isDeclaration()) {
// Copy over metadata for declarations since we're not doing it below in
// CloneFunctionInto().
SmallVector<std::pair<unsigned, MDNode *>, 1> MDs;
I.getAllMetadata(MDs);
for (auto MD : MDs)
F->addMetadata(MD.first, *MapMetadata(MD.second, VMap));
continue;
}
if (!ShouldCloneDefinition(&I)) {
// Skip after setting the correct linkage for an external reference.
F->setLinkage(GlobalValue::ExternalLinkage);
// Personality function is not valid on a declaration.
F->setPersonalityFn(nullptr);
continue;
}
Function::arg_iterator DestI = F->arg_begin();
for (const Argument &J : I.args()) {
DestI->setName(J.getName());
VMap[&J] = &*DestI++;
}
SmallVector<ReturnInst *, 8> Returns; // Ignore returns cloned.
CloneFunctionInto(F, &I, VMap, CloneFunctionChangeType::ClonedModule,
Returns);
if (I.hasPersonalityFn())
F->setPersonalityFn(MapValue(I.getPersonalityFn(), VMap));
copyComdat(F, &I);
}
// And aliases
for (const GlobalAlias &I : M.aliases()) {
// We already dealt with undefined aliases above.
if (!ShouldCloneDefinition(&I))
continue;
GlobalAlias *GA = cast<GlobalAlias>(VMap[&I]);
if (const Constant *C = I.getAliasee())
GA->setAliasee(MapValue(C, VMap));
}
// And named metadata....
for (const NamedMDNode &NMD : M.named_metadata()) {
NamedMDNode *NewNMD = New->getOrInsertNamedMetadata(NMD.getName());
for (unsigned i = 0, e = NMD.getNumOperands(); i != e; ++i)
NewNMD->addOperand(MapMetadata(NMD.getOperand(i), VMap));
}
return New;
}
extern "C" {
LLVMModuleRef LLVMCloneModule(LLVMModuleRef M) {
return wrap(CloneModule(*unwrap(M)).release());
}
}
|
