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