[Polly] Untangle ScopInfo lit-testcases from specifics of the legacy-PM

[philip.pfaffe]

Summary

For the ScopInfo lit testsuite, this patch removes some dependences on output behaviour of the legacy PM.

In most cases, these tests checked the tool output for labels created by the pass printer in the legacy PM. This doesn't work for the new PM anymore. Untangling the testcases is the first step to porting the testsuite for the new PM infrastructure.

[grosser]

LGTM! Very nice!

polly/trunk/test/ScopInfo/aliasing_many_parameters_not_all_involved.ll

 ; RUN: opt %loadPolly -polly-scops -polly-rtc-max-parameters=8 -analyze < %s | FileCheck %s --check-prefix=MAX8
 ; RUN: opt %loadPolly -polly-scops -polly-rtc-max-parameters=7 -analyze < %s | FileCheck %s --check-prefix=MAX7
 ;
 ; Check that we allow this SCoP even though it has 10 parameters involved in posisbly aliasing accesses.
 ; However, only 7 are involved in accesses through B, 8 through C and none in accesses through A.
 ;
-; MAX8-LABEL:       Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'for.cond => for.end' in function 'jd':
-; MAX8:  Function: jd
+; MAX8-LABEL:  Function: jd
+; MAX8-NEXT: Region: %for.cond---%for.end
 
-; MAX7-LABEL:       Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'for.cond => for.end' in function 'jd':
 ; MAX7:  Invalid Scop!
 ;
 ;    void jd(int *A, int *B, int *C, long p1, long p2, long p3, long p4, long p5,
 ;            long p6, long p7, long p8, long p9, long p10) {
 ;      for (int i = 0; i < 1024; i++)
 ;        A[i] = B[p1] - B[p2] + B[-p3] - B[p4] + B[p5] - B[-p6] + B[p7] - C[p3] +
 ;               C[-p4] - C[p5] + C[p6] - C[-p7] + C[p8] - C[p9] + C[-p10];
 ;    }

polly/trunk/test/ScopInfo/branch-references-loop-scev-with-unknown-iterations.ll

 ; RUN: opt %loadPolly -polly-scops -analyze < %s | \
 ; RUN:     FileCheck %s -check-prefix=NONAFFINE
 ; RUN: opt %loadPolly -polly-scops -analyze \
 ; RUN:     -polly-allow-nonaffine-branches=false < %s | \
 ; RUN:     FileCheck %s -check-prefix=NO-NONEAFFINE
 
-; NONAFFINE:      Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'branch => end' in function 'f':
-; NONAFFINE-NEXT: Invalid Scop!
-; NONAFFINE-NEXT: Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'loop => branch' in function 'f':
-; NONAFFINE-NEXT: Invalid Scop!
-; NONAFFINE-NEXT: Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'loop => end' in function 'f':
-; NONAFFINE-NEXT: Invalid Scop!
-; NONAFFINE-NEXT: Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'entry => <Function Return>' in function 'f':
-; NONAFFINE-NEXT: Invalid Scop!
+; NONAFFINE-NOT: Statements
 
 ; NO-NONEAFFINE: Statements {
 ; NO-NONEAFFINE-NEXT:   Stmt_then
 ; NO-NONEAFFINE-NEXT:         Domain :=
 ; NO-NONEAFFINE-NEXT:             [p_0] -> { Stmt_then[] : p_0 <= -2 or p_0 >= 0 };
 ; NO-NONEAFFINE-NEXT:         Schedule :=
 ; NO-NONEAFFINE-NEXT:             [p_0] -> { Stmt_then[] -> [] };
 ; NO-NONEAFFINE-NEXT:         MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]

polly/trunk/test/ScopInfo/cond_in_loop.ll

bb3:                                              ; preds = %bb2, %bb1
   %3 = add nsw i64 %1, 1                          ; <i64> [#uses=2]
   %exitcond = icmp eq i64 %3, %M                  ; <i1> [#uses=1]
   br i1 %exitcond, label %return, label %bb
 
 return:                                           ; preds = %bb3, %entry
   ret void
 }
 
-; CHECK-LABEL: Printing analysis 'Polly - Create polyhedral description of Scops' for region: 'bb => return' in function 'f':
-; CHECK-NEXT:      Function: f
+; CHECK-LABEL:      Function: f
 ; CHECK-NEXT:      Region: %bb---%return

polly/trunk/test/ScopInfo/fortran_array_param_nonmalloc_nonvectored.ll

 
 return.loopexit:                                  ; preds = %"6"
   br label %return
 
 return:                                           ; preds = %return.loopexit, %entry.split
   ret void
 }
 
-; CHECK: MayWriteAccess := [Reduction Type: NONE] [Fortran array descriptor: xs] [Scalar: 0]
+; CHECK: MayWriteAccess := [Reduction Type: NONE] [Fortran array descriptor: xs] [Scalar: 0]
 

polly/trunk/test/ScopInfo/integers.ll

 ; RUN: opt %loadPolly -polly-scops -analyze < %s | FileCheck %s
 
 ; Check that we correctly convert integers to isl values.
 
 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"
 
 ; Large positive integer
 define void @f(i1024* nocapture %a) nounwind {
 entry:
   br label %bb
 
 bb:
   %indvar = phi i1024 [ 0, %entry ], [ %indvar.next, %bb ]
   store i1024 %indvar, i1024* %a, align 8
   %indvar.next = add nsw i1024 %indvar, 1
   %exitcond = icmp eq i1024 %indvar, 123456000000000000000000000
-; CHECK:  'bb => return' in function 'f'
+; CHECK-LABEL: Function: f
+; CHECK-NEXT: Region: %bb---%return
 ; CHECK: i0 <= 123456000000000000000000000
   br i1 %exitcond, label %return, label %bb
 
 return:
   ret void
 }
 
 ; Normal positive integer
 define void @f2(i32* nocapture %a) nounwind {
 entry:
   br label %bb
 
 bb:
   %indvar = phi i32 [ 0, %entry ], [ %indvar.next, %bb ]
   %scevgep = getelementptr i32, i32* %a, i32 %indvar
   store i32 %indvar, i32* %scevgep, align 8
   %indvar.next = add nsw i32 %indvar, 1
   %exitcond = icmp eq i32 %indvar, 123456
-; CHECK:  'bb => return' in function 'f2'
+; CHECK-LABEL: Function: f2
+; CHECK-NEXT: Region: %bb---%return
 ; CHECK: i0 <= 123456
   br i1 %exitcond, label %return, label %bb
 
 return:
   ret void
 }
 
 ; Normal negative integer
 define void @f3(i32* nocapture %a, i32 %n) nounwind {
 entry:
   br label %bb
 
 bb:
   %indvar = phi i32 [ 0, %entry ], [ %indvar.next, %bb ]
   %scevgep = getelementptr i32, i32* %a, i32 %indvar
   store i32 %indvar, i32* %scevgep, align 8
   %indvar.next = add nsw i32 %indvar, 1
   %sub = sub i32 %n, 123456
   %exitcond = icmp eq i32 %indvar, %sub
-; CHECK:  'bb => return' in function 'f3'
+; CHECK-LABEL: Function: f3
+; CHECK-NEXT: Region: %bb---%return
 ; CHECK: -123456
   br i1 %exitcond, label %return, label %bb
 
 return:
   ret void
 }
 
 ; Large negative integer
 define void @f4(i1024* nocapture %a, i1024 %n) nounwind {
 entry:
   br label %bb
 
 bb:
   %indvar = phi i1024 [ 0, %entry ], [ %indvar.next, %bb ]
   %scevgep = getelementptr i1024, i1024* %a, i1024 %indvar
   store i1024 %indvar, i1024* %scevgep, align 8
   %indvar.next = add nsw i1024 %indvar, 1
   %sub = sub i1024 %n, 123456000000000000000000000000000000
-; CHECK:  'bb => return' in function 'f4'
+; CHECK-LABEL: Function: f4
+; CHECK-NEXT: Region: %bb---%return
 ; CHECK: -123456000000000000000000000000000000
   %exitcond = icmp eq i1024 %indvar, %sub
   br i1 %exitcond, label %return, label %bb
 
 return:
   ret void
 }
 
 define void @f5(i1023* nocapture %a, i1023 %n) nounwind {
 entry:
   br label %bb
 
 bb:
   %indvar = phi i1023 [ 0, %entry ], [ %indvar.next, %bb ]
   %scevgep = getelementptr i1023, i1023* %a, i1023 %indvar
   store i1023 %indvar, i1023* %scevgep, align 8
   %indvar.next = add nsw i1023 %indvar, 1
   %sub = sub i1023 %n, 123456000000000000000000000000000000
-; CHECK:  'bb => return' in function 'f5'
+; CHECK-LABEL: Function: f5
+; CHECK-NEXT: Region: %bb---%return
 ; CHECK: -123456000000000000000000000000000000
   %exitcond = icmp eq i1023 %indvar, %sub
   br i1 %exitcond, label %return, label %bb
 
 return:
   ret void
 }
 
 ; Tiny negative integer
 define void @f6(i3* nocapture %a, i3 %n) nounwind {
 entry:
   br label %bb
 
 bb:
   %indvar = phi i3 [ 0, %entry ], [ %indvar.next, %bb ]
   %scevgep = getelementptr i3, i3* %a, i3 %indvar
   store i3 %indvar, i3* %scevgep, align 8
   %indvar.next = add nsw i3 %indvar, 1
   %sub = sub i3 %n, 3
-; CHECK-LABEL:  'bb => return' in function 'f6'
+; CHECK-LABEL: Function: f6
+; CHECK-NEXT: Region: %bb---%return
 ; CHECK:         Context:
 ; CHECK-NEXT:    [n] -> {  : -4 <= n <= 3 }
 ; CHECK-NEXT:    Assumed Context:
 ; CHECK-NEXT:    [n] -> {  :  }
 ; CHECK-NEXT:    Invalid Context:
 ; CHECK-NEXT:    [n] -> {  : 1 = 0 }
 
 ; CHECK:     Statements {

polly/trunk/test/ScopInfo/licm_load.ll

 ; CHECK:      Invariant Accesses: {
 ; CHECK-NEXT:   ReadAccess := [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:       [n, j] -> { Stmt_{{[a-zA-Z_]*}}[{{[i0]*}}] -> MemRef_B[j] };
 ; CHECK-NEXT:       Execution Context: [n, j] -> {  : n > 0 }
 ; CHECK-NEXT: }
 ;
 ; CHECK: Statements {
 ; CHECK:      Stmt_for_body
-; CHECK-DAG:     MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
+; CHECK:     MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:        [n, j] -> { Stmt_for_body[i0] -> MemRef_A[i0] };
 ; CHECK:     }

polly/trunk/test/ScopInfo/undef_in_cond.ll

 
 bb3:                                              ; preds = %bb2, %bb1, %bb
   br label %bb14
 
 bb14:                                             ; preds = %bb5, %bb4, %bb3, %entry
   ret void
 }
 
-; CHECK: Invalid Scop!
+; CHECK-NOT: Function: