[Delinearization][NewPM] Port delinearization to NPM

[aeubanks]

Summary

Also make tests in Analysis/Delinearization work under NPM.

[asbirlea]

llvm/lib/Analysis/Delinearization.cpp

59–60

s/PrintDelinearization/printDelinearization

Make this static?

[aeubanks]

rename

llvm/lib/Analysis/Delinearization.cpp

59–60

Renamed.
This is in an anonymous namespace.

llvm/include/llvm/Analysis/Delinearization.h

+//===---- Delinearization.h - MultiDimensional Index Delinearization ------===//
+//
+// 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 implements an analysis pass that tries to delinearize all GEP
+// instructions in all loops using the SCEV analysis functionality. This pass is
+// only used for testing purposes: if your pass needs delinearization, please
+// use the on-demand SCEVAddRecExpr::delinearize() function.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_ANALYSIS_DELINEARIZATION_H
+#define LLVM_ANALYSIS_DELINEARIZATION_H
+
+#include "llvm/IR/PassManager.h"
+#include "llvm/Support/raw_ostream.h"
+
+namespace llvm {
+struct DelinearizationPrinterPass
+    : public PassInfoMixin<DelinearizationPrinterPass> {
+  explicit DelinearizationPrinterPass(raw_ostream &OS);
+  PreservedAnalyses run(Function &F, FunctionAnalysisManager &AM);
+
+private:
+  raw_ostream &OS;
+};
+} // namespace llvm
+
+#endif // LLVM_ANALYSIS_DELINEARIZATION_H

llvm/lib/Analysis/Delinearization.cpp

 //===---- Delinearization.cpp - MultiDimensional Index Delinearization ----===//
 //
 // 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 implements an analysis pass that tries to delinearize all GEP
 // instructions in all loops using the SCEV analysis functionality. This pass is
 // only used for testing purposes: if your pass needs delinearization, please
 // use the on-demand SCEVAddRecExpr::delinearize() function.
 //
 //===----------------------------------------------------------------------===//
 
+#include "llvm/Analysis/Delinearization.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/Passes.h"
 #include "llvm/Analysis/ScalarEvolution.h"
 #include "llvm/Analysis/ScalarEvolutionExpressions.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/InstIterator.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/PassManager.h"
 #include "llvm/IR/Type.h"
 #include "llvm/InitializePasses.h"
 #include "llvm/Pass.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
public:
   Delinearization() : FunctionPass(ID) {
     initializeDelinearizationPass(*PassRegistry::getPassRegistry());
   }
   bool runOnFunction(Function &F) override;
   void getAnalysisUsage(AnalysisUsage &AU) const override;
   void print(raw_ostream &O, const Module *M = nullptr) const override;
 };
 
-} // end anonymous namespace
-
-void Delinearization::getAnalysisUsage(AnalysisUsage &AU) const {
-  AU.setPreservesAll();
-  AU.addRequired<LoopInfoWrapperPass>();
-  AU.addRequired<ScalarEvolutionWrapperPass>();
-}
-
-bool Delinearization::runOnFunction(Function &F) {
-  this->F = &F;
-  SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
-  LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
-  return false;
-}
-
-void Delinearization::print(raw_ostream &O, const Module *) const {
+void printDelinearization(raw_ostream &O, Function *F, LoopInfo *LI,
+                          ScalarEvolution *SE) {
   O << "Delinearization on function " << F->getName() << ":\n";
   for (inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) {
     Instruction *Inst = &(*I);
 
     // Only analyze loads and stores.
     if (!isa<StoreInst>(Inst) && !isa<LoadInst>(Inst) &&
         !isa<GetElementPtrInst>(Inst))
       continue;
for (Loop *L = LI->getLoopFor(BB); L != nullptr; L = L->getParentLoop()) {
       O << "ArrayRef";
       for (int i = 0; i < Size; i++)
         O << "[" << *Subscripts[i] << "]";
       O << "\n";
     }
   }
 }
 
+} // end anonymous namespace
+
+void Delinearization::getAnalysisUsage(AnalysisUsage &AU) const {
+  AU.setPreservesAll();
+  AU.addRequired<LoopInfoWrapperPass>();
+  AU.addRequired<ScalarEvolutionWrapperPass>();
+}
+
+bool Delinearization::runOnFunction(Function &F) {
+  this->F = &F;
+  SE = &getAnalysis<ScalarEvolutionWrapperPass>().getSE();
+  LI = &getAnalysis<LoopInfoWrapperPass>().getLoopInfo();
+  return false;
+}
+
+void Delinearization::print(raw_ostream &O, const Module *) const {
+  printDelinearization(O, F, LI, SE);
+}
+
 char Delinearization::ID = 0;
 static const char delinearization_name[] = "Delinearization";
 INITIALIZE_PASS_BEGIN(Delinearization, DL_NAME, delinearization_name, true,
                       true)
 INITIALIZE_PASS_DEPENDENCY(LoopInfoWrapperPass)
 INITIALIZE_PASS_END(Delinearization, DL_NAME, delinearization_name, true, true)
 
 FunctionPass *llvm::createDelinearizationPass() { return new Delinearization; }
+
+DelinearizationPrinterPass::DelinearizationPrinterPass(raw_ostream &OS)
+    : OS(OS) {}
+PreservedAnalyses DelinearizationPrinterPass::run(Function &F,
+                                                  FunctionAnalysisManager &AM) {
+  printDelinearization(OS, &F, &AM.getResult<LoopAnalysis>(F),
+                       &AM.getResult<ScalarEvolutionAnalysis>(F));
+  return PreservedAnalyses::all();
+}

llvm/lib/Passes/PassBuilder.cpp

 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/Analysis/BranchProbabilityInfo.h"
 #include "llvm/Analysis/CFGPrinter.h"
 #include "llvm/Analysis/CFLAndersAliasAnalysis.h"
 #include "llvm/Analysis/CFLSteensAliasAnalysis.h"
 #include "llvm/Analysis/CGSCCPassManager.h"
 #include "llvm/Analysis/CallGraph.h"
 #include "llvm/Analysis/DDG.h"
+#include "llvm/Analysis/Delinearization.h"
 #include "llvm/Analysis/DemandedBits.h"
 #include "llvm/Analysis/DependenceAnalysis.h"
 #include "llvm/Analysis/DominanceFrontier.h"
 #include "llvm/Analysis/FunctionPropertiesAnalysis.h"
 #include "llvm/Analysis/GlobalsModRef.h"
 #include "llvm/Analysis/IVUsers.h"
 #include "llvm/Analysis/InlineAdvisor.h"
 #include "llvm/Analysis/InlineSizeEstimatorAnalysis.h"

llvm/lib/Passes/PassRegistry.def

 FUNCTION_PASS("pgo-memop-opt", PGOMemOPSizeOpt())
 FUNCTION_PASS("print", PrintFunctionPass(dbgs()))
 FUNCTION_PASS("print<assumptions>", AssumptionPrinterPass(dbgs()))
 FUNCTION_PASS("print<block-freq>", BlockFrequencyPrinterPass(dbgs()))
 FUNCTION_PASS("print<branch-prob>", BranchProbabilityPrinterPass(dbgs()))
 FUNCTION_PASS("print<da>", DependenceAnalysisPrinterPass(dbgs()))
 FUNCTION_PASS("print<domtree>", DominatorTreePrinterPass(dbgs()))
 FUNCTION_PASS("print<postdomtree>", PostDominatorTreePrinterPass(dbgs()))
+FUNCTION_PASS("print<delinearization>", DelinearizationPrinterPass(dbgs()))
 FUNCTION_PASS("print<demanded-bits>", DemandedBitsPrinterPass(dbgs()))
 FUNCTION_PASS("print<domfrontier>", DominanceFrontierPrinterPass(dbgs()))
 FUNCTION_PASS("print<func-properties>", FunctionPropertiesPrinterPass(dbgs()))
 FUNCTION_PASS("print<inline-cost>", InlineCostAnnotationPrinterPass(dbgs()))
 FUNCTION_PASS("print<inliner-size-estimator>", 
   InlineSizeEstimatorAnalysisPrinterPass(dbgs()))
 FUNCTION_PASS("print<loops>", LoopPrinterPass(dbgs()))
 FUNCTION_PASS("print<memoryssa>", MemorySSAPrinterPass(dbgs()))

llvm/test/Analysis/Delinearization/a.ll

-; RUN: opt < %s -analyze -delinearize | FileCheck %s
+; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 ;
 ; void foo(long n, long m, long o, int A[n][m][o]) {
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)
 ;       for (long k = 0; k < o; k++)
 ;         A[2*i+3][3*j-4][5*k+7] = 1;
 ; }
 

llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll

-; RUN: opt -delinearize -analyze < %s | FileCheck %s
+; RUN: opt -delinearize -analyze -enable-new-pm=0 < %s | FileCheck %s
+; RUN: opt -passes='print<delinearization>' -disable-output < %s 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; CHECK:      Inst:  %tmp = load float, float* %arrayidx, align 4
 ; CHECK-NEXT: In Loop with Header: for.inc
 ; CHECK-NEXT: AccessFunction: {(4 * %N * %call),+,4}<nsw><%for.inc>
 ; CHECK-NEXT: Base offset: %A
 ; CHECK-NEXT: ArrayDecl[UnknownSize][%N] with elements of 4 bytes.

llvm/test/Analysis/Delinearization/divide_by_one.ll

-; RUN: opt < %s -analyze -delinearize | FileCheck %s
+; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-p:32:32-i1:32-i64:64-a:0-n32"
 
 ; Check that division by 1 can be delinearized.
 ;
 ; void test1(unsigned char *dst, int stride, int bs) {
 ;   for (int r = bs; r >= 0; --r)
 ;     for (int c = 0; c < bs; ++c)

llvm/test/Analysis/Delinearization/gcd_multiply_expr.ll

-; RUN: opt < %s -basic-aa -da -analyze -delinearize
+; RUN: opt < %s -basic-aa -da -analyze -enable-new-pm=0 -delinearize
+; RUN: opt < %s -aa-pipeline=basic-aa -passes='require<da>,print<delinearization>' -disable-output
 ;
 ; a, b, c, d, g, h;
 ; char *f;
 ; static fn1(p1) {
 ;   char *e = p1;
 ;   for (; d;) {
 ;     a = 0;
 ;     for (;; ++a)

llvm/test/Analysis/Delinearization/himeno_1.ll

-; RUN: opt < %s -analyze -delinearize | FileCheck %s
+; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 ; #define MR(mt,n,r,c,d)  mt->m[(n) * mt->mrows * mt->mcols * mt->mdeps + (r) * mt->mcols* mt->mdeps + (c) * mt->mdeps + (d)]
 ;
 ; struct Mat {
 ;   float* m;
 ;   int mnums;
 ;   int mrows;
 ;   int mcols;

llvm/test/Analysis/Delinearization/himeno_2.ll

-; RUN: opt < %s -analyze -delinearize | FileCheck %s
+; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 ; #define MR(mt,n,r,c,d)  mt->m[(n) * mt->mrows * mt->mcols * mt->mdeps + (r) * mt->mcols* mt->mdeps + (c) * mt->mdeps + (d)]
 ;
 ; struct Mat {
 ;   float* m;
 ;   int mnums;
 ;   int mrows;
 ;   int mcols;

llvm/test/Analysis/Delinearization/iv_times_constant_in_subscript.ll

-; RUN: opt < %s -analyze -delinearize | FileCheck %s
+; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 ; Derived from the following code:
 ;
 ; void foo(long n, long m, long b, double A[n][m]) {
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)
 ;       A[2i+b][2j] = 1.0;
 ; }

llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_3d.ll

-; RUN: opt < %s -analyze -delinearize  | FileCheck %s
+; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize  | FileCheck %s
+; RUN: opt < %s -passes='print<delinearization>' -disable-output  2>&1 | FileCheck %s
 
 ; void foo(long n, long m, long o, double A[n][m][o]) {
 ;
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)
 ;       for (long k = 0; k < o; k++)
 ;         A[i+3][j-4][k+7] = 1.0;
 ; }

llvm/test/Analysis/Delinearization/multidim_ivs_and_integer_offsets_nts_3d.ll

-; RUN: opt < %s -analyze -delinearize | FileCheck %s
+; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 ; void foo(long n, long m, long o, long p, double A[n][m][o+p]) {
 ;
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)
 ;       for (long k = 0; k < o; k++)
 ;         A[i+3][j-4][k+7] = 1.0;
 ; }

llvm/test/Analysis/Delinearization/multidim_ivs_and_parameteric_offsets_3d.ll

-; RUN: opt < %s -analyze -delinearize | FileCheck %s
+; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 ; void foo(long n, long m, long o, double A[n][m][o], long p, long q, long r) {
 ;
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)
 ;       for (long k = 0; k < o; k++)
 ;         A[i+p][j+q][k+r] = 1.0;
 ; }

llvm/test/Analysis/Delinearization/multidim_only_ivs_2d.ll

-; RUN: opt < %s -analyze -delinearize | FileCheck %s
+; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 ; Derived from the following code:
 ;
 ; void foo(long n, long m, double A[n][m]) {
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)
 ;       A[i][j] = 1.0;
 ; }

llvm/test/Analysis/Delinearization/multidim_only_ivs_2d_nested.ll

-; RUN: opt < %s -analyze -delinearize | FileCheck %s
+; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 ; XFAIL: *
 ; We do not recognize anymore variable size arrays.
 
 ; extern void bar(long n, long m, double A[n][m]);
 ;
 ; void foo(long a, long b) {
 ;   for (long n = 1; n < a; ++n)
 ;   for (long m = 1; m < b; ++m) {

llvm/test/Analysis/Delinearization/multidim_only_ivs_3d.ll

-; RUN: opt < %s -analyze -delinearize | FileCheck %s
+; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 ; void foo(long n, long m, long o, double A[n][m][o]) {
 ;
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)
 ;       for (long k = 0; k < o; k++)
 ;         A[i][j][k] = 1.0;
 ; }

llvm/test/Analysis/Delinearization/multidim_only_ivs_3d_cast.ll

-; RUN: opt < %s -analyze -delinearize | FileCheck %s
+; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize | FileCheck %s
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 ; void foo(int n, int m, int o, double A[n][m][o]) {
 ;
 ;   for (int i = 0; i < n; i++)
 ;     for (int j = 0; j < m; j++)
 ;       for (int k = 0; k < o; k++)
 ;         A[i][j][k] = 1.0;
 ; }
 

llvm/test/Analysis/Delinearization/multidim_two_accesses_different_delinearization.ll

-; RUN: opt -basic-aa -da -analyze < %s
+; RUN: opt -basic-aa -da -analyze -enable-new-pm=0 < %s
+; RUN: opt -aa-pipeline=basic-aa -passes='require<da>,print<delinearization>' -disable-output < %s
 target datalayout = "e-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 ; Derived from the following code:
 ;
 ; void foo(long n, long m, double *A) {
 ;   for (long i = 0; i < n; i++)
 ;     for (long j = 0; j < m; j++)

llvm/test/Analysis/Delinearization/parameter_addrec_product.ll

-; RUN: opt -delinearize -analyze < %s | FileCheck %s
+; RUN: opt -delinearize -analyze -enable-new-pm=0 < %s | FileCheck %s
+; RUN: opt -passes='print<delinearization>' -disable-output < %s 2>&1 | FileCheck %s
 ;
 ;    void foo(float *A, long *p) {
 ;      for (long i = 0; i < 100; i++)
 ;        for (long j = 0; j < 100; j++)
 ;          A[i * (*p) + j] += i + j;
 ;    }
 ;
 ; CHECK: ArrayDecl[UnknownSize][%pval] with elements of 4 bytes.

llvm/test/Analysis/Delinearization/terms_with_identity_factor.ll

 ; REQUIRES: asserts
-; RUN: opt < %s -analyze -delinearize -debug 2>&1 | FileCheck %s
+; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize -debug 2>&1 | FileCheck %s
+; RUN: opt < %s -passes='print<delinearization>' -disable-output -debug 2>&1 2>&1 | FileCheck %s
 ; void foo (int m, int n, char *A) {
 ;    for (int i=0; i < m; i++)
 ;      for(int j=0; j< n; j++)
 ;        A[i*n+j] += 1;
 ;}
 
 ; ModuleID = 'delin.cpp'
 ;target datalayout = "e-m:e-i64:64-i128:128-n32:64-S128"

llvm/test/Analysis/Delinearization/type_mismatch.ll

-; RUN: opt < %s -analyze -delinearize
+; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize
+; RUN: opt < %s -passes='print<delinearization>' -disable-output
 ; REQUIRES: asserts
 
 ; Test that SCEV divide code doesn't crash when attempting to create a SCEV
 ; with operands of different types. In this case, the visitAddRecExpr
 ; function tries to create an AddRec where the start and step are different
 ; types.
 
 target datalayout = "e-m:e-p:32:32-i64:64-a:0-v32:32-n16:32"

llvm/test/Analysis/Delinearization/undef.ll

-; RUN: opt < %s -analyze -delinearize
+; RUN: opt < %s -analyze -enable-new-pm=0 -delinearize
+; RUN: opt < %s -passes='print<delinearization>' -disable-output
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 target triple = "x86_64-unknown-linux-gnu"
 
 define void @foo(double* %Ey) {
 entry:
   br i1 undef, label %for.cond55.preheader, label %for.end324
 
 for.cond55.preheader: