1 //===- LoopExtractor.cpp - Extract each loop into a new function ----------===//
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 // A pass wrapper around the ExtractLoop() scalar transformation to extract each
10 // top-level loop into its own new function. If the loop is the ONLY loop in a
11 // given function, it is not touched. This is a pass most useful for debugging
12 // via bugpoint.
13 //
14 //===----------------------------------------------------------------------===//
15
16 #include "llvm/ADT/Statistic.h"
17 #include "llvm/Analysis/AssumptionCache.h"
18 #include "llvm/Analysis/LoopPass.h"
19 #include "llvm/IR/Dominators.h"
20 #include "llvm/IR/Instructions.h"
21 #include "llvm/IR/Module.h"
22 #include "llvm/InitializePasses.h"
23 #include "llvm/Pass.h"
24 #include "llvm/Support/CommandLine.h"
25 #include "llvm/Transforms/IPO.h"
26 #include "llvm/Transforms/Scalar.h"
27 #include "llvm/Transforms/Utils.h"
28 #include "llvm/Transforms/Utils/BasicBlockUtils.h"
29 #include "llvm/Transforms/Utils/CodeExtractor.h"
30 #include <fstream>
31 #include <set>
32 using namespace llvm;
33
34 #define DEBUG_TYPE "loop-extract"
35
36 STATISTIC(NumExtracted, "Number of loops extracted");
37
38 namespace {
39 struct LoopExtractor : public LoopPass {
40 static char ID; // Pass identification, replacement for typeid
41 unsigned NumLoops;
42
LoopExtractor__anonfffaf9460111::LoopExtractor43 explicit LoopExtractor(unsigned numLoops = ~0)
44 : LoopPass(ID), NumLoops(numLoops) {
45 initializeLoopExtractorPass(*PassRegistry::getPassRegistry());
46 }
47
48 bool runOnLoop(Loop *L, LPPassManager &) override;
49
getAnalysisUsage__anonfffaf9460111::LoopExtractor50 void getAnalysisUsage(AnalysisUsage &AU) const override {
51 AU.addRequiredID(BreakCriticalEdgesID);
52 AU.addRequiredID(LoopSimplifyID);
53 AU.addRequired<DominatorTreeWrapperPass>();
54 AU.addRequired<LoopInfoWrapperPass>();
55 AU.addUsedIfAvailable<AssumptionCacheTracker>();
56 }
57 };
58 }
59
60 char LoopExtractor::ID = 0;
61 INITIALIZE_PASS_BEGIN(LoopExtractor, "loop-extract",
62 "Extract loops into new functions", false, false)
63 INITIALIZE_PASS_DEPENDENCY(BreakCriticalEdges)
64 INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
65 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
66 INITIALIZE_PASS_END(LoopExtractor, "loop-extract",
67 "Extract loops into new functions", false, false)
68
69 namespace {
70 /// SingleLoopExtractor - For bugpoint.
71 struct SingleLoopExtractor : public LoopExtractor {
72 static char ID; // Pass identification, replacement for typeid
SingleLoopExtractor__anonfffaf9460211::SingleLoopExtractor73 SingleLoopExtractor() : LoopExtractor(1) {}
74 };
75 } // End anonymous namespace
76
77 char SingleLoopExtractor::ID = 0;
78 INITIALIZE_PASS(SingleLoopExtractor, "loop-extract-single",
79 "Extract at most one loop into a new function", false, false)
80
81 // createLoopExtractorPass - This pass extracts all natural loops from the
82 // program into a function if it can.
83 //
createLoopExtractorPass()84 Pass *llvm::createLoopExtractorPass() { return new LoopExtractor(); }
85
runOnLoop(Loop * L,LPPassManager & LPM)86 bool LoopExtractor::runOnLoop(Loop *L, LPPassManager &LPM) {
87 if (skipLoop(L))
88 return false;
89
90 // Only visit top-level loops.
91 if (L->getParentLoop())
92 return false;
93
94 // If LoopSimplify form is not available, stay out of trouble.
95 if (!L->isLoopSimplifyForm())
96 return false;
97
98 DominatorTree &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();
99 LoopInfo &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
100 bool Changed = false;
101
102 // If there is more than one top-level loop in this function, extract all of
103 // the loops. Otherwise there is exactly one top-level loop; in this case if
104 // this function is more than a minimal wrapper around the loop, extract
105 // the loop.
106 bool ShouldExtractLoop = false;
107
108 // Extract the loop if the entry block doesn't branch to the loop header.
109 Instruction *EntryTI =
110 L->getHeader()->getParent()->getEntryBlock().getTerminator();
111 if (!isa<BranchInst>(EntryTI) ||
112 !cast<BranchInst>(EntryTI)->isUnconditional() ||
113 EntryTI->getSuccessor(0) != L->getHeader()) {
114 ShouldExtractLoop = true;
115 } else {
116 // Check to see if any exits from the loop are more than just return
117 // blocks.
118 SmallVector<BasicBlock*, 8> ExitBlocks;
119 L->getExitBlocks(ExitBlocks);
120 for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
121 if (!isa<ReturnInst>(ExitBlocks[i]->getTerminator())) {
122 ShouldExtractLoop = true;
123 break;
124 }
125 }
126
127 if (ShouldExtractLoop) {
128 // We must omit EH pads. EH pads must accompany the invoke
129 // instruction. But this would result in a loop in the extracted
130 // function. An infinite cycle occurs when it tries to extract that loop as
131 // well.
132 SmallVector<BasicBlock*, 8> ExitBlocks;
133 L->getExitBlocks(ExitBlocks);
134 for (unsigned i = 0, e = ExitBlocks.size(); i != e; ++i)
135 if (ExitBlocks[i]->isEHPad()) {
136 ShouldExtractLoop = false;
137 break;
138 }
139 }
140
141 if (ShouldExtractLoop) {
142 if (NumLoops == 0) return Changed;
143 --NumLoops;
144 AssumptionCache *AC = nullptr;
145 Function &Func = *L->getHeader()->getParent();
146 if (auto *ACT = getAnalysisIfAvailable<AssumptionCacheTracker>())
147 AC = ACT->lookupAssumptionCache(Func);
148 CodeExtractorAnalysisCache CEAC(Func);
149 CodeExtractor Extractor(DT, *L, false, nullptr, nullptr, AC);
150 if (Extractor.extractCodeRegion(CEAC) != nullptr) {
151 Changed = true;
152 // After extraction, the loop is replaced by a function call, so
153 // we shouldn't try to run any more loop passes on it.
154 LPM.markLoopAsDeleted(*L);
155 LI.erase(L);
156 }
157 ++NumExtracted;
158 }
159
160 return Changed;
161 }
162
163 // createSingleLoopExtractorPass - This pass extracts one natural loop from the
164 // program into a function if it can. This is used by bugpoint.
165 //
createSingleLoopExtractorPass()166 Pass *llvm::createSingleLoopExtractorPass() {
167 return new SingleLoopExtractor();
168 }
169