File: | build/llvm-toolchain-snapshot-15~++20220420111733+e13d2efed663/llvm/lib/Analysis/CallGraphSCCPass.cpp |
Warning: | line 154, column 11 Value stored to 'InstrCount' is never read |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | //===- CallGraphSCCPass.cpp - Pass that operates BU on call graph ---------===// |
2 | // |
3 | // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. |
4 | // See https://llvm.org/LICENSE.txt for license information. |
5 | // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception |
6 | // |
7 | //===----------------------------------------------------------------------===// |
8 | // |
9 | // This file implements the CallGraphSCCPass class, which is used for passes |
10 | // which are implemented as bottom-up traversals on the call graph. Because |
11 | // there may be cycles in the call graph, passes of this type operate on the |
12 | // call-graph in SCC order: that is, they process function bottom-up, except for |
13 | // recursive functions, which they process all at once. |
14 | // |
15 | //===----------------------------------------------------------------------===// |
16 | |
17 | #include "llvm/Analysis/CallGraphSCCPass.h" |
18 | #include "llvm/ADT/DenseMap.h" |
19 | #include "llvm/ADT/SCCIterator.h" |
20 | #include "llvm/ADT/Statistic.h" |
21 | #include "llvm/Analysis/CallGraph.h" |
22 | #include "llvm/IR/AbstractCallSite.h" |
23 | #include "llvm/IR/Function.h" |
24 | #include "llvm/IR/Intrinsics.h" |
25 | #include "llvm/IR/LLVMContext.h" |
26 | #include "llvm/IR/LegacyPassManagers.h" |
27 | #include "llvm/IR/Module.h" |
28 | #include "llvm/IR/OptBisect.h" |
29 | #include "llvm/IR/PassTimingInfo.h" |
30 | #include "llvm/IR/PrintPasses.h" |
31 | #include "llvm/Pass.h" |
32 | #include "llvm/Support/CommandLine.h" |
33 | #include "llvm/Support/Debug.h" |
34 | #include "llvm/Support/Timer.h" |
35 | #include "llvm/Support/raw_ostream.h" |
36 | #include <cassert> |
37 | #include <string> |
38 | #include <utility> |
39 | #include <vector> |
40 | |
41 | using namespace llvm; |
42 | |
43 | #define DEBUG_TYPE"cgscc-passmgr" "cgscc-passmgr" |
44 | |
45 | namespace llvm { |
46 | cl::opt<unsigned> MaxDevirtIterations("max-devirt-iterations", cl::ReallyHidden, |
47 | cl::init(4)); |
48 | } |
49 | |
50 | STATISTIC(MaxSCCIterations, "Maximum CGSCCPassMgr iterations on one SCC")static llvm::Statistic MaxSCCIterations = {"cgscc-passmgr", "MaxSCCIterations" , "Maximum CGSCCPassMgr iterations on one SCC"}; |
51 | |
52 | //===----------------------------------------------------------------------===// |
53 | // CGPassManager |
54 | // |
55 | /// CGPassManager manages FPPassManagers and CallGraphSCCPasses. |
56 | |
57 | namespace { |
58 | |
59 | class CGPassManager : public ModulePass, public PMDataManager { |
60 | public: |
61 | static char ID; |
62 | |
63 | explicit CGPassManager() : ModulePass(ID) {} |
64 | |
65 | /// Execute all of the passes scheduled for execution. Keep track of |
66 | /// whether any of the passes modifies the module, and if so, return true. |
67 | bool runOnModule(Module &M) override; |
68 | |
69 | using ModulePass::doInitialization; |
70 | using ModulePass::doFinalization; |
71 | |
72 | bool doInitialization(CallGraph &CG); |
73 | bool doFinalization(CallGraph &CG); |
74 | |
75 | /// Pass Manager itself does not invalidate any analysis info. |
76 | void getAnalysisUsage(AnalysisUsage &Info) const override { |
77 | // CGPassManager walks SCC and it needs CallGraph. |
78 | Info.addRequired<CallGraphWrapperPass>(); |
79 | Info.setPreservesAll(); |
80 | } |
81 | |
82 | StringRef getPassName() const override { return "CallGraph Pass Manager"; } |
83 | |
84 | PMDataManager *getAsPMDataManager() override { return this; } |
85 | Pass *getAsPass() override { return this; } |
86 | |
87 | // Print passes managed by this manager |
88 | void dumpPassStructure(unsigned Offset) override { |
89 | errs().indent(Offset*2) << "Call Graph SCC Pass Manager\n"; |
90 | for (unsigned Index = 0; Index < getNumContainedPasses(); ++Index) { |
91 | Pass *P = getContainedPass(Index); |
92 | P->dumpPassStructure(Offset + 1); |
93 | dumpLastUses(P, Offset+1); |
94 | } |
95 | } |
96 | |
97 | Pass *getContainedPass(unsigned N) { |
98 | assert(N < PassVector.size() && "Pass number out of range!")(static_cast <bool> (N < PassVector.size() && "Pass number out of range!") ? void (0) : __assert_fail ("N < PassVector.size() && \"Pass number out of range!\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 98, __extension__ __PRETTY_FUNCTION__)); |
99 | return static_cast<Pass *>(PassVector[N]); |
100 | } |
101 | |
102 | PassManagerType getPassManagerType() const override { |
103 | return PMT_CallGraphPassManager; |
104 | } |
105 | |
106 | private: |
107 | bool RunAllPassesOnSCC(CallGraphSCC &CurSCC, CallGraph &CG, |
108 | bool &DevirtualizedCall); |
109 | |
110 | bool RunPassOnSCC(Pass *P, CallGraphSCC &CurSCC, |
111 | CallGraph &CG, bool &CallGraphUpToDate, |
112 | bool &DevirtualizedCall); |
113 | bool RefreshCallGraph(const CallGraphSCC &CurSCC, CallGraph &CG, |
114 | bool IsCheckingMode); |
115 | }; |
116 | |
117 | } // end anonymous namespace. |
118 | |
119 | char CGPassManager::ID = 0; |
120 | |
121 | bool CGPassManager::RunPassOnSCC(Pass *P, CallGraphSCC &CurSCC, |
122 | CallGraph &CG, bool &CallGraphUpToDate, |
123 | bool &DevirtualizedCall) { |
124 | bool Changed = false; |
125 | PMDataManager *PM = P->getAsPMDataManager(); |
126 | Module &M = CG.getModule(); |
127 | |
128 | if (!PM) { |
129 | CallGraphSCCPass *CGSP = (CallGraphSCCPass *)P; |
130 | if (!CallGraphUpToDate) { |
131 | DevirtualizedCall |= RefreshCallGraph(CurSCC, CG, false); |
132 | CallGraphUpToDate = true; |
133 | } |
134 | |
135 | { |
136 | unsigned InstrCount, SCCCount = 0; |
137 | StringMap<std::pair<unsigned, unsigned>> FunctionToInstrCount; |
138 | bool EmitICRemark = M.shouldEmitInstrCountChangedRemark(); |
139 | TimeRegion PassTimer(getPassTimer(CGSP)); |
140 | if (EmitICRemark) |
141 | InstrCount = initSizeRemarkInfo(M, FunctionToInstrCount); |
142 | Changed = CGSP->runOnSCC(CurSCC); |
143 | |
144 | if (EmitICRemark) { |
145 | // FIXME: Add getInstructionCount to CallGraphSCC. |
146 | SCCCount = M.getInstructionCount(); |
147 | // Is there a difference in the number of instructions in the module? |
148 | if (SCCCount != InstrCount) { |
149 | // Yep. Emit a remark and update InstrCount. |
150 | int64_t Delta = |
151 | static_cast<int64_t>(SCCCount) - static_cast<int64_t>(InstrCount); |
152 | emitInstrCountChangedRemark(P, M, Delta, InstrCount, |
153 | FunctionToInstrCount); |
154 | InstrCount = SCCCount; |
Value stored to 'InstrCount' is never read | |
155 | } |
156 | } |
157 | } |
158 | |
159 | // After the CGSCCPass is done, when assertions are enabled, use |
160 | // RefreshCallGraph to verify that the callgraph was correctly updated. |
161 | #ifndef NDEBUG |
162 | if (Changed) |
163 | RefreshCallGraph(CurSCC, CG, true); |
164 | #endif |
165 | |
166 | return Changed; |
167 | } |
168 | |
169 | assert(PM->getPassManagerType() == PMT_FunctionPassManager &&(static_cast <bool> (PM->getPassManagerType() == PMT_FunctionPassManager && "Invalid CGPassManager member") ? void (0) : __assert_fail ("PM->getPassManagerType() == PMT_FunctionPassManager && \"Invalid CGPassManager member\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 170, __extension__ __PRETTY_FUNCTION__)) |
170 | "Invalid CGPassManager member")(static_cast <bool> (PM->getPassManagerType() == PMT_FunctionPassManager && "Invalid CGPassManager member") ? void (0) : __assert_fail ("PM->getPassManagerType() == PMT_FunctionPassManager && \"Invalid CGPassManager member\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 170, __extension__ __PRETTY_FUNCTION__)); |
171 | FPPassManager *FPP = (FPPassManager*)P; |
172 | |
173 | // Run pass P on all functions in the current SCC. |
174 | for (CallGraphNode *CGN : CurSCC) { |
175 | if (Function *F = CGN->getFunction()) { |
176 | dumpPassInfo(P, EXECUTION_MSG, ON_FUNCTION_MSG, F->getName()); |
177 | { |
178 | TimeRegion PassTimer(getPassTimer(FPP)); |
179 | Changed |= FPP->runOnFunction(*F); |
180 | } |
181 | F->getContext().yield(); |
182 | } |
183 | } |
184 | |
185 | // The function pass(es) modified the IR, they may have clobbered the |
186 | // callgraph. |
187 | if (Changed && CallGraphUpToDate) { |
188 | LLVM_DEBUG(dbgs() << "CGSCCPASSMGR: Pass Dirtied SCC: " << P->getPassName()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { dbgs() << "CGSCCPASSMGR: Pass Dirtied SCC: " << P->getPassName() << '\n'; } } while (false ) |
189 | << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { dbgs() << "CGSCCPASSMGR: Pass Dirtied SCC: " << P->getPassName() << '\n'; } } while (false ); |
190 | CallGraphUpToDate = false; |
191 | } |
192 | return Changed; |
193 | } |
194 | |
195 | /// Scan the functions in the specified CFG and resync the |
196 | /// callgraph with the call sites found in it. This is used after |
197 | /// FunctionPasses have potentially munged the callgraph, and can be used after |
198 | /// CallGraphSCC passes to verify that they correctly updated the callgraph. |
199 | /// |
200 | /// This function returns true if it devirtualized an existing function call, |
201 | /// meaning it turned an indirect call into a direct call. This happens when |
202 | /// a function pass like GVN optimizes away stuff feeding the indirect call. |
203 | /// This never happens in checking mode. |
204 | bool CGPassManager::RefreshCallGraph(const CallGraphSCC &CurSCC, CallGraph &CG, |
205 | bool CheckingMode) { |
206 | DenseMap<Value *, CallGraphNode *> Calls; |
207 | |
208 | LLVM_DEBUG(dbgs() << "CGSCCPASSMGR: Refreshing SCC with " << CurSCC.size()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { dbgs() << "CGSCCPASSMGR: Refreshing SCC with " << CurSCC.size() << " nodes:\n"; for (CallGraphNode *CGN : CurSCC) CGN->dump();; } } while (false) |
209 | << " nodes:\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { dbgs() << "CGSCCPASSMGR: Refreshing SCC with " << CurSCC.size() << " nodes:\n"; for (CallGraphNode *CGN : CurSCC) CGN->dump();; } } while (false) |
210 | for (CallGraphNode *CGNdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { dbgs() << "CGSCCPASSMGR: Refreshing SCC with " << CurSCC.size() << " nodes:\n"; for (CallGraphNode *CGN : CurSCC) CGN->dump();; } } while (false) |
211 | : CurSCC) CGN->dump();)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { dbgs() << "CGSCCPASSMGR: Refreshing SCC with " << CurSCC.size() << " nodes:\n"; for (CallGraphNode *CGN : CurSCC) CGN->dump();; } } while (false); |
212 | |
213 | bool MadeChange = false; |
214 | bool DevirtualizedCall = false; |
215 | |
216 | // Scan all functions in the SCC. |
217 | unsigned FunctionNo = 0; |
218 | for (CallGraphSCC::iterator SCCIdx = CurSCC.begin(), E = CurSCC.end(); |
219 | SCCIdx != E; ++SCCIdx, ++FunctionNo) { |
220 | CallGraphNode *CGN = *SCCIdx; |
221 | Function *F = CGN->getFunction(); |
222 | if (!F || F->isDeclaration()) continue; |
223 | |
224 | // Walk the function body looking for call sites. Sync up the call sites in |
225 | // CGN with those actually in the function. |
226 | |
227 | // Keep track of the number of direct and indirect calls that were |
228 | // invalidated and removed. |
229 | unsigned NumDirectRemoved = 0, NumIndirectRemoved = 0; |
230 | |
231 | CallGraphNode::iterator CGNEnd = CGN->end(); |
232 | |
233 | auto RemoveAndCheckForDone = [&](CallGraphNode::iterator I) { |
234 | // Just remove the edge from the set of callees, keep track of whether |
235 | // I points to the last element of the vector. |
236 | bool WasLast = I + 1 == CGNEnd; |
237 | CGN->removeCallEdge(I); |
238 | |
239 | // If I pointed to the last element of the vector, we have to bail out: |
240 | // iterator checking rejects comparisons of the resultant pointer with |
241 | // end. |
242 | if (WasLast) |
243 | return true; |
244 | |
245 | CGNEnd = CGN->end(); |
246 | return false; |
247 | }; |
248 | |
249 | // Get the set of call sites currently in the function. |
250 | for (CallGraphNode::iterator I = CGN->begin(); I != CGNEnd;) { |
251 | // Delete "reference" call records that do not have call instruction. We |
252 | // reinsert them as needed later. However, keep them in checking mode. |
253 | if (!I->first) { |
254 | if (CheckingMode) { |
255 | ++I; |
256 | continue; |
257 | } |
258 | if (RemoveAndCheckForDone(I)) |
259 | break; |
260 | continue; |
261 | } |
262 | |
263 | // If this call site is null, then the function pass deleted the call |
264 | // entirely and the WeakTrackingVH nulled it out. |
265 | auto *Call = dyn_cast_or_null<CallBase>(*I->first); |
266 | if (!Call || |
267 | // If we've already seen this call site, then the FunctionPass RAUW'd |
268 | // one call with another, which resulted in two "uses" in the edge |
269 | // list of the same call. |
270 | Calls.count(Call) || |
271 | |
272 | // If the call edge is not from a call or invoke, or it is a |
273 | // instrinsic call, then the function pass RAUW'd a call with |
274 | // another value. This can happen when constant folding happens |
275 | // of well known functions etc. |
276 | (Call->getCalledFunction() && |
277 | Call->getCalledFunction()->isIntrinsic() && |
278 | Intrinsic::isLeaf(Call->getCalledFunction()->getIntrinsicID()))) { |
279 | assert(!CheckingMode &&(static_cast <bool> (!CheckingMode && "CallGraphSCCPass did not update the CallGraph correctly!" ) ? void (0) : __assert_fail ("!CheckingMode && \"CallGraphSCCPass did not update the CallGraph correctly!\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 280, __extension__ __PRETTY_FUNCTION__)) |
280 | "CallGraphSCCPass did not update the CallGraph correctly!")(static_cast <bool> (!CheckingMode && "CallGraphSCCPass did not update the CallGraph correctly!" ) ? void (0) : __assert_fail ("!CheckingMode && \"CallGraphSCCPass did not update the CallGraph correctly!\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 280, __extension__ __PRETTY_FUNCTION__)); |
281 | |
282 | // If this was an indirect call site, count it. |
283 | if (!I->second->getFunction()) |
284 | ++NumIndirectRemoved; |
285 | else |
286 | ++NumDirectRemoved; |
287 | |
288 | if (RemoveAndCheckForDone(I)) |
289 | break; |
290 | continue; |
291 | } |
292 | |
293 | assert(!Calls.count(Call) && "Call site occurs in node multiple times")(static_cast <bool> (!Calls.count(Call) && "Call site occurs in node multiple times" ) ? void (0) : __assert_fail ("!Calls.count(Call) && \"Call site occurs in node multiple times\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 293, __extension__ __PRETTY_FUNCTION__)); |
294 | |
295 | if (Call) { |
296 | Function *Callee = Call->getCalledFunction(); |
297 | // Ignore intrinsics because they're not really function calls. |
298 | if (!Callee || !(Callee->isIntrinsic())) |
299 | Calls.insert(std::make_pair(Call, I->second)); |
300 | } |
301 | ++I; |
302 | } |
303 | |
304 | // Loop over all of the instructions in the function, getting the callsites. |
305 | // Keep track of the number of direct/indirect calls added. |
306 | unsigned NumDirectAdded = 0, NumIndirectAdded = 0; |
307 | |
308 | for (BasicBlock &BB : *F) |
309 | for (Instruction &I : BB) { |
310 | auto *Call = dyn_cast<CallBase>(&I); |
311 | if (!Call) |
312 | continue; |
313 | Function *Callee = Call->getCalledFunction(); |
314 | if (Callee && Callee->isIntrinsic()) |
315 | continue; |
316 | |
317 | // If we are not in checking mode, insert potential callback calls as |
318 | // references. This is not a requirement but helps to iterate over the |
319 | // functions in the right order. |
320 | if (!CheckingMode) { |
321 | forEachCallbackFunction(*Call, [&](Function *CB) { |
322 | CGN->addCalledFunction(nullptr, CG.getOrInsertFunction(CB)); |
323 | }); |
324 | } |
325 | |
326 | // If this call site already existed in the callgraph, just verify it |
327 | // matches up to expectations and remove it from Calls. |
328 | DenseMap<Value *, CallGraphNode *>::iterator ExistingIt = |
329 | Calls.find(Call); |
330 | if (ExistingIt != Calls.end()) { |
331 | CallGraphNode *ExistingNode = ExistingIt->second; |
332 | |
333 | // Remove from Calls since we have now seen it. |
334 | Calls.erase(ExistingIt); |
335 | |
336 | // Verify that the callee is right. |
337 | if (ExistingNode->getFunction() == Call->getCalledFunction()) |
338 | continue; |
339 | |
340 | // If we are in checking mode, we are not allowed to actually mutate |
341 | // the callgraph. If this is a case where we can infer that the |
342 | // callgraph is less precise than it could be (e.g. an indirect call |
343 | // site could be turned direct), don't reject it in checking mode, and |
344 | // don't tweak it to be more precise. |
345 | if (CheckingMode && Call->getCalledFunction() && |
346 | ExistingNode->getFunction() == nullptr) |
347 | continue; |
348 | |
349 | assert(!CheckingMode &&(static_cast <bool> (!CheckingMode && "CallGraphSCCPass did not update the CallGraph correctly!" ) ? void (0) : __assert_fail ("!CheckingMode && \"CallGraphSCCPass did not update the CallGraph correctly!\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 350, __extension__ __PRETTY_FUNCTION__)) |
350 | "CallGraphSCCPass did not update the CallGraph correctly!")(static_cast <bool> (!CheckingMode && "CallGraphSCCPass did not update the CallGraph correctly!" ) ? void (0) : __assert_fail ("!CheckingMode && \"CallGraphSCCPass did not update the CallGraph correctly!\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 350, __extension__ __PRETTY_FUNCTION__)); |
351 | |
352 | // If not, we either went from a direct call to indirect, indirect to |
353 | // direct, or direct to different direct. |
354 | CallGraphNode *CalleeNode; |
355 | if (Function *Callee = Call->getCalledFunction()) { |
356 | CalleeNode = CG.getOrInsertFunction(Callee); |
357 | // Keep track of whether we turned an indirect call into a direct |
358 | // one. |
359 | if (!ExistingNode->getFunction()) { |
360 | DevirtualizedCall = true; |
361 | LLVM_DEBUG(dbgs() << " CGSCCPASSMGR: Devirtualized call to '"do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { dbgs() << " CGSCCPASSMGR: Devirtualized call to '" << Callee->getName() << "'\n"; } } while (false ) |
362 | << Callee->getName() << "'\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { dbgs() << " CGSCCPASSMGR: Devirtualized call to '" << Callee->getName() << "'\n"; } } while (false ); |
363 | } |
364 | } else { |
365 | CalleeNode = CG.getCallsExternalNode(); |
366 | } |
367 | |
368 | // Update the edge target in CGN. |
369 | CGN->replaceCallEdge(*Call, *Call, CalleeNode); |
370 | MadeChange = true; |
371 | continue; |
372 | } |
373 | |
374 | assert(!CheckingMode &&(static_cast <bool> (!CheckingMode && "CallGraphSCCPass did not update the CallGraph correctly!" ) ? void (0) : __assert_fail ("!CheckingMode && \"CallGraphSCCPass did not update the CallGraph correctly!\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 375, __extension__ __PRETTY_FUNCTION__)) |
375 | "CallGraphSCCPass did not update the CallGraph correctly!")(static_cast <bool> (!CheckingMode && "CallGraphSCCPass did not update the CallGraph correctly!" ) ? void (0) : __assert_fail ("!CheckingMode && \"CallGraphSCCPass did not update the CallGraph correctly!\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 375, __extension__ __PRETTY_FUNCTION__)); |
376 | |
377 | // If the call site didn't exist in the CGN yet, add it. |
378 | CallGraphNode *CalleeNode; |
379 | if (Function *Callee = Call->getCalledFunction()) { |
380 | CalleeNode = CG.getOrInsertFunction(Callee); |
381 | ++NumDirectAdded; |
382 | } else { |
383 | CalleeNode = CG.getCallsExternalNode(); |
384 | ++NumIndirectAdded; |
385 | } |
386 | |
387 | CGN->addCalledFunction(Call, CalleeNode); |
388 | MadeChange = true; |
389 | } |
390 | |
391 | // We scanned the old callgraph node, removing invalidated call sites and |
392 | // then added back newly found call sites. One thing that can happen is |
393 | // that an old indirect call site was deleted and replaced with a new direct |
394 | // call. In this case, we have devirtualized a call, and CGSCCPM would like |
395 | // to iteratively optimize the new code. Unfortunately, we don't really |
396 | // have a great way to detect when this happens. As an approximation, we |
397 | // just look at whether the number of indirect calls is reduced and the |
398 | // number of direct calls is increased. There are tons of ways to fool this |
399 | // (e.g. DCE'ing an indirect call and duplicating an unrelated block with a |
400 | // direct call) but this is close enough. |
401 | if (NumIndirectRemoved > NumIndirectAdded && |
402 | NumDirectRemoved < NumDirectAdded) |
403 | DevirtualizedCall = true; |
404 | |
405 | // After scanning this function, if we still have entries in callsites, then |
406 | // they are dangling pointers. WeakTrackingVH should save us for this, so |
407 | // abort if |
408 | // this happens. |
409 | assert(Calls.empty() && "Dangling pointers found in call sites map")(static_cast <bool> (Calls.empty() && "Dangling pointers found in call sites map" ) ? void (0) : __assert_fail ("Calls.empty() && \"Dangling pointers found in call sites map\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 409, __extension__ __PRETTY_FUNCTION__)); |
410 | |
411 | // Periodically do an explicit clear to remove tombstones when processing |
412 | // large scc's. |
413 | if ((FunctionNo & 15) == 15) |
414 | Calls.clear(); |
415 | } |
416 | |
417 | LLVM_DEBUG(if (MadeChange) {do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { if (MadeChange) { dbgs() << "CGSCCPASSMGR: Refreshed SCC is now:\n" ; for (CallGraphNode *CGN : CurSCC) CGN->dump(); if (DevirtualizedCall ) dbgs() << "CGSCCPASSMGR: Refresh devirtualized a call!\n" ; } else { dbgs() << "CGSCCPASSMGR: SCC Refresh didn't change call graph.\n" ; }; } } while (false) |
418 | dbgs() << "CGSCCPASSMGR: Refreshed SCC is now:\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { if (MadeChange) { dbgs() << "CGSCCPASSMGR: Refreshed SCC is now:\n" ; for (CallGraphNode *CGN : CurSCC) CGN->dump(); if (DevirtualizedCall ) dbgs() << "CGSCCPASSMGR: Refresh devirtualized a call!\n" ; } else { dbgs() << "CGSCCPASSMGR: SCC Refresh didn't change call graph.\n" ; }; } } while (false) |
419 | for (CallGraphNode *CGN : CurSCC)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { if (MadeChange) { dbgs() << "CGSCCPASSMGR: Refreshed SCC is now:\n" ; for (CallGraphNode *CGN : CurSCC) CGN->dump(); if (DevirtualizedCall ) dbgs() << "CGSCCPASSMGR: Refresh devirtualized a call!\n" ; } else { dbgs() << "CGSCCPASSMGR: SCC Refresh didn't change call graph.\n" ; }; } } while (false) |
420 | CGN->dump();do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { if (MadeChange) { dbgs() << "CGSCCPASSMGR: Refreshed SCC is now:\n" ; for (CallGraphNode *CGN : CurSCC) CGN->dump(); if (DevirtualizedCall ) dbgs() << "CGSCCPASSMGR: Refresh devirtualized a call!\n" ; } else { dbgs() << "CGSCCPASSMGR: SCC Refresh didn't change call graph.\n" ; }; } } while (false) |
421 | if (DevirtualizedCall)do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { if (MadeChange) { dbgs() << "CGSCCPASSMGR: Refreshed SCC is now:\n" ; for (CallGraphNode *CGN : CurSCC) CGN->dump(); if (DevirtualizedCall ) dbgs() << "CGSCCPASSMGR: Refresh devirtualized a call!\n" ; } else { dbgs() << "CGSCCPASSMGR: SCC Refresh didn't change call graph.\n" ; }; } } while (false) |
422 | dbgs() << "CGSCCPASSMGR: Refresh devirtualized a call!\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { if (MadeChange) { dbgs() << "CGSCCPASSMGR: Refreshed SCC is now:\n" ; for (CallGraphNode *CGN : CurSCC) CGN->dump(); if (DevirtualizedCall ) dbgs() << "CGSCCPASSMGR: Refresh devirtualized a call!\n" ; } else { dbgs() << "CGSCCPASSMGR: SCC Refresh didn't change call graph.\n" ; }; } } while (false) |
423 | } else {do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { if (MadeChange) { dbgs() << "CGSCCPASSMGR: Refreshed SCC is now:\n" ; for (CallGraphNode *CGN : CurSCC) CGN->dump(); if (DevirtualizedCall ) dbgs() << "CGSCCPASSMGR: Refresh devirtualized a call!\n" ; } else { dbgs() << "CGSCCPASSMGR: SCC Refresh didn't change call graph.\n" ; }; } } while (false) |
424 | dbgs() << "CGSCCPASSMGR: SCC Refresh didn't change call graph.\n";do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { if (MadeChange) { dbgs() << "CGSCCPASSMGR: Refreshed SCC is now:\n" ; for (CallGraphNode *CGN : CurSCC) CGN->dump(); if (DevirtualizedCall ) dbgs() << "CGSCCPASSMGR: Refresh devirtualized a call!\n" ; } else { dbgs() << "CGSCCPASSMGR: SCC Refresh didn't change call graph.\n" ; }; } } while (false) |
425 | })do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { if (MadeChange) { dbgs() << "CGSCCPASSMGR: Refreshed SCC is now:\n" ; for (CallGraphNode *CGN : CurSCC) CGN->dump(); if (DevirtualizedCall ) dbgs() << "CGSCCPASSMGR: Refresh devirtualized a call!\n" ; } else { dbgs() << "CGSCCPASSMGR: SCC Refresh didn't change call graph.\n" ; }; } } while (false); |
426 | (void)MadeChange; |
427 | |
428 | return DevirtualizedCall; |
429 | } |
430 | |
431 | /// Execute the body of the entire pass manager on the specified SCC. |
432 | /// This keeps track of whether a function pass devirtualizes |
433 | /// any calls and returns it in DevirtualizedCall. |
434 | bool CGPassManager::RunAllPassesOnSCC(CallGraphSCC &CurSCC, CallGraph &CG, |
435 | bool &DevirtualizedCall) { |
436 | bool Changed = false; |
437 | |
438 | // Keep track of whether the callgraph is known to be up-to-date or not. |
439 | // The CGSSC pass manager runs two types of passes: |
440 | // CallGraphSCC Passes and other random function passes. Because other |
441 | // random function passes are not CallGraph aware, they may clobber the |
442 | // call graph by introducing new calls or deleting other ones. This flag |
443 | // is set to false when we run a function pass so that we know to clean up |
444 | // the callgraph when we need to run a CGSCCPass again. |
445 | bool CallGraphUpToDate = true; |
446 | |
447 | // Run all passes on current SCC. |
448 | for (unsigned PassNo = 0, e = getNumContainedPasses(); |
449 | PassNo != e; ++PassNo) { |
450 | Pass *P = getContainedPass(PassNo); |
451 | |
452 | // If we're in -debug-pass=Executions mode, construct the SCC node list, |
453 | // otherwise avoid constructing this string as it is expensive. |
454 | if (isPassDebuggingExecutionsOrMore()) { |
455 | std::string Functions; |
456 | #ifndef NDEBUG |
457 | raw_string_ostream OS(Functions); |
458 | ListSeparator LS; |
459 | for (const CallGraphNode *CGN : CurSCC) { |
460 | OS << LS; |
461 | CGN->print(OS); |
462 | } |
463 | OS.flush(); |
464 | #endif |
465 | dumpPassInfo(P, EXECUTION_MSG, ON_CG_MSG, Functions); |
466 | } |
467 | dumpRequiredSet(P); |
468 | |
469 | initializeAnalysisImpl(P); |
470 | |
471 | #ifdef EXPENSIVE_CHECKS |
472 | uint64_t RefHash = P->structuralHash(CG.getModule()); |
473 | #endif |
474 | |
475 | // Actually run this pass on the current SCC. |
476 | bool LocalChanged = |
477 | RunPassOnSCC(P, CurSCC, CG, CallGraphUpToDate, DevirtualizedCall); |
478 | |
479 | Changed |= LocalChanged; |
480 | |
481 | #ifdef EXPENSIVE_CHECKS |
482 | if (!LocalChanged && (RefHash != P->structuralHash(CG.getModule()))) { |
483 | llvm::errs() << "Pass modifies its input and doesn't report it: " |
484 | << P->getPassName() << "\n"; |
485 | llvm_unreachable("Pass modifies its input and doesn't report it")::llvm::llvm_unreachable_internal("Pass modifies its input and doesn't report it" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 485); |
486 | } |
487 | #endif |
488 | if (LocalChanged) |
489 | dumpPassInfo(P, MODIFICATION_MSG, ON_CG_MSG, ""); |
490 | dumpPreservedSet(P); |
491 | |
492 | verifyPreservedAnalysis(P); |
493 | if (LocalChanged) |
494 | removeNotPreservedAnalysis(P); |
495 | recordAvailableAnalysis(P); |
496 | removeDeadPasses(P, "", ON_CG_MSG); |
497 | } |
498 | |
499 | // If the callgraph was left out of date (because the last pass run was a |
500 | // functionpass), refresh it before we move on to the next SCC. |
501 | if (!CallGraphUpToDate) |
502 | DevirtualizedCall |= RefreshCallGraph(CurSCC, CG, false); |
503 | return Changed; |
504 | } |
505 | |
506 | /// Execute all of the passes scheduled for execution. Keep track of |
507 | /// whether any of the passes modifies the module, and if so, return true. |
508 | bool CGPassManager::runOnModule(Module &M) { |
509 | CallGraph &CG = getAnalysis<CallGraphWrapperPass>().getCallGraph(); |
510 | bool Changed = doInitialization(CG); |
511 | |
512 | // Walk the callgraph in bottom-up SCC order. |
513 | scc_iterator<CallGraph*> CGI = scc_begin(&CG); |
514 | |
515 | CallGraphSCC CurSCC(CG, &CGI); |
516 | while (!CGI.isAtEnd()) { |
517 | // Copy the current SCC and increment past it so that the pass can hack |
518 | // on the SCC if it wants to without invalidating our iterator. |
519 | const std::vector<CallGraphNode *> &NodeVec = *CGI; |
520 | CurSCC.initialize(NodeVec); |
521 | ++CGI; |
522 | |
523 | // At the top level, we run all the passes in this pass manager on the |
524 | // functions in this SCC. However, we support iterative compilation in the |
525 | // case where a function pass devirtualizes a call to a function. For |
526 | // example, it is very common for a function pass (often GVN or instcombine) |
527 | // to eliminate the addressing that feeds into a call. With that improved |
528 | // information, we would like the call to be an inline candidate, infer |
529 | // mod-ref information etc. |
530 | // |
531 | // Because of this, we allow iteration up to a specified iteration count. |
532 | // This only happens in the case of a devirtualized call, so we only burn |
533 | // compile time in the case that we're making progress. We also have a hard |
534 | // iteration count limit in case there is crazy code. |
535 | unsigned Iteration = 0; |
536 | bool DevirtualizedCall = false; |
537 | do { |
538 | LLVM_DEBUG(if (Iteration) dbgs()do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { if (Iteration) dbgs() << " SCCPASSMGR: Re-visiting SCC, iteration #" << Iteration << '\n'; } } while (false) |
539 | << " SCCPASSMGR: Re-visiting SCC, iteration #" << Iterationdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { if (Iteration) dbgs() << " SCCPASSMGR: Re-visiting SCC, iteration #" << Iteration << '\n'; } } while (false) |
540 | << '\n')do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { if (Iteration) dbgs() << " SCCPASSMGR: Re-visiting SCC, iteration #" << Iteration << '\n'; } } while (false); |
541 | DevirtualizedCall = false; |
542 | Changed |= RunAllPassesOnSCC(CurSCC, CG, DevirtualizedCall); |
543 | } while (Iteration++ < MaxDevirtIterations && DevirtualizedCall); |
544 | |
545 | if (DevirtualizedCall) |
546 | LLVM_DEBUG(dbgs() << " CGSCCPASSMGR: Stopped iteration after "do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { dbgs() << " CGSCCPASSMGR: Stopped iteration after " << Iteration << " times, due to -max-devirt-iterations\n" ; } } while (false) |
547 | << Iterationdo { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { dbgs() << " CGSCCPASSMGR: Stopped iteration after " << Iteration << " times, due to -max-devirt-iterations\n" ; } } while (false) |
548 | << " times, due to -max-devirt-iterations\n")do { if (::llvm::DebugFlag && ::llvm::isCurrentDebugType ("cgscc-passmgr")) { dbgs() << " CGSCCPASSMGR: Stopped iteration after " << Iteration << " times, due to -max-devirt-iterations\n" ; } } while (false); |
549 | |
550 | MaxSCCIterations.updateMax(Iteration); |
551 | } |
552 | Changed |= doFinalization(CG); |
553 | return Changed; |
554 | } |
555 | |
556 | /// Initialize CG |
557 | bool CGPassManager::doInitialization(CallGraph &CG) { |
558 | bool Changed = false; |
559 | for (unsigned i = 0, e = getNumContainedPasses(); i != e; ++i) { |
560 | if (PMDataManager *PM = getContainedPass(i)->getAsPMDataManager()) { |
561 | assert(PM->getPassManagerType() == PMT_FunctionPassManager &&(static_cast <bool> (PM->getPassManagerType() == PMT_FunctionPassManager && "Invalid CGPassManager member") ? void (0) : __assert_fail ("PM->getPassManagerType() == PMT_FunctionPassManager && \"Invalid CGPassManager member\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 562, __extension__ __PRETTY_FUNCTION__)) |
562 | "Invalid CGPassManager member")(static_cast <bool> (PM->getPassManagerType() == PMT_FunctionPassManager && "Invalid CGPassManager member") ? void (0) : __assert_fail ("PM->getPassManagerType() == PMT_FunctionPassManager && \"Invalid CGPassManager member\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 562, __extension__ __PRETTY_FUNCTION__)); |
563 | Changed |= ((FPPassManager*)PM)->doInitialization(CG.getModule()); |
564 | } else { |
565 | Changed |= ((CallGraphSCCPass*)getContainedPass(i))->doInitialization(CG); |
566 | } |
567 | } |
568 | return Changed; |
569 | } |
570 | |
571 | /// Finalize CG |
572 | bool CGPassManager::doFinalization(CallGraph &CG) { |
573 | bool Changed = false; |
574 | for (unsigned i = 0, e = getNumContainedPasses(); i != e; ++i) { |
575 | if (PMDataManager *PM = getContainedPass(i)->getAsPMDataManager()) { |
576 | assert(PM->getPassManagerType() == PMT_FunctionPassManager &&(static_cast <bool> (PM->getPassManagerType() == PMT_FunctionPassManager && "Invalid CGPassManager member") ? void (0) : __assert_fail ("PM->getPassManagerType() == PMT_FunctionPassManager && \"Invalid CGPassManager member\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 577, __extension__ __PRETTY_FUNCTION__)) |
577 | "Invalid CGPassManager member")(static_cast <bool> (PM->getPassManagerType() == PMT_FunctionPassManager && "Invalid CGPassManager member") ? void (0) : __assert_fail ("PM->getPassManagerType() == PMT_FunctionPassManager && \"Invalid CGPassManager member\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 577, __extension__ __PRETTY_FUNCTION__)); |
578 | Changed |= ((FPPassManager*)PM)->doFinalization(CG.getModule()); |
579 | } else { |
580 | Changed |= ((CallGraphSCCPass*)getContainedPass(i))->doFinalization(CG); |
581 | } |
582 | } |
583 | return Changed; |
584 | } |
585 | |
586 | //===----------------------------------------------------------------------===// |
587 | // CallGraphSCC Implementation |
588 | //===----------------------------------------------------------------------===// |
589 | |
590 | /// This informs the SCC and the pass manager that the specified |
591 | /// Old node has been deleted, and New is to be used in its place. |
592 | void CallGraphSCC::ReplaceNode(CallGraphNode *Old, CallGraphNode *New) { |
593 | assert(Old != New && "Should not replace node with self")(static_cast <bool> (Old != New && "Should not replace node with self" ) ? void (0) : __assert_fail ("Old != New && \"Should not replace node with self\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 593, __extension__ __PRETTY_FUNCTION__)); |
594 | for (unsigned i = 0; ; ++i) { |
595 | assert(i != Nodes.size() && "Node not in SCC")(static_cast <bool> (i != Nodes.size() && "Node not in SCC" ) ? void (0) : __assert_fail ("i != Nodes.size() && \"Node not in SCC\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 595, __extension__ __PRETTY_FUNCTION__)); |
596 | if (Nodes[i] != Old) continue; |
597 | if (New) |
598 | Nodes[i] = New; |
599 | else |
600 | Nodes.erase(Nodes.begin() + i); |
601 | break; |
602 | } |
603 | |
604 | // Update the active scc_iterator so that it doesn't contain dangling |
605 | // pointers to the old CallGraphNode. |
606 | scc_iterator<CallGraph*> *CGI = (scc_iterator<CallGraph*>*)Context; |
607 | CGI->ReplaceNode(Old, New); |
608 | } |
609 | |
610 | void CallGraphSCC::DeleteNode(CallGraphNode *Old) { |
611 | ReplaceNode(Old, /*New=*/nullptr); |
612 | } |
613 | |
614 | //===----------------------------------------------------------------------===// |
615 | // CallGraphSCCPass Implementation |
616 | //===----------------------------------------------------------------------===// |
617 | |
618 | /// Assign pass manager to manage this pass. |
619 | void CallGraphSCCPass::assignPassManager(PMStack &PMS, |
620 | PassManagerType PreferredType) { |
621 | // Find CGPassManager |
622 | while (!PMS.empty() && |
623 | PMS.top()->getPassManagerType() > PMT_CallGraphPassManager) |
624 | PMS.pop(); |
625 | |
626 | assert(!PMS.empty() && "Unable to handle Call Graph Pass")(static_cast <bool> (!PMS.empty() && "Unable to handle Call Graph Pass" ) ? void (0) : __assert_fail ("!PMS.empty() && \"Unable to handle Call Graph Pass\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 626, __extension__ __PRETTY_FUNCTION__)); |
627 | CGPassManager *CGP; |
628 | |
629 | if (PMS.top()->getPassManagerType() == PMT_CallGraphPassManager) |
630 | CGP = (CGPassManager*)PMS.top(); |
631 | else { |
632 | // Create new Call Graph SCC Pass Manager if it does not exist. |
633 | assert(!PMS.empty() && "Unable to create Call Graph Pass Manager")(static_cast <bool> (!PMS.empty() && "Unable to create Call Graph Pass Manager" ) ? void (0) : __assert_fail ("!PMS.empty() && \"Unable to create Call Graph Pass Manager\"" , "llvm/lib/Analysis/CallGraphSCCPass.cpp", 633, __extension__ __PRETTY_FUNCTION__)); |
634 | PMDataManager *PMD = PMS.top(); |
635 | |
636 | // [1] Create new Call Graph Pass Manager |
637 | CGP = new CGPassManager(); |
638 | |
639 | // [2] Set up new manager's top level manager |
640 | PMTopLevelManager *TPM = PMD->getTopLevelManager(); |
641 | TPM->addIndirectPassManager(CGP); |
642 | |
643 | // [3] Assign manager to manage this new manager. This may create |
644 | // and push new managers into PMS |
645 | Pass *P = CGP; |
646 | TPM->schedulePass(P); |
647 | |
648 | // [4] Push new manager into PMS |
649 | PMS.push(CGP); |
650 | } |
651 | |
652 | CGP->add(this); |
653 | } |
654 | |
655 | /// For this class, we declare that we require and preserve the call graph. |
656 | /// If the derived class implements this method, it should |
657 | /// always explicitly call the implementation here. |
658 | void CallGraphSCCPass::getAnalysisUsage(AnalysisUsage &AU) const { |
659 | AU.addRequired<CallGraphWrapperPass>(); |
660 | AU.addPreserved<CallGraphWrapperPass>(); |
661 | } |
662 | |
663 | //===----------------------------------------------------------------------===// |
664 | // PrintCallGraphPass Implementation |
665 | //===----------------------------------------------------------------------===// |
666 | |
667 | namespace { |
668 | |
669 | /// PrintCallGraphPass - Print a Module corresponding to a call graph. |
670 | /// |
671 | class PrintCallGraphPass : public CallGraphSCCPass { |
672 | std::string Banner; |
673 | raw_ostream &OS; // raw_ostream to print on. |
674 | |
675 | public: |
676 | static char ID; |
677 | |
678 | PrintCallGraphPass(const std::string &B, raw_ostream &OS) |
679 | : CallGraphSCCPass(ID), Banner(B), OS(OS) {} |
680 | |
681 | void getAnalysisUsage(AnalysisUsage &AU) const override { |
682 | AU.setPreservesAll(); |
683 | } |
684 | |
685 | bool runOnSCC(CallGraphSCC &SCC) override { |
686 | bool BannerPrinted = false; |
687 | auto PrintBannerOnce = [&]() { |
688 | if (BannerPrinted) |
689 | return; |
690 | OS << Banner; |
691 | BannerPrinted = true; |
692 | }; |
693 | |
694 | bool NeedModule = llvm::forcePrintModuleIR(); |
695 | if (isFunctionInPrintList("*") && NeedModule) { |
696 | PrintBannerOnce(); |
697 | OS << "\n"; |
698 | SCC.getCallGraph().getModule().print(OS, nullptr); |
699 | return false; |
700 | } |
701 | bool FoundFunction = false; |
702 | for (CallGraphNode *CGN : SCC) { |
703 | if (Function *F = CGN->getFunction()) { |
704 | if (!F->isDeclaration() && isFunctionInPrintList(F->getName())) { |
705 | FoundFunction = true; |
706 | if (!NeedModule) { |
707 | PrintBannerOnce(); |
708 | F->print(OS); |
709 | } |
710 | } |
711 | } else if (isFunctionInPrintList("*")) { |
712 | PrintBannerOnce(); |
713 | OS << "\nPrinting <null> Function\n"; |
714 | } |
715 | } |
716 | if (NeedModule && FoundFunction) { |
717 | PrintBannerOnce(); |
718 | OS << "\n"; |
719 | SCC.getCallGraph().getModule().print(OS, nullptr); |
720 | } |
721 | return false; |
722 | } |
723 | |
724 | StringRef getPassName() const override { return "Print CallGraph IR"; } |
725 | }; |
726 | |
727 | } // end anonymous namespace. |
728 | |
729 | char PrintCallGraphPass::ID = 0; |
730 | |
731 | Pass *CallGraphSCCPass::createPrinterPass(raw_ostream &OS, |
732 | const std::string &Banner) const { |
733 | return new PrintCallGraphPass(Banner, OS); |
734 | } |
735 | |
736 | static std::string getDescription(const CallGraphSCC &SCC) { |
737 | std::string Desc = "SCC ("; |
738 | ListSeparator LS; |
739 | for (CallGraphNode *CGN : SCC) { |
740 | Desc += LS; |
741 | Function *F = CGN->getFunction(); |
742 | if (F) |
743 | Desc += F->getName(); |
744 | else |
745 | Desc += "<<null function>>"; |
746 | } |
747 | Desc += ")"; |
748 | return Desc; |
749 | } |
750 | |
751 | bool CallGraphSCCPass::skipSCC(CallGraphSCC &SCC) const { |
752 | OptPassGate &Gate = |
753 | SCC.getCallGraph().getModule().getContext().getOptPassGate(); |
754 | return Gate.isEnabled() && !Gate.shouldRunPass(this, getDescription(SCC)); |
755 | } |
756 | |
757 | char DummyCGSCCPass::ID = 0; |
758 | |
759 | INITIALIZE_PASS(DummyCGSCCPass, "DummyCGSCCPass", "DummyCGSCCPass", false,static void *initializeDummyCGSCCPassPassOnce(PassRegistry & Registry) { PassInfo *PI = new PassInfo( "DummyCGSCCPass", "DummyCGSCCPass" , &DummyCGSCCPass::ID, PassInfo::NormalCtor_t(callDefaultCtor <DummyCGSCCPass>), false, false); Registry.registerPass (*PI, true); return PI; } static llvm::once_flag InitializeDummyCGSCCPassPassFlag ; void llvm::initializeDummyCGSCCPassPass(PassRegistry &Registry ) { llvm::call_once(InitializeDummyCGSCCPassPassFlag, initializeDummyCGSCCPassPassOnce , std::ref(Registry)); } |
760 | false)static void *initializeDummyCGSCCPassPassOnce(PassRegistry & Registry) { PassInfo *PI = new PassInfo( "DummyCGSCCPass", "DummyCGSCCPass" , &DummyCGSCCPass::ID, PassInfo::NormalCtor_t(callDefaultCtor <DummyCGSCCPass>), false, false); Registry.registerPass (*PI, true); return PI; } static llvm::once_flag InitializeDummyCGSCCPassPassFlag ; void llvm::initializeDummyCGSCCPassPass(PassRegistry &Registry ) { llvm::call_once(InitializeDummyCGSCCPassPassFlag, initializeDummyCGSCCPassPassOnce , std::ref(Registry)); } |