[Hexagon] Make HexagonVLCR compatibile with New PM

[quic_aankit]

Summary

The patch modifies HexagonVectorLoopCarriedReuse pass to make it compatible with both Legacy Pass Manager through HexagonVectorLoopCarriedReuseLegacyPass and with New Pass Manager through HexagonVectorLoopCarriedReusePass.

[pzheng]

Is there any test case for this pass? Please also run clang-format.

llvm/lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.cpp

279

Is this removed intentionally?

[quic_aankit]

llvm/lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.cpp

279

Yeah. I did find it being used anywhere

[quic_aankit]

Ran clang-format on the patch

[pzheng]

Is there any existing test case for this pass with the legacy pass manager? If so, you might want to add one with the new pass manager too.

[quic_aankit]

In D86955#2261498, @pzheng wrote:

Is there any existing test case for this pass with the legacy pass manager? If so, you might want to add one with the new pass manager too.

All the existing testcases use opt to run the pass. The pass is not run integrated in the main list of passes for any -Ox level.

[pzheng]

In D86955#2261510, @quic_aankit wrote:

In D86955#2261498, @pzheng wrote:

Is there any existing test case for this pass with the legacy pass manager? If so, you might want to add one with the new pass manager too.

All the existing testcases use opt to run the pass. The pass is not run integrated in the main list of passes for any -Ox level.

That's what I meant. For each legacy pass manager test "RUN: opt -hexagon-vlcr ...", you can add a corresponding new pass manager test "RUN: opt -passes=hexagon-vlcr". This way, we will have the same test coverage with both the legacy and new pass managers.

[quic_aankit]

In D86955#2261551, @pzheng wrote:

In D86955#2261510, @quic_aankit wrote:

In D86955#2261498, @pzheng wrote:

Is there any existing test case for this pass with the legacy pass manager? If so, you might want to add one with the new pass manager too.

All the existing testcases use opt to run the pass. The pass is not run integrated in the main list of passes for any -Ox level.

That's what I meant. For each legacy pass manager test "RUN: opt -hexagon-vlcr ...", you can add a corresponding new pass manager test "RUN: opt -passes=hexagon-vlcr". This way, we will have the same test coverage with both the legacy and new pass managers.

Hi pzheng, I could not figure out a way to register a target specific pass in opt? I can see that llvm/lib/Passes/PassRegistry.def is the registry for target independent passes. Can you point me to an example/API which can help me in registering this pass so that I can use it -passes option in opt?

[pzheng]

In D86955#2271328, @quic_aankit wrote:

In D86955#2261551, @pzheng wrote:

In D86955#2261510, @quic_aankit wrote:

In D86955#2261498, @pzheng wrote:

Is there any existing test case for this pass with the legacy pass manager? If so, you might want to add one with the new pass manager too.

All the existing testcases use opt to run the pass. The pass is not run integrated in the main list of passes for any -Ox level.

That's what I meant. For each legacy pass manager test "RUN: opt -hexagon-vlcr ...", you can add a corresponding new pass manager test "RUN: opt -passes=hexagon-vlcr". This way, we will have the same test coverage with both the legacy and new pass managers.

Hi pzheng, I could not figure out a way to register a target specific pass in opt? I can see that llvm/lib/Passes/PassRegistry.def is the registry for target independent passes. Can you point me to an example/API which can help me in registering this pass so that I can use it -passes option in opt?

I am not sure if there is a better place to register the pass other than PassRegistry.def. Maybe someone who knows can comment on this.

[quic_aankit]

In D86955#2274924, @pzheng wrote:

In D86955#2271328, @quic_aankit wrote:

In D86955#2261551, @pzheng wrote:

In D86955#2261510, @quic_aankit wrote:

In D86955#2261498, @pzheng wrote:

Is there any existing test case for this pass with the legacy pass manager? If so, you might want to add one with the new pass manager too.

All the existing testcases use opt to run the pass. The pass is not run integrated in the main list of passes for any -Ox level.

That's what I meant. For each legacy pass manager test "RUN: opt -hexagon-vlcr ...", you can add a corresponding new pass manager test "RUN: opt -passes=hexagon-vlcr". This way, we will have the same test coverage with both the legacy and new pass managers.

Hi pzheng, I could not figure out a way to register a target specific pass in opt? I can see that llvm/lib/Passes/PassRegistry.def is the registry for target independent passes. Can you point me to an example/API which can help me in registering this pass so that I can use it -passes option in opt?

I am not sure if there is a better place to register the pass other than PassRegistry.def. Maybe someone who knows can comment on this.

Hi pzheng, testing target specific passes using opt+NPM is not currently supported and the work is still work-in-progress. Can we land this without modifying the testcases for now?

[pzheng]

In D86955#2280318, @quic_aankit wrote:

In D86955#2274924, @pzheng wrote:

In D86955#2271328, @quic_aankit wrote:

In D86955#2261551, @pzheng wrote:

In D86955#2261510, @quic_aankit wrote:

In D86955#2261498, @pzheng wrote:

Is there any existing test case for this pass with the legacy pass manager? If so, you might want to add one with the new pass manager too.

All the existing testcases use opt to run the pass. The pass is not run integrated in the main list of passes for any -Ox level.

That's what I meant. For each legacy pass manager test "RUN: opt -hexagon-vlcr ...", you can add a corresponding new pass manager test "RUN: opt -passes=hexagon-vlcr". This way, we will have the same test coverage with both the legacy and new pass managers.

Hi pzheng, I could not figure out a way to register a target specific pass in opt? I can see that llvm/lib/Passes/PassRegistry.def is the registry for target independent passes. Can you point me to an example/API which can help me in registering this pass so that I can use it -passes option in opt?

I am not sure if there is a better place to register the pass other than PassRegistry.def. Maybe someone who knows can comment on this.

Hi pzheng, testing target specific passes using opt+NPM is not currently supported and the work is still work-in-progress. Can we land this without modifying the testcases for now?

Hi @quic_aankit, just to be clear, you tried registering the pass in PassRegistry.def, but still couldn't get "opt -passes=hexagon-vlcr" to work, right? If so, I am fine with leaving out the tests for now, but we should probably mention in the commit message that tests are still to be ported.

[quic_aankit]

In D86955#2283186, @pzheng wrote:

In D86955#2280318, @quic_aankit wrote:

In D86955#2274924, @pzheng wrote:

In D86955#2271328, @quic_aankit wrote:

In D86955#2261551, @pzheng wrote:

In D86955#2261510, @quic_aankit wrote:

In D86955#2261498, @pzheng wrote:

Is there any existing test case for this pass with the legacy pass manager? If so, you might want to add one with the new pass manager too.

All the existing testcases use opt to run the pass. The pass is not run integrated in the main list of passes for any -Ox level.

That's what I meant. For each legacy pass manager test "RUN: opt -hexagon-vlcr ...", you can add a corresponding new pass manager test "RUN: opt -passes=hexagon-vlcr". This way, we will have the same test coverage with both the legacy and new pass managers.

Hi pzheng, I could not figure out a way to register a target specific pass in opt? I can see that llvm/lib/Passes/PassRegistry.def is the registry for target independent passes. Can you point me to an example/API which can help me in registering this pass so that I can use it -passes option in opt?

I am not sure if there is a better place to register the pass other than PassRegistry.def. Maybe someone who knows can comment on this.

Hi pzheng, testing target specific passes using opt+NPM is not currently supported and the work is still work-in-progress. Can we land this without modifying the testcases for now?

Hi @quic_aankit, just to be clear, you tried registering the pass in PassRegistry.def, but still couldn't get "opt -passes=hexagon-vlcr" to work, right? If so, I am fine with leaving out the tests for now, but we should probably mention in the commit message that tests are still to be ported.

Yes @pzheng . I cannot register the pass the in PassRegisry.def as I cannot include the requried header file from lib/target/hexagon. The LLVM community confirmed that testing target specific passes using opt is a work in progress and not supported yet.

llvm/lib/Target/Hexagon/HexagonTargetMachine.cpp

 //===----------------------------------------------------------------------===//
 
 #include "HexagonTargetMachine.h"
 #include "Hexagon.h"
 #include "HexagonISelLowering.h"
 #include "HexagonMachineScheduler.h"
 #include "HexagonTargetObjectFile.h"
 #include "HexagonTargetTransformInfo.h"
+#include "HexagonVectorLoopCarriedReuse.h"
 #include "TargetInfo/HexagonTargetInfo.h"
 #include "llvm/CodeGen/Passes.h"
 #include "llvm/CodeGen/TargetPassConfig.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/TargetRegistry.h"
 #include "llvm/Transforms/IPO/PassManagerBuilder.h"
namespace llvm {
   void initializeHexagonBitSimplifyPass(PassRegistry&);
   void initializeHexagonConstExtendersPass(PassRegistry&);
   void initializeHexagonConstPropagationPass(PassRegistry&);
   void initializeHexagonEarlyIfConversionPass(PassRegistry&);
   void initializeHexagonExpandCondsetsPass(PassRegistry&);
   void initializeHexagonGenMuxPass(PassRegistry&);
   void initializeHexagonHardwareLoopsPass(PassRegistry&);
   void initializeHexagonLoopIdiomRecognizePass(PassRegistry&);
-  void initializeHexagonVectorLoopCarriedReusePass(PassRegistry&);
+  void initializeHexagonVectorLoopCarriedReuseLegacyPassPass(PassRegistry&);
   void initializeHexagonNewValueJumpPass(PassRegistry&);
   void initializeHexagonOptAddrModePass(PassRegistry&);
   void initializeHexagonPacketizerPass(PassRegistry&);
   void initializeHexagonRDFOptPass(PassRegistry&);
   void initializeHexagonSplitDoubleRegsPass(PassRegistry&);
   void initializeHexagonVExtractPass(PassRegistry&);
   Pass *createHexagonLoopIdiomPass();
-  Pass *createHexagonVectorLoopCarriedReusePass();
+  Pass *createHexagonVectorLoopCarriedReuseLegacyPass();
 
   FunctionPass *createHexagonBitSimplify();
   FunctionPass *createHexagonBranchRelaxation();
   FunctionPass *createHexagonCallFrameInformation();
   FunctionPass *createHexagonCFGOptimizer();
   FunctionPass *createHexagonCommonGEP();
   FunctionPass *createHexagonConstExtenders();
   FunctionPass *createHexagonConstPropagationPass();
extern "C" LLVM_EXTERNAL_VISIBILITY void LLVMInitializeHexagonTarget() {
   PassRegistry &PR = *PassRegistry::getPassRegistry();
   initializeHexagonBitSimplifyPass(PR);
   initializeHexagonConstExtendersPass(PR);
   initializeHexagonConstPropagationPass(PR);
   initializeHexagonEarlyIfConversionPass(PR);
   initializeHexagonGenMuxPass(PR);
   initializeHexagonHardwareLoopsPass(PR);
   initializeHexagonLoopIdiomRecognizePass(PR);
-  initializeHexagonVectorLoopCarriedReusePass(PR);
+  initializeHexagonVectorLoopCarriedReuseLegacyPassPass(PR);
   initializeHexagonNewValueJumpPass(PR);
   initializeHexagonOptAddrModePass(PR);
   initializeHexagonPacketizerPass(PR);
   initializeHexagonRDFOptPass(PR);
   initializeHexagonSplitDoubleRegsPass(PR);
   initializeHexagonVExtractPass(PR);
 }
 
HexagonTargetMachine::getSubtargetImpl(const Function &F) const {
   return I.get();
 }
 
 void HexagonTargetMachine::adjustPassManager(PassManagerBuilder &PMB) {
   PMB.addExtension(
     PassManagerBuilder::EP_LateLoopOptimizations,
     [&](const PassManagerBuilder &, legacy::PassManagerBase &PM) {
       PM.add(createHexagonLoopIdiomPass());
     });
   PMB.addExtension(
     PassManagerBuilder::EP_LoopOptimizerEnd,
     [&](const PassManagerBuilder &, legacy::PassManagerBase &PM) {
-      PM.add(createHexagonVectorLoopCarriedReusePass());
+      PM.add(createHexagonVectorLoopCarriedReuseLegacyPass());
     });
 }
 
 TargetTransformInfo
 HexagonTargetMachine::getTargetTransformInfo(const Function &F) {
   return TargetTransformInfo(HexagonTTIImpl(this, F));
 }
 

llvm/lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.h

+//===- HexagonVectorLoopCarriedReuse.h ------------------------------------===//
+//
+// 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
+//
+//===----------------------------------------------------------------------===//
+//
+// This pass removes the computation of provably redundant expressions that have
+// been computed earlier in a previous iteration. It relies on the use of PHIs
+// to identify loop carried dependences. This is scalar replacement for vector
+// types.
+//
+//-----------------------------------------------------------------------------
+// Motivation: Consider the case where we have the following loop structure.
+//
+// Loop:
+//  t0 = a[i];
+//  t1 = f(t0);
+//  t2 = g(t1);
+//  ...
+//  t3 = a[i+1];
+//  t4 = f(t3);
+//  t5 = g(t4);
+//  t6 = op(t2, t5)
+//  cond_branch <Loop>
+//
+// This can be converted to
+//  t00 = a[0];
+//  t10 = f(t00);
+//  t20 = g(t10);
+// Loop:
+//  t2 = t20;
+//  t3 = a[i+1];
+//  t4 = f(t3);
+//  t5 = g(t4);
+//  t6 = op(t2, t5)
+//  t20 = t5
+//  cond_branch <Loop>
+//
+// SROA does a good job of reusing a[i+1] as a[i] in the next iteration.
+// Such a loop comes to this pass in the following form.
+//
+// LoopPreheader:
+//  X0 = a[0];
+// Loop:
+//  X2 = PHI<(X0, LoopPreheader), (X1, Loop)>
+//  t1 = f(X2)   <-- I1
+//  t2 = g(t1)
+//  ...
+//  X1 = a[i+1]
+//  t4 = f(X1)   <-- I2
+//  t5 = g(t4)
+//  t6 = op(t2, t5)
+//  cond_branch <Loop>
+//
+// In this pass, we look for PHIs such as X2 whose incoming values come only
+// from the Loop Preheader and over the backedge and additionaly, both these
+// values are the results of the same operation in terms of opcode. We call such
+// a PHI node a dependence chain or DepChain. In this case, the dependence of X2
+// over X1 is carried over only one iteration and so the DepChain is only one
+// PHI node long.
+//
+// Then, we traverse the uses of the PHI (X2) and the uses of the value of the
+// PHI coming  over the backedge (X1). We stop at the first pair of such users
+// I1 (of X2) and I2 (of X1) that meet the following conditions.
+// 1. I1 and I2 are the same operation, but with different operands.
+// 2. X2 and X1 are used at the same operand number in the two instructions.
+// 3. All other operands Op1 of I1 and Op2 of I2 are also such that there is a
+//    a DepChain from Op1 to Op2 of the same length as that between X2 and X1.
+//
+// We then make the following transformation
+// LoopPreheader:
+//  X0 = a[0];
+//  Y0 = f(X0);
+// Loop:
+//  X2 = PHI<(X0, LoopPreheader), (X1, Loop)>
+//  Y2 = PHI<(Y0, LoopPreheader), (t4, Loop)>
+//  t1 = f(X2)   <-- Will be removed by DCE.
+//  t2 = g(Y2)
+//  ...
+//  X1 = a[i+1]
+//  t4 = f(X1)
+//  t5 = g(t4)
+//  t6 = op(t2, t5)
+//  cond_branch <Loop>
+//
+// We proceed until we cannot find any more such instructions I1 and I2.
+//
+// --- DepChains & Loop carried dependences ---
+// Consider a single basic block loop such as
+//
+// LoopPreheader:
+//  X0 = ...
+//  Y0 = ...
+// Loop:
+//  X2 = PHI<(X0, LoopPreheader), (X1, Loop)>
+//  Y2 = PHI<(Y0, LoopPreheader), (X2, Loop)>
+//  ...
+//  X1 = ...
+//  ...
+//  cond_branch <Loop>
+//
+// Then there is a dependence between X2 and X1 that goes back one iteration,
+// i.e. X1 is used as X2 in the very next iteration. We represent this as a
+// DepChain from X2 to X1 (X2->X1).
+// Similarly, there is a dependence between Y2 and X1 that goes back two
+// iterations. X1 is used as Y2 two iterations after it is computed. This is
+// represented by a DepChain as (Y2->X2->X1).
+//
+// A DepChain has the following properties.
+// 1. Num of edges in DepChain = Number of Instructions in DepChain = Number of
+//    iterations of carried dependence + 1.
+// 2. All instructions in the DepChain except the last are PHIs.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIB_TARGET_HEXAGON_HEXAGONVLCR_H
+#define LLVM_LIB_TARGET_HEXAGON_HEXAGONVLCR_H
+
+#include "llvm/Transforms/Scalar/LoopPassManager.h"
+
+namespace llvm {
+
+class Loop;
+
+/// Hexagon Vector Loop Carried Reuse Pass
+struct HexagonVectorLoopCarriedReusePass
+    : public PassInfoMixin<HexagonVectorLoopCarriedReusePass> {
+  HexagonVectorLoopCarriedReusePass() {}
+
+  /// Run pass over the Loop.
+  PreservedAnalyses run(Loop &L, LoopAnalysisManager &LAM,
+                        LoopStandardAnalysisResults &AR, LPMUpdater &U);
+};
+
+} // end namespace llvm
+
+#endif // LLVM_LIB_TARGET_HEXAGON_HEXAGONVLCR_H

llvm/lib/Target/Hexagon/HexagonVectorLoopCarriedReuse.cpp

 //===- HexagonVectorLoopCarriedReuse.cpp ----------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 //
 // This pass removes the computation of provably redundant expressions that have
 // been computed earlier in a previous iteration. It relies on the use of PHIs
 // to identify loop carried dependences. This is scalar replacement for vector
 // types.
 //
-//-----------------------------------------------------------------------------
-// Motivation: Consider the case where we have the following loop structure.
-//
-// Loop:
-//  t0 = a[i];
-//  t1 = f(t0);
-//  t2 = g(t1);
-//  ...
-//  t3 = a[i+1];
-//  t4 = f(t3);
-//  t5 = g(t4);
-//  t6 = op(t2, t5)
-//  cond_branch <Loop>
-//
-// This can be converted to
-//  t00 = a[0];
-//  t10 = f(t00);
-//  t20 = g(t10);
-// Loop:
-//  t2 = t20;
-//  t3 = a[i+1];
-//  t4 = f(t3);
-//  t5 = g(t4);
-//  t6 = op(t2, t5)
-//  t20 = t5
-//  cond_branch <Loop>
-//
-// SROA does a good job of reusing a[i+1] as a[i] in the next iteration.
-// Such a loop comes to this pass in the following form.
-//
-// LoopPreheader:
-//  X0 = a[0];
-// Loop:
-//  X2 = PHI<(X0, LoopPreheader), (X1, Loop)>
-//  t1 = f(X2)   <-- I1
-//  t2 = g(t1)
-//  ...
-//  X1 = a[i+1]
-//  t4 = f(X1)   <-- I2
-//  t5 = g(t4)
-//  t6 = op(t2, t5)
-//  cond_branch <Loop>
-//
-// In this pass, we look for PHIs such as X2 whose incoming values come only
-// from the Loop Preheader and over the backedge and additionaly, both these
-// values are the results of the same operation in terms of opcode. We call such
-// a PHI node a dependence chain or DepChain. In this case, the dependence of X2
-// over X1 is carried over only one iteration and so the DepChain is only one
-// PHI node long.
-//
-// Then, we traverse the uses of the PHI (X2) and the uses of the value of the
-// PHI coming  over the backedge (X1). We stop at the first pair of such users
-// I1 (of X2) and I2 (of X1) that meet the following conditions.
-// 1. I1 and I2 are the same operation, but with different operands.
-// 2. X2 and X1 are used at the same operand number in the two instructions.
-// 3. All other operands Op1 of I1 and Op2 of I2 are also such that there is a
-//    a DepChain from Op1 to Op2 of the same length as that between X2 and X1.
-//
-// We then make the following transformation
-// LoopPreheader:
-//  X0 = a[0];
-//  Y0 = f(X0);
-// Loop:
-//  X2 = PHI<(X0, LoopPreheader), (X1, Loop)>
-//  Y2 = PHI<(Y0, LoopPreheader), (t4, Loop)>
-//  t1 = f(X2)   <-- Will be removed by DCE.
-//  t2 = g(Y2)
-//  ...
-//  X1 = a[i+1]
-//  t4 = f(X1)
-//  t5 = g(t4)
-//  t6 = op(t2, t5)
-//  cond_branch <Loop>
-//
-// We proceed until we cannot find any more such instructions I1 and I2.
-//
-// --- DepChains & Loop carried dependences ---
-// Consider a single basic block loop such as
-//
-// LoopPreheader:
-//  X0 = ...
-//  Y0 = ...
-// Loop:
-//  X2 = PHI<(X0, LoopPreheader), (X1, Loop)>
-//  Y2 = PHI<(Y0, LoopPreheader), (X2, Loop)>
-//  ...
-//  X1 = ...
-//  ...
-//  cond_branch <Loop>
-//
-// Then there is a dependence between X2 and X1 that goes back one iteration,
-// i.e. X1 is used as X2 in the very next iteration. We represent this as a
-// DepChain from X2 to X1 (X2->X1).
-// Similarly, there is a dependence between Y2 and X1 that goes back two
-// iterations. X1 is used as Y2 two iterations after it is computed. This is
-// represented by a DepChain as (Y2->X2->X1).
-//
-// A DepChain has the following properties.
-// 1. Num of edges in DepChain = Number of Instructions in DepChain = Number of
-//    iterations of carried dependence + 1.
-// 2. All instructions in the DepChain except the last are PHIs.
-//
 //===----------------------------------------------------------------------===//
 
+#include "HexagonVectorLoopCarriedReuse.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/LoopPass.h"
 #include "llvm/IR/BasicBlock.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/IRBuilder.h"

 
 static cl::opt<int> HexagonVLCRIterationLim("hexagon-vlcr-iteration-lim",
     cl::Hidden,
     cl::desc("Maximum distance of loop carried dependences that are handled"),
     cl::init(2), cl::ZeroOrMore);
 
 namespace llvm {
 
-void initializeHexagonVectorLoopCarriedReusePass(PassRegistry&);
-Pass *createHexagonVectorLoopCarriedReusePass();
+void initializeHexagonVectorLoopCarriedReuseLegacyPassPass(PassRegistry&);
+Pass *createHexagonVectorLoopCarriedReuseLegacyPass();
 
 } // end namespace llvm
 
 namespace {
 
   // See info about DepChain in the comments at the top of this file.
   using ChainOfDependences = SmallVector<Instruction *, 4>;
 
namespace {
   LLVM_ATTRIBUTE_UNUSED
   raw_ostream &operator<<(raw_ostream &OS, const ReuseValue &RU) {
     OS << "** ReuseValue ***\n";
     OS << "Instruction to Replace: " << *(RU.Inst2Replace) << "\n";
     OS << "Backedge Instruction: " << *(RU.BackedgeInst) << "\n";
     return OS;
   }
 
-  class HexagonVectorLoopCarriedReuse : public LoopPass {
+  class HexagonVectorLoopCarriedReuseLegacyPass : public LoopPass {
   public:
     static char ID;
 
-    explicit HexagonVectorLoopCarriedReuse() : LoopPass(ID) {
+    explicit HexagonVectorLoopCarriedReuseLegacyPass() : LoopPass(ID) {
       PassRegistry *PR = PassRegistry::getPassRegistry();
-      initializeHexagonVectorLoopCarriedReusePass(*PR);
+      initializeHexagonVectorLoopCarriedReuseLegacyPassPass(*PR);
     }
 
     StringRef getPassName() const override {
       return "Hexagon-specific loop carried reuse for HVX vectors";
     }
 
     void getAnalysisUsage(AnalysisUsage &AU) const override {
-      AU.addRequired<LoopInfoWrapperPass>();
       AU.addRequiredID(LoopSimplifyID);
       AU.addRequiredID(LCSSAID);
       AU.addPreservedID(LCSSAID);
       AU.setPreservesCFG();
     }
 
     bool runOnLoop(Loop *L, LPPassManager &LPM) override;
+  };
+
+  class HexagonVectorLoopCarriedReuse {
+  public:
+    HexagonVectorLoopCarriedReuse(Loop *L) : CurLoop(L){};
+
+    bool run();
 
   private:
     SetVector<DepChain *> Dependences;
     std::set<Instruction *> ReplacedInsts;
     Loop *CurLoop;
     ReuseValue ReuseCandidate;
 
     bool doVLCR();
     void findLoopCarriedDeps();
     void findValueToReuse();
     void findDepChainFromPHI(Instruction *I, DepChain &D);
     void reuseValue();
     Value *findValueInBlock(Value *Op, BasicBlock *BB);
     DepChain *getDepChainBtwn(Instruction *I1, Instruction *I2, int Iters);
     bool isEquivalentOperation(Instruction *I1, Instruction *I2);
     bool canReplace(Instruction *I);
     bool isCallInstCommutative(CallInst *C);
   };
 
 } // end anonymous namespace
 
-char HexagonVectorLoopCarriedReuse::ID = 0;
+char HexagonVectorLoopCarriedReuseLegacyPass::ID = 0;
 
-INITIALIZE_PASS_BEGIN(HexagonVectorLoopCarriedReuse, "hexagon-vlcr",
-    "Hexagon-specific predictive commoning for HVX vectors", false, false)
-INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
+INITIALIZE_PASS_BEGIN(HexagonVectorLoopCarriedReuseLegacyPass, "hexagon-vlcr",
+                      "Hexagon-specific predictive commoning for HVX vectors",
+                      false, false)
 INITIALIZE_PASS_DEPENDENCY(LoopSimplify)
 INITIALIZE_PASS_DEPENDENCY(LCSSAWrapperPass)
-INITIALIZE_PASS_END(HexagonVectorLoopCarriedReuse, "hexagon-vlcr",
-    "Hexagon-specific predictive commoning for HVX vectors", false, false)
+INITIALIZE_PASS_END(HexagonVectorLoopCarriedReuseLegacyPass, "hexagon-vlcr",
+                    "Hexagon-specific predictive commoning for HVX vectors",
+                    false, false)
+
+PreservedAnalyses
+HexagonVectorLoopCarriedReusePass::run(Loop &L, LoopAnalysisManager &LAM,
+                                       LoopStandardAnalysisResults &AR,
+                                       LPMUpdater &U) {
+  HexagonVectorLoopCarriedReuse Vlcr(&L);
+  if (!Vlcr.run())
+    return PreservedAnalyses::all();
+  PreservedAnalyses PA;
+  PA.preserveSet<CFGAnalyses>();
+  return PA;
+}
 
-bool HexagonVectorLoopCarriedReuse::runOnLoop(Loop *L, LPPassManager &LPM) {
+bool HexagonVectorLoopCarriedReuseLegacyPass::runOnLoop(Loop *L,
+                                                        LPPassManager &LPM) {
   if (skipLoop(L))
     return false;
+  HexagonVectorLoopCarriedReuse Vlcr(L);
+  return Vlcr.run();
+}
 
-  if (!L->getLoopPreheader())
+bool HexagonVectorLoopCarriedReuse::run() {
+  if (!CurLoop->getLoopPreheader())
     return false;
 
   // Work only on innermost loops.
-  if (!L->getSubLoops().empty())
+  if (!CurLoop->getSubLoops().empty())
     return false;
 
   // Work only on single basic blocks loops.
-  if (L->getNumBlocks() != 1)
+  if (CurLoop->getNumBlocks() != 1)
     return false;
 
-  CurLoop = L;
-
   return doVLCR();
 }
 
 bool HexagonVectorLoopCarriedReuse::isCallInstCommutative(CallInst *C) {
   switch (C->getCalledFunction()->getIntrinsicID()) {
     case Intrinsic::hexagon_V6_vaddb:
     case Intrinsic::hexagon_V6_vaddb_128B:
     case Intrinsic::hexagon_V6_vaddh:
for (auto I = BB->begin(), E = BB->end(); I != E && isa<PHINode>(I); ++I) {
     else
       delete D;
   }
   LLVM_DEBUG(dbgs() << "Found " << Dependences.size() << " dependences\n");
   LLVM_DEBUG(for (size_t i = 0; i < Dependences.size();
                   ++i) { dbgs() << *Dependences[i] << "\n"; });
 }
 
-Pass *llvm::createHexagonVectorLoopCarriedReusePass() {
-  return new HexagonVectorLoopCarriedReuse();
+Pass *llvm::createHexagonVectorLoopCarriedReuseLegacyPass() {
+  return new HexagonVectorLoopCarriedReuseLegacyPass();
 }