1//===- RegionInfo.cpp - SESE region detection analysis --------------------===//
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// Detects single entry single exit regions in the control flow graph.
9//===----------------------------------------------------------------------===//
10
11#include "llvm/Analysis/RegionInfo.h"
12#include "llvm/ADT/Statistic.h"
13#include "llvm/InitializePasses.h"
14#ifndef NDEBUG
15#include "llvm/Analysis/RegionPrinter.h"
16#endif
17#include "llvm/Analysis/RegionInfoImpl.h"
18#include "llvm/Config/llvm-config.h"
19#include "llvm/IR/Function.h"
20#include "llvm/Support/CommandLine.h"
21#include "llvm/Support/Compiler.h"
22
23using namespace llvm;
24
25#define DEBUG_TYPE "region"
26
27namespace llvm {
28
29template class RegionBase<RegionTraits<Function>>;
30template class RegionNodeBase<RegionTraits<Function>>;
31template class RegionInfoBase<RegionTraits<Function>>;
32
33} // end namespace llvm
34
35STATISTIC(numRegions,       "The # of regions");
36STATISTIC(numSimpleRegions, "The # of simple regions");
37
38// Always verify if expensive checking is enabled.
39
40static cl::opt<bool,true>
41VerifyRegionInfoX(
42  "verify-region-info",
43  cl::location(RegionInfoBase<RegionTraits<Function>>::VerifyRegionInfo),
44  cl::desc("Verify region info (time consuming)"));
45
46static cl::opt<Region::PrintStyle, true> printStyleX("print-region-style",
47  cl::location(RegionInfo::printStyle),
48  cl::Hidden,
49  cl::desc("style of printing regions"),
50  cl::values(
51    clEnumValN(Region::PrintNone, "none",  "print no details"),
52    clEnumValN(Region::PrintBB, "bb",
53               "print regions in detail with block_iterator"),
54    clEnumValN(Region::PrintRN, "rn",
55               "print regions in detail with element_iterator")));
56
57//===----------------------------------------------------------------------===//
58// Region implementation
59//
60
61Region::Region(BasicBlock *Entry, BasicBlock *Exit,
62               RegionInfo* RI,
63               DominatorTree *DT, Region *Parent) :
64  RegionBase<RegionTraits<Function>>(Entry, Exit, RI, DT, Parent) {
65
66}
67
68Region::~Region() = default;
69
70//===----------------------------------------------------------------------===//
71// RegionInfo implementation
72//
73
74RegionInfo::RegionInfo() = default;
75
76RegionInfo::~RegionInfo() = default;
77
78bool RegionInfo::invalidate(Function &F, const PreservedAnalyses &PA,
79                            FunctionAnalysisManager::Invalidator &) {
80  // Check whether the analysis, all analyses on functions, or the function's
81  // CFG has been preserved.
82  auto PAC = PA.getChecker<RegionInfoAnalysis>();
83  return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>() ||
84           PAC.preservedSet<CFGAnalyses>());
85}
86
87void RegionInfo::updateStatistics(Region *R) {
88  ++numRegions;
89
90  // TODO: Slow. Should only be enabled if -stats is used.
91  if (R->isSimple())
92    ++numSimpleRegions;
93}
94
95void RegionInfo::recalculate(Function &F, DominatorTree *DT_,
96                             PostDominatorTree *PDT_, DominanceFrontier *DF_) {
97  DT = DT_;
98  PDT = PDT_;
99  DF = DF_;
100
101  TopLevelRegion = new Region(&F.getEntryBlock(), nullptr,
102                              this, DT, nullptr);
103  updateStatistics(TopLevelRegion);
104  calculate(F);
105}
106
107#ifndef NDEBUG
108void RegionInfo::view() { viewRegion(this); }
109
110void RegionInfo::viewOnly() { viewRegionOnly(this); }
111#endif
112
113//===----------------------------------------------------------------------===//
114// RegionInfoPass implementation
115//
116
117RegionInfoPass::RegionInfoPass() : FunctionPass(ID) {
118  initializeRegionInfoPassPass(*PassRegistry::getPassRegistry());
119}
120
121RegionInfoPass::~RegionInfoPass() = default;
122
123bool RegionInfoPass::runOnFunction(Function &F) {
124  releaseMemory();
125
126  auto DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
127  auto PDT = &getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
128  auto DF = &getAnalysis<DominanceFrontierWrapperPass>().getDominanceFrontier();
129
130  RI.recalculate(F, DT, PDT, DF);
131  return false;
132}
133
134void RegionInfoPass::releaseMemory() {
135  RI.releaseMemory();
136}
137
138void RegionInfoPass::verifyAnalysis() const {
139    RI.verifyAnalysis();
140}
141
142void RegionInfoPass::getAnalysisUsage(AnalysisUsage &AU) const {
143  AU.setPreservesAll();
144  AU.addRequiredTransitive<DominatorTreeWrapperPass>();
145  AU.addRequired<PostDominatorTreeWrapperPass>();
146  AU.addRequired<DominanceFrontierWrapperPass>();
147}
148
149void RegionInfoPass::print(raw_ostream &OS, const Module *) const {
150  RI.print(OS);
151}
152
153#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
154LLVM_DUMP_METHOD void RegionInfoPass::dump() const {
155  RI.dump();
156}
157#endif
158
159char RegionInfoPass::ID = 0;
160
161INITIALIZE_PASS_BEGIN(RegionInfoPass, "regions",
162                "Detect single entry single exit regions", true, true)
163INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
164INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass)
165INITIALIZE_PASS_DEPENDENCY(DominanceFrontierWrapperPass)
166INITIALIZE_PASS_END(RegionInfoPass, "regions",
167                "Detect single entry single exit regions", true, true)
168
169// Create methods available outside of this file, to use them
170// "include/llvm/LinkAllPasses.h". Otherwise the pass would be deleted by
171// the link time optimization.
172
173namespace llvm {
174
175  FunctionPass *createRegionInfoPass() {
176    return new RegionInfoPass();
177  }
178
179} // end namespace llvm
180
181//===----------------------------------------------------------------------===//
182// RegionInfoAnalysis implementation
183//
184
185AnalysisKey RegionInfoAnalysis::Key;
186
187RegionInfo RegionInfoAnalysis::run(Function &F, FunctionAnalysisManager &AM) {
188  RegionInfo RI;
189  auto *DT = &AM.getResult<DominatorTreeAnalysis>(F);
190  auto *PDT = &AM.getResult<PostDominatorTreeAnalysis>(F);
191  auto *DF = &AM.getResult<DominanceFrontierAnalysis>(F);
192
193  RI.recalculate(F, DT, PDT, DF);
194  return RI;
195}
196
197RegionInfoPrinterPass::RegionInfoPrinterPass(raw_ostream &OS)
198  : OS(OS) {}
199
200PreservedAnalyses RegionInfoPrinterPass::run(Function &F,
201                                             FunctionAnalysisManager &AM) {
202  OS << "Region Tree for function: " << F.getName() << "\n";
203  AM.getResult<RegionInfoAnalysis>(F).print(OS);
204
205  return PreservedAnalyses::all();
206}
207
208PreservedAnalyses RegionInfoVerifierPass::run(Function &F,
209                                              FunctionAnalysisManager &AM) {
210  AM.getResult<RegionInfoAnalysis>(F).verifyAnalysis();
211
212  return PreservedAnalyses::all();
213}
214