Commit 67904db2 authored by Alina Sbirlea's avatar Alina Sbirlea
Browse files

[IRCE] Make IRCE a Function pass. 

Summary: Make InductiveRangeCheckElimination a FunctionPass.

Reviewers: reames, mkazantsev

Subscribers: hiraditya, llvm-commits

Tags: #llvm

Differential Revision: https://reviews.llvm.org/D73592
parent 921d4e7c

llvm/include/llvm/Transforms/Scalar/InductiveRangeCheckElimination.h

+1 −3
Original line number Diff line number Diff line
@@ -15,14 +15,12 @@ 
#define LLVM_TRANSFORMS_SCALAR_INDUCTIVERANGECHECKELIMINATION_H



#include "llvm/IR/PassManager.h"

#include "llvm/Transforms/Scalar/LoopPassManager.h"



namespace llvm {



class IRCEPass : public PassInfoMixin<IRCEPass> {

public:

  PreservedAnalyses run(Loop &L, LoopAnalysisManager &AM,

                        LoopStandardAnalysisResults &AR, LPMUpdater &U);

  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);

};



} // end namespace llvm

llvm/lib/Passes/PassRegistry.def

+1 −1
Original line number Diff line number Diff line
@@ -183,6 +183,7 @@ FUNCTION_PASS("gvn-hoist", GVNHoistPass()) 
FUNCTION_PASS("instcombine", InstCombinePass())

FUNCTION_PASS("instsimplify", InstSimplifyPass())

FUNCTION_PASS("invalidate<all>", InvalidateAllAnalysesPass())

FUNCTION_PASS("irce", IRCEPass())

FUNCTION_PASS("float2int", Float2IntPass())

FUNCTION_PASS("no-op-function", NoOpFunctionPass())

FUNCTION_PASS("libcalls-shrinkwrap", LibCallsShrinkWrapPass())
@@ -313,7 +314,6 @@ LOOP_PASS("loop-deletion", LoopDeletionPass()) 
LOOP_PASS("simplify-cfg", LoopSimplifyCFGPass())

LOOP_PASS("strength-reduce", LoopStrengthReducePass())

LOOP_PASS("indvars", IndVarSimplifyPass())

LOOP_PASS("irce", IRCEPass())

LOOP_PASS("unroll-full", LoopFullUnrollPass())

LOOP_PASS("print-access-info", LoopAccessInfoPrinterPass(dbgs()))

LOOP_PASS("print<ddg>", DDGAnalysisPrinterPass(dbgs()))

llvm/lib/Transforms/Scalar/InductiveRangeCheckElimination.cpp

+61 −22
Original line number Diff line number Diff line
@@ -242,20 +242,25 @@ public: 
  bool run(Loop *L, function_ref<void(Loop *, bool)> LPMAddNewLoop);

};



class IRCELegacyPass : public LoopPass {

class IRCELegacyPass : public FunctionPass {

public:

  static char ID;



  IRCELegacyPass() : LoopPass(ID) {

  IRCELegacyPass() : FunctionPass(ID) {

    initializeIRCELegacyPassPass(*PassRegistry::getPassRegistry());

  }



  void getAnalysisUsage(AnalysisUsage &AU) const override {

    AU.addRequired<BranchProbabilityInfoWrapperPass>();

    getLoopAnalysisUsage(AU);

    AU.addRequired<DominatorTreeWrapperPass>();

    AU.addPreserved<DominatorTreeWrapperPass>();

    AU.addRequired<LoopInfoWrapperPass>();

    AU.addPreserved<LoopInfoWrapperPass>();

    AU.addRequired<ScalarEvolutionWrapperPass>();

    AU.addPreserved<ScalarEvolutionWrapperPass>();

  }



  bool runOnLoop(Loop *L, LPPassManager &LPM) override;

  bool runOnFunction(Function &F) override;

};



} // end anonymous namespace
@@ -265,7 +270,9 @@ char IRCELegacyPass::ID = 0; 
INITIALIZE_PASS_BEGIN(IRCELegacyPass, "irce",

                      "Inductive range check elimination", false, false)

INITIALIZE_PASS_DEPENDENCY(BranchProbabilityInfoWrapperPass)

INITIALIZE_PASS_DEPENDENCY(LoopPass)

INITIALIZE_PASS_DEPENDENCY(DominatorTreeWrapperPass)

INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)

INITIALIZE_PASS_DEPENDENCY(ScalarEvolutionWrapperPass)

INITIALIZE_PASS_END(IRCELegacyPass, "irce", "Inductive range check elimination",

                    false, false)
@@ -1747,27 +1754,42 @@ IntersectUnsignedRange(ScalarEvolution &SE, 
  return Ret;

}



PreservedAnalyses IRCEPass::run(Loop &L, LoopAnalysisManager &AM,

                                LoopStandardAnalysisResults &AR,

                                LPMUpdater &U) {

  Function *F = L.getHeader()->getParent();

  const auto &FAM =

      AM.getResult<FunctionAnalysisManagerLoopProxy>(L, AR).getManager();

  auto *BPI = FAM.getCachedResult<BranchProbabilityAnalysis>(*F);

  InductiveRangeCheckElimination IRCE(AR.SE, BPI, AR.DT, AR.LI);

  auto LPMAddNewLoop = [&U](Loop *NL, bool IsSubloop) {

PreservedAnalyses IRCEPass::run(Function &F, FunctionAnalysisManager &AM) {

  auto &SE = AM.getResult<ScalarEvolutionAnalysis>(F);

  auto &DT = AM.getResult<DominatorTreeAnalysis>(F);

  LoopInfo &LI = AM.getResult<LoopAnalysis>(F);



  BranchProbabilityInfo BPI;

  BPI.calculate(F, LI);

  InductiveRangeCheckElimination IRCE(SE, &BPI, DT, LI);



  bool Changed = false;



  for (const auto &L : LI) {

    Changed |= simplifyLoop(L, &DT, &LI, &SE, nullptr, nullptr,

                            /*PreserveLCSSA=*/false);

    Changed |= formLCSSARecursively(*L, DT, &LI, &SE);

  }



  SmallPriorityWorklist<Loop *, 4> Worklist;

  appendLoopsToWorklist(LI, Worklist);

  auto LPMAddNewLoop = [&Worklist](Loop *NL, bool IsSubloop) {

    if (!IsSubloop)

      U.addSiblingLoops(NL);

      appendLoopsToWorklist(*NL, Worklist);

  };

  bool Changed = IRCE.run(&L, LPMAddNewLoop);



  while (!Worklist.empty()) {

    Loop *L = Worklist.pop_back_val();

    Changed |= IRCE.run(L, LPMAddNewLoop);

  }



  if (!Changed)

    return PreservedAnalyses::all();



  return getLoopPassPreservedAnalyses();

}



bool IRCELegacyPass::runOnLoop(Loop *L, LPPassManager &LPM) {

  if (skipLoop(L))

bool IRCELegacyPass::runOnFunction(Function &F) {

  if (skipFunction(F))

    return false;



  ScalarEvolution &SE = getAnalysis<ScalarEvolutionWrapperPass>().getSE();
@@ -1776,10 +1798,27 @@ bool IRCELegacyPass::runOnLoop(Loop *L, LPPassManager &LPM) { 
  auto &DT = getAnalysis<DominatorTreeWrapperPass>().getDomTree();

  auto &LI = getAnalysis<LoopInfoWrapperPass>().getLoopInfo();

  InductiveRangeCheckElimination IRCE(SE, &BPI, DT, LI);

  auto LPMAddNewLoop = [&LPM](Loop *NL, bool /* IsSubLoop */) {

    LPM.addLoop(*NL);



  bool Changed = false;



  for (const auto &L : LI) {

    Changed |= simplifyLoop(L, &DT, &LI, &SE, nullptr, nullptr,

                            /*PreserveLCSSA=*/false);

    Changed |= formLCSSARecursively(*L, DT, &LI, &SE);

  }



  SmallPriorityWorklist<Loop *, 4> Worklist;

  appendLoopsToWorklist(LI, Worklist);

  auto LPMAddNewLoop = [&](Loop *NL, bool IsSubloop) {

    if (!IsSubloop)

      appendLoopsToWorklist(*NL, Worklist);

  };

  return IRCE.run(L, LPMAddNewLoop);



  while (!Worklist.empty()) {

    Loop *L = Worklist.pop_back_val();

    Changed |= IRCE.run(L, LPMAddNewLoop);

  }

  return Changed;

}



bool InductiveRangeCheckElimination::run(

llvm/lib/Transforms/Utils/LoopUtils.cpp

+4 −0
Original line number Diff line number Diff line
@@ -1488,6 +1488,10 @@ void llvm::appendLoopsToWorklist(RangeT &&Loops, 
template void llvm::appendLoopsToWorklist<ArrayRef<Loop *> &>(

    ArrayRef<Loop *> &Loops, SmallPriorityWorklist<Loop *, 4> &Worklist);



template void

llvm::appendLoopsToWorklist<Loop &>(Loop &L,

                                    SmallPriorityWorklist<Loop *, 4> &Worklist);



void llvm::appendLoopsToWorklist(LoopInfo &LI,

                                 SmallPriorityWorklist<Loop *, 4> &Worklist) {

  appendReversedLoopsToWorklist(LI, Worklist);

llvm/test/Transforms/IRCE/add-metadata-pre-post-loops.ll

+1 −1
Original line number Diff line number Diff line 
; RUN: opt -irce -S < %s 2>&1 | FileCheck %s

; RUN: opt -passes='require<branch-prob>,loop(irce)' -S < %s 2>&1 | FileCheck %s

; RUN: opt -passes='require<branch-prob>,irce' -S < %s 2>&1 | FileCheck %s



; test that the pre and post loops have loop metadata which disables any further

; loop optimizations.