RegionInfo.cpp

Go to the documentation of this file.

//===- RegionInfo.cpp - SESE region detection analysis --------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
// Detects single entry single exit regions in the control flow graph.
//===----------------------------------------------------------------------===//
 
#include "llvm/Analysis/RegionInfo.h"
#include "llvm/ADT/Statistic.h"
#include "llvm/Analysis/DominanceFrontier.h"
#include "llvm/InitializePasses.h"
#ifndef NDEBUG
#include "llvm/Analysis/RegionPrinter.h"
#endif
#include "llvm/Analysis/Passes.h"
#include "llvm/Analysis/RegionInfoImpl.h"
#include "llvm/Config/llvm-config.h"
#include "llvm/IR/Function.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/Compiler.h"
 
using namespace llvm;
 
#define DEBUG_TYPE "region"
 
namespace llvm {
 
template class LLVM_EXPORT_TEMPLATE RegionBase<RegionTraits<Function>>;
template class LLVM_EXPORT_TEMPLATE RegionNodeBase<RegionTraits<Function>>;
template class LLVM_EXPORT_TEMPLATE RegionInfoBase<RegionTraits<Function>>;
 
} // end namespace llvm
 
STATISTIC(numRegions,       "The # of regions");
STATISTIC(numSimpleRegions, "The # of simple regions");
 
// Always verify if expensive checking is enabled.
 
static cl::opt<bool,true>
VerifyRegionInfoX(
  "verify-region-info",
  cl::location(RegionInfoBase<RegionTraits<Function>>::VerifyRegionInfo),
  cl::desc("Verify region info (time consuming)"));
 
static cl::opt<Region::PrintStyle, true> printStyleX("print-region-style",
  cl::location(RegionInfo::printStyle),
  cl::Hidden,
  cl::desc("style of printing regions"),
  cl::values(
    clEnumValN(Region::PrintNone, "none",  "print no details"),
    clEnumValN(Region::PrintBB, "bb",
               "print regions in detail with block_iterator"),
    clEnumValN(Region::PrintRN, "rn",
               "print regions in detail with element_iterator")));
 
//===----------------------------------------------------------------------===//
// RegionTraits<Function> implementation
//
 
void RegionTraits<Function>::updateStatistics(Region *R) {
  ++numRegions;
 
  // TODO: Slow. Should only be enabled if -stats is used.
  if (R->isSimple())
    ++numSimpleRegions;
}
 
//===----------------------------------------------------------------------===//
// Region implementation
//
 
Region::Region(BasicBlock *Entry, BasicBlock *Exit,
               RegionInfo* RI,
               DominatorTree *DT, Region *Parent) :
  RegionBase<RegionTraits<Function>>(Entry, Exit, RI, DT, Parent) {
 
}
 
Region::~Region() = default;
 
//===----------------------------------------------------------------------===//
// RegionInfo implementation
//
 
RegionInfo::RegionInfo() = default;
 
RegionInfo::~RegionInfo() = default;
 
bool RegionInfo::invalidate(Function &F, const PreservedAnalyses &PA,
                            FunctionAnalysisManager::Invalidator &) {
  // Check whether the analysis, all analyses on functions, or the function's
  // CFG has been preserved.
  auto PAC = PA.getChecker<RegionInfoAnalysis>();
  return !(PAC.preserved() || PAC.preservedSet<AllAnalysesOn<Function>>() ||
           PAC.preservedSet<CFGAnalyses>());
}
 
void RegionInfo::recalculate(Function &F, DominatorTree *DT_,
                             PostDominatorTree *PDT_, DominanceFrontier *DF_) {
  DT = DT_;
  PDT = PDT_;
  DF = DF_;
 
  TopLevelRegion = new Region(&F.getEntryBlock(), nullptr,
                              this, DT, nullptr);
  RegionTraits<Function>::updateStatistics(TopLevelRegion);
  calculate(F);
}
 
#ifndef NDEBUG
void RegionInfo::view() { viewRegion(this); }
 
void RegionInfo::viewOnly() { viewRegionOnly(this); }
#endif
 
//===----------------------------------------------------------------------===//
// RegionInfoPass implementation
//
 
RegionInfoPass::RegionInfoPass() : FunctionPass(ID) {}
 
RegionInfoPass::~RegionInfoPass() = default;
 
bool RegionInfoPass::runOnFunction(Function &F) {
  releaseMemory();
 
  auto DT = &getAnalysis<DominatorTreeWrapperPass>().getDomTree();
  auto PDT = &getAnalysis<PostDominatorTreeWrapperPass>().getPostDomTree();
  auto DF = &getAnalysis<DominanceFrontierWrapperPass>().getDominanceFrontier();
 
  RI.recalculate(F, DT, PDT, DF);
  return false;
}
 
void RegionInfoPass::releaseMemory() {
  RI.releaseMemory();
}
 
void RegionInfoPass::verifyAnalysis() const {
    RI.verifyAnalysis();
}
 
void RegionInfoPass::getAnalysisUsage(AnalysisUsage &AU) const {
  AU.setPreservesAll();
  AU.addRequiredTransitive<DominatorTreeWrapperPass>();
  AU.addRequired<PostDominatorTreeWrapperPass>();
  AU.addRequired<DominanceFrontierWrapperPass>();
}
 
void RegionInfoPass::print(raw_ostream &OS, const Module *) const {
  RI.print(OS);
}
 
#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
LLVM_DUMP_METHOD void RegionInfoPass::dump() const {
  RI.dump();
}
#endif
 
char RegionInfoPass::ID = 0;
 
INITIALIZE_PASS_BEGIN(RegionInfoPass, "regions",
                "Detect single entry single exit regions", true, true)
INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)
INITIALIZE_PASS_DEPENDENCY(PostDominatorTreeWrapperPass)
INITIALIZE_PASS_DEPENDENCY(DominanceFrontierWrapperPass)
INITIALIZE_PASS_END(RegionInfoPass, "regions",
                "Detect single entry single exit regions", true, true)
 
// Create methods available outside of this file, to use them
// "include/llvm/LinkAllPasses.h". Otherwise the pass would be deleted by
// the link time optimization.
 
namespace llvm {
 
  FunctionPass *createRegionInfoPass() {
    return new RegionInfoPass();
  }
 
} // end namespace llvm
 
//===----------------------------------------------------------------------===//
// RegionInfoAnalysis implementation
//
 
AnalysisKey RegionInfoAnalysis::Key;
 
RegionInfo RegionInfoAnalysis::run(Function &F, FunctionAnalysisManager &AM) {
  RegionInfo RI;
  auto *DT = &AM.getResult<DominatorTreeAnalysis>(F);
  auto *PDT = &AM.getResult<PostDominatorTreeAnalysis>(F);
  auto *DF = &AM.getResult<DominanceFrontierAnalysis>(F);
 
  RI.recalculate(F, DT, PDT, DF);
  return RI;
}
 
RegionInfoPrinterPass::RegionInfoPrinterPass(raw_ostream &OS)
  : OS(OS) {}
 
PreservedAnalyses RegionInfoPrinterPass::run(Function &F,
                                             FunctionAnalysisManager &AM) {
  OS << "Region Tree for function: " << F.getName() << "\n";
  AM.getResult<RegionInfoAnalysis>(F).print(OS);
 
  return PreservedAnalyses::all();
}
 
PreservedAnalyses RegionInfoVerifierPass::run(Function &F,
                                              FunctionAnalysisManager &AM) {
  AM.getResult<RegionInfoAnalysis>(F).verifyAnalysis();
 
  return PreservedAnalyses::all();
}