[Polly] Fix REQUIRES for nvptx-dependent tests

[probinson]

Summary

These have been effectively disabled ever since 'nvptx' was added to
the REQUIRES clauses, because REQUIRES does not support triple checks.
The new 'target=<triple>' is supported, so switch to that scheme.
Fix up XFAIL annotations, now that these tests are actually run.

Part of the project to eliminate special handling for triples in lit
expressions.

[probinson]

I did not investigate _why_ any of these tests failed, on the theory that subject matter experts should handle that. My goal is to clean up use (and misuse) of triple checks in the lit tests.

[probinson]

double-parallel-loop.ll:
Fixed a command-line typo, but still has unexpected output,
more extensive than I'm willing to fix naively.

scalar-param-and-value-32-bit.ll:
Updated CHECK line to match current actual output.

scalar-param-and-value-use.ll:
Fixed apparent typo in the IR: check line, test now passes.

scalar-parameter-fp128.ll:
Updated "This fails" comment with current failure message.

scalar-parameter-half.ll:
Removed "This fails" comment, as the test now passes.
(It also doesn't FileCheck the output, which it probably should,
but a subject-matter expert should address that separately.)

scalar-parameter-i120.ll:
Updated "This fails" comment with current failure message.

scalar-parameter-i128.ll:
Remove "This fails" comment, as the test now passes.
(It also doesn't FileCheck the output, which it probably should,
but a subject-matter expert should address that separately.)

scalar-parameter-i3000.ll:
Updated "This fails" comment with current failure message.

scalar-parameter-i80.ll:
Updated "This fails" comment with current failure message.

scalar-parameter-ppc_fp128.ll:
Updated "This fails" comment with current failure message.

scalar-parameter-x86_fp80.ll:
Updated "This fails" comment with current failure message.

scalar-parameter.ll:
Remove redundant target datalayout clauses that prevented opt
from parsing the input; however the test still fails with
unexpected output.

[probinson]

Made a pass over the tests trying to address the actual failures, but didn't get very far.
I'd like to commit this to unblock my lit work (described here) and let the polly experts take care of the rest of these tests.

[probinson]

Update to correct diff

[probinson]

ping

[probinson]

Ping. +tra based on git-log

[tra]

Normally NVPTX-specific tests in clang use REQUIRES: nvptx-registered-target. There seem to be way less uses of target=... and I do not quite understand when it would be true. Would it be true when the default target matches the one specified by target=xxx, or when the compiler does have enabled back-end for that target?

Given that these tests are run w/o explicitly specifying the target, I assume you want the former and in that case this appears to be the right constraint for the tests. I am not familiar with polly, so can't comment on the tests themselves.

polly/test/GPGPU/double-parallel-loop.ll

21–26

So the idea here is to actually run the tests, but that they all are expected to fail at the moment?

[probinson]

Would [target=xxx] be true when the default target matches the one specified by target=xxx, or when the compiler does have enabled back-end for that target?

target=xxx would be true when the default triple matches. The check for having the backend enabled is still xxx-registered-target.

I don't know anything about these tests either, except that they came up when I searched for tests using feature names that weren't defined.

polly/test/GPGPU/double-parallel-loop.ll

21–26

This one is expected to fail, yes. Others in this directory are expected to pass. I added or removed XFAIL according to whether the tests pass or fail for me, now that they actually can be run. In a couple of cases the reason for the failure looked like a trivial mismatch, and I tweaked those to let them pass. I don't know anything about Polly or NVPTX so I can't make any more extensive changes.

[tra]

polly/test/GPGPU/double-parallel-loop.ll

21–26

Then I would suggest adding a "TODO/FIXME" to make the tests work and remove XFAIL once it's done, so it's clear that we're not doing negative testing here.

[probinson]

Add "This fails today ..." notes to the tests where I added XFAIL: *

[probinson]

polly/test/GPGPU/double-parallel-loop.ll

21–26

The idiom in these tests appears to be "This test fails today (reason)" so I added comments in that form to the tests where I added XFAIL.

[probinson]

@tra can I get your okay on this?

[tra]

polly/test/GPGPU/double-parallel-loop.ll

23

Nit: I'd move REQUIRES to the top of the file.

[probinson]

polly/test/GPGPU/double-parallel-loop.ll

23

I hear you, but the style of these tests puts RUN first, so I'm going to stick with that.

polly/test/GPGPU/double-parallel-loop.ll

-; RUN: opt %loadPolly -polly-print-scops -disable-outout < %s | FileCheck %s
+; RUN: opt %loadPolly -polly-print-scops -disable-output < %s | FileCheck %s
 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-schedule \
 ; RUN: -disable-output < %s | \
 ; RUN: FileCheck -check-prefix=SCHED %s
 
 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code \
 ; RUN: -disable-output < %s | \
 ; RUN: FileCheck -check-prefix=CODE %s
 
 ; RUN: opt %loadPolly -polly-codegen-ppcg -S < %s | \
 ; RUN: FileCheck %s -check-prefix=IR
 
 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-kernel-ir \
 ; RUN: -disable-output < %s | \
 ; RUN: FileCheck %s -check-prefix=KERNEL-IR
 
 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-kernel-asm \
 ; RUN: -disable-output < %s | \
 ; RUN: FileCheck %s -check-prefix=KERNEL-ASM
 
-; REQUIRES: pollyacc,nvptx
+; XFAIL: *
+
+; REQUIRES: pollyacc, target=nvptx{{.*}}
+
+; This fails today due to extensive output differences from when the test was written.
 
 ; CHECK: Stmt_bb5
 ; CHECK-NEXT:       Domain :=
 ; CHECK-NEXT:           { Stmt_bb5[i0, i1] : 0 <= i0 <= 1023 and 0 <= i1 <= 1023 };
 ; CHECK-NEXT:       Schedule :=
 ; CHECK-NEXT:           { Stmt_bb5[i0, i1] -> [i0, i1] };
 ; CHECK-NEXT:       ReadAccess :=       [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:           { Stmt_bb5[i0, i1] -> MemRef_A[i0, i1] };
 ; CHECK-NEXT:       MustWriteAccess :=  [Reduction Type: NONE] [Scalar: 0]

polly/test/GPGPU/scalar-param-and-value-32-bit.ll

 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-kernel-ir \
 ; RUN: -disable-output < %s | \
 ; RUN: FileCheck %s
 
-; REQUIRES: pollyacc,nvptx
+; REQUIRES: pollyacc, target=nvptx{{.*}}
 ;
 ;    void foo(float A[], int n) {
 ;      for (long j = 0; j < n; j++)
 ;        A[j + n] += 42;
 ;    }
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
-; CHECK: define ptx_kernel void @kernel_0(i8* %MemRef_A, i32 %n)
+; CHECK: define ptx_kernel void @FUNC_foo_SCOP_0_KERNEL_0(i8 addrspace(1)* %MemRef_A, i32 %n)
 
 define void @foo(float* %A, i32 %n) {
 bb:
   br label %bb1
 
 bb1:                                              ; preds = %bb9, %bb
   %j.0 = phi i64 [ 0, %bb ], [ %tmp10, %bb9 ]
   %tmp = sext i32 %n to i64

polly/test/GPGPU/scalar-param-and-value-use.ll

 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-kernel-ir \
 ; RUN: -disable-output < %s | \
 ; RUN: FileCheck -check-prefix=IR %s
 
-; REQUIRES: pollyacc,nvptx
+; REQUIRES: pollyacc, target=nvptx{{.*}}
 
 ;    void foo(long n, float A[][n]) {
 ;      for (long i = 0; i < 32; i++)
 ;        for (long j = 0; j < 32; j++)
 ;          A[i][j] += A[i + 1][j + 1];
 ;    }
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; This test case failed at some point as %n was only available in this kernel
 ; when referenced through an isl_id in an isl ast expression, but not when
 ; it was referenced from a SCEV  or instruction that not part of any loop
 ; bound.
 
-; IR: %polly.access.mul.MemRef_A6 = mul nsw i64 {{.*}}, %n
+; IR: %polly.access.mul.MemRef_A = mul nsw i64 {{.*}}, %n
 
 define void @foo(i64 %n, float* %A) {
 bb:
   br label %bb2
 
 bb2:                                              ; preds = %bb19, %bb
   %i.0 = phi i64 [ 0, %bb ], [ %tmp20, %bb19 ]
   %exitcond1 = icmp ne i64 %i.0, 32

polly/test/GPGPU/scalar-parameter-fp128.ll

 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code -disable-output %s
 
 ; XFAIL: *
 
-; REQUIRES: pollyacc,nvptx
+; REQUIRES: pollyacc, target=nvptx{{.*}}
 
-; This fails today with "type mismatch between callee prototype and arguments"
+; This fails today with "LowerFormalArguments didn't emit the correct number of values!"
 
 ;    void foo(fp128 A[], fp128 b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 

polly/test/GPGPU/scalar-parameter-half.ll

 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code -disable-output %s
 
-; REQUIRES: pollyacc,nvptx
-
-; This fails today with "unexpected type" in the LLVM PTX backend.
+; REQUIRES: pollyacc, target=nvptx{{.*}}
 
 ;    void foo(half A[], half b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 

polly/test/GPGPU/scalar-parameter-i120.ll

 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code -disable-output %s
 
 ; XFAIL: *
 
-; REQUIRES: pollyacc,nvptx
+; REQUIRES: pollyacc, target=nvptx{{.*}}
 
-; This fails today with "type mismatch between callee prototype and arguments"
+; This fails today with "Promotion is not suitable for scalars of size larger than 64-bits"
 
 ;    void foo(i120 A[], i120 b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 

polly/test/GPGPU/scalar-parameter-i128.ll

 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code -disable-output %s
 
-; XFAIL: *
-
-; REQUIRES: pollyacc,nvptx
-
-; This fails today with "LowerFormalArguments didn't emit the correct number of
-;                        values!"
+; REQUIRES: pollyacc, target=nvptx{{.*}}
 
 ;    void foo(i128 A[], i128 b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 

polly/test/GPGPU/scalar-parameter-i3000.ll

 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code -disable-output %s
 
 ; XFAIL: *
 
-; REQUIRES: pollyacc,nvptx
+; REQUIRES: pollyacc, target=nvptx{{.*}}
 
-; This fails today with "LowerFormalArguments didn't emit the correct number of
-;                        values!"
+; This fails today with "Promotion is not suitable for scalars of size larger than 64-bits"
 
 ;    void foo(i3000 A[], i3000 b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 

polly/test/GPGPU/scalar-parameter-i80.ll

 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code -disable-output %s
 
 ; XFAIL: *
 
-; REQUIRES: pollyacc,nvptx
+; REQUIRES: pollyacc, target=nvptx{{.*}}
 
-; This fails today with "LowerFormalArguments didn't emit the correct number of
-;                        values!"
+; This fails today with "Promotion is not suitable for scalars of size larger than 64-bits"
 
 ;    void foo(i80 A[], i80 b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 

polly/test/GPGPU/scalar-parameter-ppc_fp128.ll

 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code -disable-output %s
 
 ; XFAIL: *
 
-; REQUIRES: pollyacc,nvptx
+; REQUIRES: pollyacc, target=nvptx{{.*}}
 
-; This fails today with "type mismatch between callee prototype and arguments"
+; This fails today with "LowerFormalArguments didn't emit the correct number of values!"
 
 ;    void foo(fp128 A[], fp128 b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 

polly/test/GPGPU/scalar-parameter-x86_fp80.ll

 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code -disable-output %s
 
 ; XFAIL: *
 
-; REQUIRES: pollyacc,nvptx
+; REQUIRES: pollyacc, target=nvptx{{.*}}
 
-; This fails today with "type mismatch between callee prototype and arguments"
+; This fails today with "LowerFormalArguments didn't emit the correct number of values!"
 
 ;    void foo(fp128 A[], fp128 b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 

polly/test/GPGPU/scalar-parameter.ll

 ; RUN: opt %loadPolly -polly-codegen-ppcg -polly-acc-dump-code \
 ; RUN: -disable-output < %s | \
 ; RUN: FileCheck -check-prefix=CODE %s
 
 ; RUN: opt %loadPolly -polly-codegen-ppcg \
 ; RUN: -S < %s | \
 ; RUN: FileCheck -check-prefix=IR %s
 
 ; RUN: opt %loadPolly -polly-codegen-ppcg \
 ; RUN: -disable-output -polly-acc-dump-kernel-ir < %s | \
 ; RUN: FileCheck -check-prefix=KERNEL %s
 
-; REQUIRES: pollyacc,nvptx
+; XFAIL: *
+
+; REQUIRES: pollyacc, target=nvptx{{.*}}
+
+; This fails today due to extensive output differences from when the test was written.
 
 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
 
 ; KERNEL: define ptx_kernel void @kernel_0(i8* %MemRef_A, float %MemRef_b)
 
 ; CODE: Code
 ; CODE-NEXT: ====
 ; CODE-NEXT: # host

 ; CODE: # kernel0
 ; CODE-NEXT: Stmt_bb2(32 * b0 + t0);
 
 ;    void foo(float A[], float b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
 define void @float(float* %A, float %b) {
 bb:
   br label %bb1
 
 bb1:                                              ; preds = %bb5, %bb
   %i.0 = phi i64 [ 0, %bb ], [ %tmp6, %bb5 ]
   %exitcond = icmp ne i64 %i.0, 1024
   br i1 %exitcond, label %bb2, label %bb7

 ; CODE: # kernel0
 ; CODE-NEXT: Stmt_bb2(32 * b0 + t0);
 
 ;    void foo(double A[], double b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
 define void @double(double* %A, double %b) {
 bb:
   br label %bb1
 
 bb1:                                              ; preds = %bb5, %bb
   %i.0 = phi i64 [ 0, %bb ], [ %tmp6, %bb5 ]
   %exitcond = icmp ne i64 %i.0, 1024
   br i1 %exitcond, label %bb2, label %bb7

 ; CODE: # kernel0
 ; CODE-NEXT: Stmt_bb2(32 * b0 + t0);
 
 ;    void foo(i1 A[], i1 b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
 define void @i1(i1* %A, i1 %b) {
 bb:
   br label %bb1
 
 bb1:                                              ; preds = %bb5, %bb
   %i.0 = phi i64 [ 0, %bb ], [ %tmp6, %bb5 ]
   %exitcond = icmp ne i64 %i.0, 1024
   br i1 %exitcond, label %bb2, label %bb7

 ; CODE: # kernel0
 ; CODE-NEXT: Stmt_bb2(32 * b0 + t0);
 
 ;    void foo(i3 A[], i3 b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
 define void @i3(i3* %A, i3 %b) {
 bb:
   br label %bb1
 
 bb1:                                              ; preds = %bb5, %bb
   %i.0 = phi i64 [ 0, %bb ], [ %tmp6, %bb5 ]
   %exitcond = icmp ne i64 %i.0, 1024
   br i1 %exitcond, label %bb2, label %bb7

 ; CODE: # kernel0
 ; CODE-NEXT: Stmt_bb2(32 * b0 + t0);
 
 ;    void foo(i8 A[], i32 b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
 define void @i8(i8* %A, i8 %b) {
 bb:
   br label %bb1
 
 bb1:                                              ; preds = %bb5, %bb
   %i.0 = phi i64 [ 0, %bb ], [ %tmp6, %bb5 ]
   %exitcond = icmp ne i64 %i.0, 1024
   br i1 %exitcond, label %bb2, label %bb7

 ; CODE: # kernel0
 ; CODE-NEXT: Stmt_bb2(32 * b0 + t0);
 
 ;    void foo(i32 A[], i32 b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
 define void @i32(i32* %A, i32 %b) {
 bb:
   br label %bb1
 
 bb1:                                              ; preds = %bb5, %bb
   %i.0 = phi i64 [ 0, %bb ], [ %tmp6, %bb5 ]
   %exitcond = icmp ne i64 %i.0, 1024
   br i1 %exitcond, label %bb2, label %bb7

 ; CODE: # kernel0
 ; CODE-NEXT: Stmt_bb2(32 * b0 + t0);
 
 ;    void foo(i60 A[], i60 b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
 define void @i60(i60* %A, i60 %b) {
 bb:
   br label %bb1
 
 bb1:                                              ; preds = %bb5, %bb
   %i.0 = phi i64 [ 0, %bb ], [ %tmp6, %bb5 ]
   %exitcond = icmp ne i64 %i.0, 1024
   br i1 %exitcond, label %bb2, label %bb7

 ; CODE: # kernel0
 ; CODE-NEXT: Stmt_bb2(32 * b0 + t0);
 
 ;    void foo(i64 A[], i64 b) {
 ;      for (long i = 0; i < 1024; i++)
 ;        A[i] += b;
 ;    }
 ;
-target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
-
 define void @i64(i64* %A, i64 %b) {
 bb:
   br label %bb1
 
 bb1:                                              ; preds = %bb5, %bb
   %i.0 = phi i64 [ 0, %bb ], [ %tmp6, %bb5 ]
   %exitcond = icmp ne i64 %i.0, 1024
   br i1 %exitcond, label %bb2, label %bb7