llvm/lib/Analysis/RegionInfo.cpp

   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
  23 using namespace llvm;
  24
  25 #define DEBUG_TYPE "region"
  26
  27 namespace llvm {
  28
  29 template class RegionBase<RegionTraits<Function>>;
  30 template class RegionNodeBase<RegionTraits<Function>>;
  31 template class RegionInfoBase<RegionTraits<Function>>;
  32
  33 } // end namespace llvm
  34
  35 STATISTIC(numRegions,       "The # of regions");
  36 STATISTIC(numSimpleRegions, "The # of simple regions");
  37
  38 // Always verify if expensive checking is enabled.
  39
  40 static cl::opt<bool,true>
  41 VerifyRegionInfoX(
  42   "verify-region-info",
  43   cl::location(RegionInfoBase<RegionTraits<Function>>::VerifyRegionInfo),
  44   cl::desc("Verify region info (time consuming)"));
  45
  46 static 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
  61 Region::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
  68 Region::~Region() = default;
  69
  70 //===----------------------------------------------------------------------===//
  71 // RegionInfo implementation
  72 //
  73
  74 RegionInfo::RegionInfo() = default;
  75
  76 RegionInfo::~RegionInfo() = default;
  77
  78 bool 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
  87 void 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
  95 void 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
 108 void RegionInfo::view() { viewRegion(this); }
 109
 110 void RegionInfo::viewOnly() { viewRegionOnly(this); }
 111 #endif
 112
 113 //===----------------------------------------------------------------------===//
 114 // RegionInfoPass implementation
 115 //
 116
 117 RegionInfoPass::RegionInfoPass() : FunctionPass(ID) {
 118   initializeRegionInfoPassPass(*PassRegistry::getPassRegistry());
 119 }
 120
 121 RegionInfoPass::~RegionInfoPass() = default;
 122
 123 bool 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
 134 void RegionInfoPass::releaseMemory() {
 135   RI.releaseMemory();
 136 }
 137
 138 void RegionInfoPass::verifyAnalysis() const {
 139     RI.verifyAnalysis();
 140 }
 141
 142 void RegionInfoPass::getAnalysisUsage(AnalysisUsage &AU) const {
 143   AU.setPreservesAll();
 144   AU.addRequiredTransitive<DominatorTreeWrapperPass>();
 145   AU.addRequired<PostDominatorTreeWrapperPass>();
 146   AU.addRequired<DominanceFrontierWrapperPass>();
 147 }
 148
 149 void RegionInfoPass::print(raw_ostream &OS, const Module *) const {
 150   RI.print(OS);
 151 }
 152
 153 #if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
 154 LLVM_DUMP_METHOD void RegionInfoPass::dump() const {
 155   RI.dump();
 156 }
 157 #endif
 158
 159 char RegionInfoPass::ID = 0;
 160
 161 INITIALIZE_PASS_BEGIN(RegionInfoPass, "regions",
 162                 "Detect single entry single exit regions", true, true)
 163 INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
 164 INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass)
 165 INITIALIZE_PASS_DEPENDENCY(DominanceFrontierWrapperPass)
 166 INITIALIZE_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
 173 namespace llvm {
 174
 175   FunctionPass *createRegionInfoPass() {
 176     return new RegionInfoPass();
 177   }
 178
 179 } // end namespace llvm
 180
 181 //===----------------------------------------------------------------------===//
 182 // RegionInfoAnalysis implementation
 183 //
 184
 185 AnalysisKey RegionInfoAnalysis::Key;
 186
 187 RegionInfo 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
 197 RegionInfoPrinterPass::RegionInfoPrinterPass(raw_ostream &OS)
 198   : OS(OS) {}
 199
 200 PreservedAnalyses 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
 208 PreservedAnalyses RegionInfoVerifierPass::run(Function &F,
 209                                               FunctionAnalysisManager &AM) {
 210   AM.getResult<RegionInfoAnalysis>(F).verifyAnalysis();
 211
 212   return PreservedAnalyses::all();
 213 }