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