LLVM: lib/Transforms/Utils/SplitModule.cpp Source File (original) (raw)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
40#include
41#include
42#include
43#include
44#include
45#include
46
47using namespace llvm;
48
49#define DEBUG_TYPE "split-module"
50
51namespace {
52
56
57bool compareClusters(const std::pair<unsigned, unsigned> &A,
58 const std::pair<unsigned, unsigned> &B) {
60 return A.second > B.second;
62}
63
64using BalancingQueueType =
65 std::priority_queue<std::pair<unsigned, unsigned>,
66 std::vector<std::pair<unsigned, unsigned>>,
67 decltype(compareClusters) *>;
68
69}
70
74
76 const GlobalValue *F = I->getParent()->getParent();
77 GVtoClusterMap.unionSets(GV, F);
79 GVtoClusterMap.unionSets(GV, GVU);
80 } else {
82 }
83}
84
85
88 for (const auto *U : V->users()) {
91 while (!Worklist.empty()) {
93
96 continue;
97 }
99 }
100 }
101}
102
106 GO = GI->getResolverFunction();
107 return GO;
108}
109
110
111
112
113
115 unsigned N) {
116
117
118
119 LLVM_DEBUG(dbgs() << "Partition module with (" << M.size()
120 << ") functions\n");
121 ClusterMapType GVtoClusterMap;
122 ComdatMembersType ComdatMembers;
123
124 auto recordGVSet = [&GVtoClusterMap, &ComdatMembers](GlobalValue &GV) {
125 if (GV.isDeclaration())
126 return;
127
128 if (!GV.hasName())
129 GV.setName("__llvmsplit_unnamed");
130
131
132
133
134
135 if (const Comdat *C = GV.getComdat()) {
136 auto &Member = ComdatMembers[C];
137 if (Member)
138 GVtoClusterMap.unionSets(Member, &GV);
139 else
140 Member = &GV;
141 }
142
143
144
146 if (&GV != Root)
147 GVtoClusterMap.unionSets(&GV, Root);
148
153 continue;
155 }
156 }
157
158 if (GV.hasLocalLinkage())
160 };
161
165
166
167
168 BalancingQueueType BalancingQueue(compareClusters);
169
170 for (unsigned i = 0; i < N; ++i)
171 BalancingQueue.push(std::make_pair(i, 0));
172
174
175
176
177 for (const auto &C : GVtoClusterMap) {
178 if (->isLeader())
179 continue;
180
181 unsigned CurrentClusterID = BalancingQueue.top().first;
182 unsigned CurrentClusterSize = BalancingQueue.top().second;
183 BalancingQueue.pop();
184
185 LLVM_DEBUG(dbgs() << "Root[" << CurrentClusterID << "] cluster_size("
186 << std::distance(GVtoClusterMap.member_begin(*C),
187 GVtoClusterMap.member_end())
188 << ") ----> " << C->getData()->getName() << "\n");
189
190 for (ClusterMapType::member_iterator MI = GVtoClusterMap.findLeader(*C);
191 MI != GVtoClusterMap.member_end(); ++MI) {
192 if (!Visited.insert(*MI).second)
193 continue;
195 << ((*MI)->hasLocalLinkage() ? " l " : " e ") << "\n");
197 ClusterIDMap[*MI] = CurrentClusterID;
198 CurrentClusterSize++;
199 }
200
201 BalancingQueue.push(std::make_pair(CurrentClusterID, CurrentClusterSize));
202 }
203}
204
209 }
210
211
212
214 GV->setName("__llvmsplit_unnamed");
215}
216
217
220 GV = Root;
221
224 Name = C->getName();
225 else
227
228
229
230
233 H.update(Name);
234 H.final(R);
235 return (R[0] | (R[1] << 8)) % N == I;
236}
237
240 function_ref<void(std::unique_ptr MPart)> ModuleCallback,
241 bool PreserveLocals, bool RoundRobin) {
242 if (!PreserveLocals) {
251 }
252
253
254
255 ClusterIDMapType ClusterIDMap;
257
258
259
260
261
262
263 if (RoundRobin) {
266 for (const auto &F : M.functions()) {
267 if (F.isDeclaration() ||
269 continue;
270 auto It = ClusterIDMap.find(&F);
271 if (It == ClusterIDMap.end())
273 else
274 ++ModuleFunctionCount[It->second];
275 }
276 BalancingQueueType BalancingQueue(compareClusters);
277 for (unsigned I = 0; I < N; ++I) {
278 if (auto It = ModuleFunctionCount.find(I);
279 It != ModuleFunctionCount.end())
280 BalancingQueue.push(*It);
281 else
282 BalancingQueue.push({I, 0});
283 }
284 for (const auto *const F : UnmappedFunctions) {
285 const unsigned I = BalancingQueue.top().first;
286 const unsigned Count = BalancingQueue.top().second;
287 BalancingQueue.pop();
288 ClusterIDMap.insert({F, I});
289 BalancingQueue.push({I, Count + 1});
290 }
291 }
292
293
294
295
296 for (unsigned I = 0; I < N; ++I) {
298 std::unique_ptr MPart(
300 if (auto It = ClusterIDMap.find(GV); It != ClusterIDMap.end())
301 return It->second == I;
302 else
304 }));
305 if (I != 0)
306 MPart->setModuleInlineAsm("");
307 ModuleCallback(std::move(MPart));
308 }
309}
assert(UImm &&(UImm !=~static_cast< T >(0)) &&"Invalid immediate!")
static GCRegistry::Add< ErlangGC > A("erlang", "erlang-compatible garbage collector")
static GCRegistry::Add< OcamlGC > B("ocaml", "ocaml 3.10-compatible GC")
This file contains the declarations for the subclasses of Constant, which represent the different fla...
This file defines the DenseMap class.
Generic implementation of equivalence classes through the use Tarjan's efficient union-find algorithm...
Module.h This file contains the declarations for the Module class.
This file defines the SmallPtrSet class.
This file defines the SmallVector class.
static bool isInPartition(const GlobalValue *GV, unsigned I, unsigned N)
Definition SplitModule.cpp:218
static void addNonConstUser(ClusterMapType &GVtoClusterMap, const GlobalValue *GV, const User *U)
Definition SplitModule.cpp:71
static void findPartitions(Module &M, ClusterIDMapType &ClusterIDMap, unsigned N)
Definition SplitModule.cpp:114
static void externalize(GlobalValue *GV)
Definition SplitModule.cpp:205
static const GlobalObject * getGVPartitioningRoot(const GlobalValue *GV)
Definition SplitModule.cpp:103
static void addAllGlobalValueUsers(ClusterMapType &GVtoClusterMap, const GlobalValue *GV, const Value *V)
Definition SplitModule.cpp:86
LLVM Basic Block Representation.
The address of a basic block.
static LLVM_ABI BlockAddress * lookup(const BasicBlock *BB)
Lookup an existing BlockAddress constant for the given BasicBlock.
LLVM_ABI bool isConstantUsed() const
Return true if the constant has users other than constant expressions and other dangling things.
iterator find(const_arg_type_t< KeyT > Val)
EquivalenceClasses - This represents a collection of equivalence classes and supports three efficient...
bool hasLocalLinkage() const
LLVM_ABI const Comdat * getComdat() const
void setLinkage(LinkageTypes LT)
LLVM_ABI const GlobalObject * getAliaseeObject() const
@ HiddenVisibility
The GV is hidden.
void setVisibility(VisibilityTypes V)
@ ExternalLinkage
Externally visible function.
A Module instance is used to store all the information related to an LLVM module.
std::pair< iterator, bool > insert(PtrType Ptr)
Inserts Ptr if and only if there is no element in the container equal to Ptr.
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
void append(ItTy in_start, ItTy in_end)
Add the specified range to the end of the SmallVector.
void push_back(const T &Elt)
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
StringRef - Represent a constant reference to a string, i.e.
LLVM Value Representation.
user_iterator user_begin()
LLVM_ABI void setName(const Twine &Name)
Change the name of the value.
LLVM_ABI StringRef getName() const
Return a constant reference to the value's name.
An efficient, type-erasing, non-owning reference to a callable.
This file contains the declaration of the Comdat class, which represents a single COMDAT in LLVM.
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
@ C
The default llvm calling convention, compatible with C.
This is an optimization pass for GlobalISel generic memory operations.
UnaryFunction for_each(R &&Range, UnaryFunction F)
Provide wrappers to std::for_each which take ranges instead of having to pass begin/end explicitly.
decltype(auto) dyn_cast(const From &Val)
dyn_cast - Return the argument parameter cast to the specified type.
auto dyn_cast_or_null(const Y &Val)
LLVM_ABI void SplitModule(Module &M, unsigned N, function_ref< void(std::unique_ptr< Module > MPart)> ModuleCallback, bool PreserveLocals=false, bool RoundRobin=false)
Splits the module M into N linkable partitions.
Definition SplitModule.cpp:238
LLVM_ABI raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
FunctionAddr VTableAddr Count
bool isa(const From &Val)
isa - Return true if the parameter to the template is an instance of one of the template type argu...
ValueMap< const Value *, WeakTrackingVH > ValueToValueMapTy
LLVM_ABI std::unique_ptr< Module > CloneModule(const Module &M)
Return an exact copy of the specified module.