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 } 216