74     "intra-scc-cost-multiplier", cl::init(2), cl::Hidden,
77         "new call was previously an intra-SCC call (not relevant when the "
78         "original call was already intra-SCC). This can accumulate over "
82         "multiplied by intra-scc-cost-multiplier). This is to prevent tons of "
83         "inlining through a child SCC which can cause terrible compile times"));
90 /// Allows printing the contents of the advisor after each SCC inliner pass.
92     EnablePostSCCAdvisorPrinting("enable-scc-inline-advisor-printing",
170     // It should still be possible to run the inliner as a stand-alone SCC pass,  in getAdvisor()
172     // DefaultInlineAdvisor, which doesn't need to keep state between SCC pass  in getAdvisor()
208 PreservedAnalyses InlinerPass::run(LazyCallGraph::SCC &InitialC,  in run()
215   assert(InitialC.size() > 0 && "Cannot handle an empty SCC!");  in run()
226   // We use a single common worklist for calls across the entire SCC. We  in run()
239   // However, when processing call edges *within* an SCC we cannot rely on this  in run()
246   // by inlining until we've done one pass of inlining across the entire SCC.  in run()
248   // this model, but it is uniformly spread across all the functions in the SCC  in run()
253   // Populate the initial list of calls in this SCC.  in run()
281   // Capture updatable variable for the current SCC.  in run()
349       // Check if this inlining may repeat breaking an SCC apart that has  in run()
354       LazyCallGraph::SCC *CalleeSCC = CG.lookupSCC(*CG.lookup(Callee));  in run()
356         LLVM_DEBUG(dbgs() << "Skipping inlining internal SCC edge from a node "  in run()
357                              "previously split out of this SCC by inlining: "  in run()
359         setInlineRemark(*CB, "recursive SCC split");  in run()
422               // Continually inlining through an SCC can result in huge compile  in run()
427               // This doesn't apply to calls in the same SCC since if we do  in run()
428               // inline through the SCC the function will end up being  in run()
430               // within an SCC is necessary for performance.  in run()
493     // proxy for this particular SCC. We do this as the SCC may have changed and  in run()
496     LazyCallGraph::SCC *OldC = C;  in run()
498     LLVM_DEBUG(dbgs() << "Updated inlining SCC: " << *C << "\n");  in run()
500     // If this causes an SCC to split apart into multiple smaller SCCs, there  in run()
502     // expose an "infinite inlining" opportunity later, and because of the SCC  in run()
504     // do, and that re-inlining also has the potentially to mutate the SCC  in run()
506     // SCC splits and merges. To avoid this, we capture the originating caller  in run()
507     // node and the SCC containing the call edge. This is a slight over  in run()
510     // a new SCC is generated and the original SCC may be generated via merge  in run()
513     // It is also possible that even if no new SCC is generated  in run()
514     // (i.e., C == OldC), the original SCC could be split and then merged  in run()
515     // into the same one as itself. and the original SCC will be added into  in run()
524       LLVM_DEBUG(dbgs() << "Inlined an internal call edge and split an SCC, "  in run()
531     // invalidate analyses for all functions in this SCC later.  in run()
544   // Now that we've finished inlining all of the calls across this SCC, delete  in run()
618   // to detect when we devirtualize indirect calls and iterate the SCC passes  in run()