[delinearize] use update_analyze_test_checks.py in delinearization testcases (#153831)

In this patch:
1. Adapt the output of printDelinearization() to match what the script
   expects to see, "Printing analysis 'Delinearization' for function".
2. Register the "Delinearization" pass in the update script.
3. Automatically remove the existing CHECK statements.
4. Update the tests with a run of:
```
$ ~/llvm-project/llvm/utils/update_analyze_test_checks.py
        --opt=~/llvm-project/build/bin/opt
        ~/llvm-project/llvm/test/Analysis/Delinearization/*.ll
```
5. Drop llvm/test/Analysis/Delinearization/undef.ll because the test
   does not pass the github-actions "undef deprecator."
6. Only run delinearization pretty-print pass on the most internal loop.
7. Only run delinearization pretty-print pass on load and store
   instructions.

Author: sebpop

llvm/lib/Analysis/Delinearization.cpp

@@ -744,45 +744,48 @@ namespace {
 
 void printDelinearization(raw_ostream &O, Function *F, LoopInfo *LI,
                           ScalarEvolution *SE) {
-  O << "Delinearization on function " << F->getName() << ":\n";
+  O << "Printing analysis 'Delinearization' for function '" << F->getName()
+    << "':";
   for (Instruction &Inst : instructions(F)) {
     // Only analyze loads and stores.
-    if (!isa<StoreInst>(&Inst) && !isa<LoadInst>(&Inst) &&
-        !isa<GetElementPtrInst>(&Inst))
+    if (!isa<StoreInst>(&Inst) && !isa<LoadInst>(&Inst))
       continue;
 
     const BasicBlock *BB = Inst.getParent();
-    // Delinearize the memory access as analyzed in all the surrounding loops.
+    Loop *L = LI->getLoopFor(BB);
+    // Only delinearize the memory access in the innermost loop.
     // Do not analyze memory accesses outside loops.
-    for (Loop *L = LI->getLoopFor(BB); L != nullptr; L = L->getParentLoop()) {
-      const SCEV *AccessFn = SE->getSCEVAtScope(getPointerOperand(&Inst), L);
+    if (!L)
+      continue;
 
-      const SCEVUnknown *BasePointer =
-          dyn_cast<SCEVUnknown>(SE->getPointerBase(AccessFn));
-      // Do not delinearize if we cannot find the base pointer.
-      if (!BasePointer)
-        break;
-      AccessFn = SE->getMinusSCEV(AccessFn, BasePointer);
+    const SCEV *AccessFn = SE->getSCEVAtScope(getPointerOperand(&Inst), L);
 
-      O << "\n";
-      O << "Inst:" << Inst << "\n";
-      O << "In Loop with Header: " << L->getHeader()->getName() << "\n";
-      O << "AccessFunction: " << *AccessFn << "\n";
+    const SCEVUnknown *BasePointer =
+        dyn_cast<SCEVUnknown>(SE->getPointerBase(AccessFn));
+    // Do not delinearize if we cannot find the base pointer.
+    if (!BasePointer)
+      break;
+    AccessFn = SE->getMinusSCEV(AccessFn, BasePointer);
 
-      SmallVector<const SCEV *, 3> Subscripts, Sizes;
+    O << "\n";
+    O << "Inst:" << Inst << "\n";
+    O << "In Loop with Header: " << L->getHeader()->getName() << "\n";
+    O << "AccessFunction: " << *AccessFn << "\n";
 
-      auto IsDelinearizationFailed = [&]() {
-        return Subscripts.size() == 0 || Sizes.size() == 0 ||
-               Subscripts.size() != Sizes.size();
-      };
+    SmallVector<const SCEV *, 3> Subscripts, Sizes;
 
-      delinearize(*SE, AccessFn, Subscripts, Sizes, SE->getElementSize(&Inst));
-      if (UseFixedSizeArrayHeuristic && IsDelinearizationFailed()) {
-        Subscripts.clear();
-        Sizes.clear();
-        delinearizeFixedSizeArray(*SE, AccessFn, Subscripts, Sizes,
-                                  SE->getElementSize(&Inst));
-      }
+    auto IsDelinearizationFailed = [&]() {
+      return Subscripts.size() == 0 || Sizes.size() == 0 ||
+             Subscripts.size() != Sizes.size();
+    };
+
+    delinearize(*SE, AccessFn, Subscripts, Sizes, SE->getElementSize(&Inst));
+    if (UseFixedSizeArrayHeuristic && IsDelinearizationFailed()) {
+      Subscripts.clear();
+      Sizes.clear();
+      delinearizeFixedSizeArray(*SE, AccessFn, Subscripts, Sizes,
+                                SE->getElementSize(&Inst));
+    }
 
       if (IsDelinearizationFailed()) {
         O << "failed to delinearize\n";
@@ -800,7 +803,6 @@ void printDelinearization(raw_ostream &O, Function *F, LoopInfo *LI,
       for (int i = 0; i < Size; i++)
         O << "[" << *Subscripts[i] << "]";
       O << "\n";
-    }
   }
 }
 

llvm/test/Analysis/Delinearization/a.ll

@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
 ; 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]) {
@@ -7,12 +8,15 @@
 ;         A[2*i+3][3*j-4][5*k+7] = 1;
 ; }
 
-; AddRec: {{{(28 + (4 * (-4 + (3 * %m)) * %o) + %A),+,(8 * %m * %o)}<%for.i>,+,(12 * %o)}<%for.j>,+,20}<%for.k>
-; CHECK: Base offset: %A
-; CHECK: ArrayDecl[UnknownSize][%m][%o] with elements of 4 bytes.
-; CHECK: ArrayRef[{3,+,2}<nuw><%for.i>][{-4,+,3}<nw><%for.j>][{7,+,5}<nw><%for.k>]
-
 define void @foo(i64 %n, i64 %m, i64 %o, ptr nocapture %A) #0 {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT:  Inst: store i32 1, ptr %arrayidx11.us.us, align 4
+; CHECK-NEXT:  In Loop with Header: for.k
+; CHECK-NEXT:  AccessFunction: {{\{\{\{}}(28 + (4 * (-4 + (3 * %m)) * %o)),+,(8 * %m * %o)}<%for.i>,+,(12 * %o)}<%for.j>,+,20}<%for.k>
+; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  ArrayDecl[UnknownSize][%m][%o] with elements of 4 bytes.
+; CHECK-NEXT:  ArrayRef[{3,+,2}<nuw><%for.i>][{-4,+,3}<nw><%for.j>][{7,+,5}<nw><%for.k>]
+;
 entry:
   %cmp32 = icmp sgt i64 %n, 0
   br i1 %cmp32, label %for.cond1.preheader.lr.ph, label %for.end17

llvm/test/Analysis/Delinearization/byte_offset.ll

@@ -1,8 +1,6 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
 ; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
-; CHECK: AccessFunction: ({0,+,%i2}<%outer.loop> + %unknown)
-; CHECK-NEXT: failed to delinearize
-
 ; void foo(char A[], long i2, bool c) {
 ;   for (long i = 0; ; ++i) {
 ;     char *tmp = &A[i * i2];
@@ -13,6 +11,12 @@
 ; }
 
 define void @foo(ptr %A, i64 %i2, i64 %arg, i1 %c) {
+; CHECK-LABEL: 'foo'
+; CHECK-NEXT:  Inst: store float 0.000000e+00, ptr %arrayidx, align 4
+; CHECK-NEXT:  In Loop with Header: inner.loop
+; CHECK-NEXT:  AccessFunction: ({0,+,%i2}<%outer.loop> + %unknown)
+; CHECK-NEXT:  failed to delinearize
+;
 entry:
   br label %outer.loop
 

llvm/test/Analysis/Delinearization/constant_functions_multi_dim.ll

@@ -1,23 +1,25 @@
-; RUN: opt -passes='print<delinearization>' -disable-output < %s 2>&1 | FileCheck %s
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
+; RUN: opt < %s -passes='print<delinearization>' -disable-output 2>&1 | FileCheck %s
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
-; CHECK:      Inst:  %tmp = load float, ptr %arrayidx, align 4
-; CHECK-NEXT: In Loop with Header: for.inc
-; CHECK-NEXT: AccessFunction: {(4 * %N * %call),+,4}<%for.inc>
-; CHECK-NEXT: Base offset: %A
-; CHECK-NEXT: ArrayDecl[UnknownSize][%N] with elements of 4 bytes.
-; CHECK-NEXT: ArrayRef[%call][{0,+,1}<nuw><nsw><%for.inc>]
-
-; CHECK:      Inst:  %tmp5 = load float, ptr %arrayidx4, align 4
-; CHECK-NEXT: In Loop with Header: for.inc
-; CHECK-NEXT: AccessFunction: {(4 * %call1),+,(4 * %N)}<%for.inc>
-; CHECK-NEXT: Base offset: %B
-; CHECK-NEXT: ArrayDecl[UnknownSize][%N] with elements of 4 bytes.
-; CHECK-NEXT: ArrayRef[{0,+,1}<nuw><nsw><%for.inc>][%call1]
-
 ; Function Attrs: noinline nounwind uwtable
 define void @mat_mul(ptr %C, ptr %A, ptr %B, i64 %N) #0 !kernel_arg_addr_space !2 !kernel_arg_access_qual !3 !kernel_arg_type !4 !kernel_arg_base_type !4 !kernel_arg_type_qual !5 {
+; CHECK-LABEL: 'mat_mul'
+; CHECK-NEXT:  Inst: %tmp = load float, ptr %arrayidx, align 4
+; CHECK-NEXT:  In Loop with Header: for.inc
+; CHECK-NEXT:  AccessFunction: {(4 * %N * %call),+,4}<%for.inc>
+; CHECK-NEXT:  Base offset: %A
+; CHECK-NEXT:  ArrayDecl[UnknownSize][%N] with elements of 4 bytes.
+; CHECK-NEXT:  ArrayRef[%call][{0,+,1}<nuw><nsw><%for.inc>]
+; CHECK-EMPTY:
+; CHECK-NEXT:  Inst: %tmp5 = load float, ptr %arrayidx4, align 4
+; CHECK-NEXT:  In Loop with Header: for.inc
+; CHECK-NEXT:  AccessFunction: {(4 * %call1),+,(4 * %N)}<%for.inc>
+; CHECK-NEXT:  Base offset: %B
+; CHECK-NEXT:  ArrayDecl[UnknownSize][%N] with elements of 4 bytes.
+; CHECK-NEXT:  ArrayRef[{0,+,1}<nuw><nsw><%for.inc>][%call1]
+;
 entry:
   br label %entry.split
 

llvm/test/Analysis/Delinearization/divide_by_one.ll

@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_analyze_test_checks.py UTC_ARGS: --version 5
 ; 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"
@@ -10,19 +11,22 @@ target datalayout = "e-m:e-p:32:32-i1:32-i64:64-a:0-n32"
 ;       dst[r * stride + c] = dst[(r + 1) * stride + c - 1];
 ; }
 
-; AddRec: {{(-1 + ((1 + %bs) * %stride)),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nw><%for.body3>
-; CHECK: Inst:  %0 = load i8, ptr %arrayidx, align 1
-; CHECK: Base offset: %dst
-; CHECK: ArrayDecl[UnknownSize][%stride] with elements of 1 bytes.
-; CHECK: ArrayRef[{(1 + %bs),+,-1}<nw><%for.cond1.preheader>][{-1,+,1}<nw><%for.body3>]
-
-; AddRec: {{(ptr %bs),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nw><%for.body3>
-; CHECK: Inst:  store i8 %0, ptr %arrayidx7, align 1
-; CHECK: Base offset: %dst
-; CHECK: ArrayDecl[UnknownSize][%stride] with elements of 1 bytes.
-; CHECK: ArrayRef[{%bs,+,-1}<nsw><%for.cond1.preheader>][{0,+,1}<nuw><nsw><%for.body3>]
-
 define void @test(ptr nocapture %dst, i32 %stride, i32 %bs) {
+; CHECK-LABEL: 'test'
+; CHECK-NEXT:  Inst: %0 = load i8, ptr %arrayidx, align 1
+; CHECK-NEXT:  In Loop with Header: for.body3
+; CHECK-NEXT:  AccessFunction: {{\{\{}}(-1 + ((1 + %bs) * %stride)),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nw><%for.body3>
+; CHECK-NEXT:  Base offset: %dst
+; CHECK-NEXT:  ArrayDecl[UnknownSize][%stride] with elements of 1 bytes.
+; CHECK-NEXT:  ArrayRef[{(1 + %bs),+,-1}<nw><%for.cond1.preheader>][{-1,+,1}<nw><%for.body3>]
+; CHECK-EMPTY:
+; CHECK-NEXT:  Inst: store i8 %0, ptr %arrayidx7, align 1
+; CHECK-NEXT:  In Loop with Header: for.body3
+; CHECK-NEXT:  AccessFunction: {{\{\{}}(%stride * %bs),+,(-1 * %stride)}<%for.cond1.preheader>,+,1}<nsw><%for.body3>
+; CHECK-NEXT:  Base offset: %dst
+; CHECK-NEXT:  ArrayDecl[UnknownSize][%stride] with elements of 1 bytes.
+; CHECK-NEXT:  ArrayRef[{%bs,+,-1}<nsw><%for.cond1.preheader>][{0,+,1}<nuw><nsw><%for.body3>]
+;
 entry:
   %cmp20 = icmp sgt i32 %bs, -1
   br i1 %cmp20, label %for.cond1.preheader.lr.ph, label %for.end9