[llvm][NFC] Disallow all warnings in TypeSize tests

[peterwaller-arm]

Summary

This is a follow-up to a request from a reviewer [0]. The text may change in
the future and these tests should not produce any warning output.

[0] https://reviews.llvm.org/D91806#inline-879243

[sdesmalen]

LGTM

[david-arm]

LGTM!

llvm/test/Analysis/CostModel/AArch64/cost-scalable-vector-gep.ll

 ; RUN: opt -cost-model -analyze -mtriple=aarch64--linux-gnu -mattr=+sve < %s 2>%t | FileCheck %s
 ; RUN: FileCheck --check-prefix=WARN --allow-empty %s < %t
 
 ; This regression test is verifying that a GEP instruction performed on a
 ; scalable vector does not produce a 'assumption that TypeSize is not scalable'
 ; warning when performing cost analysis.
 
 ; If this check fails please read test/CodeGen/AArch64/README for instructions on how to resolve it.
-; WARN-NOT: warning: {{.*}}TypeSize is not scalable
+; WARN-NOT: warning:
 
 ; CHECK: Cost Model: Found an estimated cost of 1 for instruction:   %retval = getelementptr
 define <vscale x 16 x i8>* @gep_scalable_vector(<vscale x 16 x i8>* %ptr) {
   %retval = getelementptr <vscale x 16 x i8>, <vscale x 16 x i8>* %ptr, i32 2
   ret <vscale x 16 x i8>* %retval
 }

llvm/test/Analysis/LoopAccessAnalysis/gep-induction-operand-typesize-warning.ll

 ; RUN: opt -loop-load-elim -mtriple=aarch64--linux-gnu -mattr=+sve < %s 2>%t
 ; RUN: FileCheck --check-prefix=WARN --allow-empty %s < %t
 
 ; This regression test is verifying that a GEP instruction performed on a
 ; scalable vector does not produce a 'assumption that TypeSize is not scalable'
 ; warning in the llvm::getGEPInductionOperand function.
 
 ; If this check fails please read test/CodeGen/AArch64/README for instructions on how to resolve it.
-; WARN-NOT: warning: {{.*}}TypeSize is not scalable
+; WARN-NOT: warning:
 
 define void @get_gep_induction_operand_typesize_warning(i64 %n, <vscale x 4 x i32>* %a) {
 entry:
   br label %loop.body
 
 loop.body:
   %0 = phi i64 [ 0, %entry ], [ %1, %loop.body ]
   %idx = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %a, i64 %0
   store <vscale x 4 x i32> zeroinitializer, <vscale x 4 x i32>* %idx
   %1 = add i64 %0, 1
   %2 = icmp eq i64 %1, %n
   br i1 %2, label %loop.end, label %loop.body
 
 loop.end:
   ret void
 }

llvm/test/Analysis/LoopAccessAnalysis/runtime-pointer-checking-insert-typesize.ll

 ; RUN: opt -loop-accesses -analyze -enable-new-pm=0 %s | FileCheck %s
 ; RUN: opt -passes='print-access-info' -disable-output < %s 2>&1 | FileCheck %s
 
 ; This regression test is defending against a TypeSize warning 'assumption that
 ; TypeSize is not scalable'. This warning cropped up in
 ; RuntimePointerChecking::insert when performing loop load elimination because
 ; this function was previously unaware of scalable types.
 
 ; If this check fails please read test/CodeGen/AArch64/README for instructions on how to resolve it.
-; CHECK-NOT: warning: {{.*}}TypeSize is not scalable
+; CHECK-NOT: warning:
 
 define void @runtime_pointer_checking_insert_typesize(<vscale x 4 x i32>* %a,
                                                       <vscale x 4 x i32>* %b) {
 entry:
   br label %loop.body
 loop.body:
   %0 = phi i64 [ 0, %entry ], [%1, %loop.body]
   %idx_a = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %a, i64 %0

llvm/test/CodeGen/AArch64/dag-combine-lifetime-end-store-typesize.ll

 ; RUN: llc -mtriple=aarch64-- < %s 2>&1 | FileCheck --allow-empty %s
 
 ; This regression test is defending against a TypeSize warning 'assumption that TypeSize is not
 ; scalable'. This warning appeared in DAGCombiner::visitLIFETIME_END when visiting a LIFETIME_END
 ; node linked to a scalable store.
 
 ; If this check fails please read test/CodeGen/AArch64/README for instructions on how to resolve it.
-; CHECK-NOT: warning: {{.*}}TypeSize is not scalable
+; CHECK-NOT: warning:
 
 declare void @llvm.lifetime.start.p0i8(i64, i8* nocapture)
 declare void @llvm.lifetime.end.p0i8(i64, i8* nocapture)
 
 define void @foo(<vscale x 4 x i32>* nocapture dereferenceable(16) %ptr) {
 entry:
   %tmp = alloca <vscale x 4 x i32>, align 8
   %tmp_ptr = bitcast <vscale x 4 x i32>* %tmp to i8*
   call void @llvm.lifetime.start.p0i8(i64 32, i8* %tmp_ptr)
   store <vscale x 4 x i32> undef, <vscale x 4 x i32>* %ptr
   call void @llvm.lifetime.end.p0i8(i64 32, i8* %tmp_ptr)
   ret void
 }

llvm/test/CodeGen/AArch64/sve-redundant-store.ll

 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
 ; RUN: llc -O2 -mtriple=aarch64-linux-gnu -mattr=+sve < %s 2>%t | FileCheck %s
 ; RUN: FileCheck --check-prefix=WARN --allow-empty %s <%t
 
 ; If this check fails please read test/CodeGen/AArch64/README for instructions on how to resolve it.
-; WARN-NOT: warning: {{.*}}TypeSize is not scalable
+; WARN-NOT: warning:
 
 ; #include <arm_sve.h>
 ; #include <stdint.h>
 ;
 ; void redundant_store(uint32_t *p, svint32_t v) {
 ;     *p = 1;
 ;     *(svint32_t *)p = v;
 ; }

llvm/test/Transforms/InstCombine/gep-can-replace-gep-idx-with-zero-typesize.ll

 ; RUN: opt -S -instcombine < %s 2>%t
 ; RUN: FileCheck --check-prefix=WARN --allow-empty %s <%t
 
 ; This regression test is verifying that the optimization defined by
 ; canReplaceGEPIdxWithZero, which replaces a GEP index with zero iff we can show
 ; a value other than zero would cause undefined behaviour, does not throw a
 ; 'assumption that TypeSize is not scalable' warning when the source element type
 ; is a scalable vector.
 
 ; If the source element is a scalable vector type, then we cannot deduce whether
 ; or not indexing at a given index is undefined behaviour, because the size of
 ; the vector is not known.
 
 ; If this check fails please read test/CodeGen/AArch64/README for instructions
 ; on how to resolve it.
-; WARN-NOT: warning: {{.*}}TypeSize is not scalable
+; WARN-NOT: warning:
 
 declare void @do_something(<vscale x 4 x i32> %x)
 
 define void @can_replace_gep_idx_with_zero_typesize(i64 %n, <vscale x 4 x i32>* %a, i64 %b) {
   %idx = getelementptr <vscale x 4 x i32>, <vscale x 4 x i32>* %a, i64 %b
   %tmp = load <vscale x 4 x i32>, <vscale x 4 x i32>* %idx
   call void @do_something(<vscale x 4 x i32> %tmp)
   ret void
 }

llvm/test/Transforms/LoopVectorize/AArch64/sve-scalable-load-in-loop.ll

 ; RUN: opt -S -loop-vectorize -mtriple=aarch64-linux-gnu -mattr=+sve < %s 2>%t | FileCheck %s
 ; RUN: FileCheck --check-prefix=WARN --allow-empty %s <%t
 
 ; This test is checking that a scalable load inside a loop does not trigger a
 ; TypeSize error in the loop vectorization legality analysis. It is possible for
 ; a scalable/vector load to appear inside a loop at vectorization legality
 ; analysis if, for example, the ACLE are used. If we encounter a scalable/vector
 ; load, it should not be considered for analysis, and we should not see a
 ; TypeSize error.
 
 ; If this check fails please read test/CodeGen/AArch64/README for instructions on how to resolve it.
-; WARN-NOT: warning: {{.*}}TypeSize is not scalable
+; WARN-NOT: warning:
 
 ; #include <arm_sve.h>
 ;
 ; void scalable_load_in_loop(long n, int *a, int *b, svuint32_t *x,
 ;                            svuint32_t *y) {
 ;     for (unsigned i = 0; i < n; i++) {
 ;         if (i % 2 == 0) continue;
 ;         a[i] = 2 * b[i];