Verify inferattrs doesn't infer unexpected attributes

[probinson]

Summary

Add --match-full-lines or {{$}} to ensure that no unexpected
attributes appear at the ends of lines. Account for the cases
where attributes were in fact appearing.

[probinson]

A bit of yak shaving because I had wanted to add __sqrt*_finite to annotate.ll, but it wasn't doing quite the right thing.

And then I poked around a little in the other tests in this directory. I'm particularly puzzled by dereferenceable.ll and dereferenceable-inseltpoison.ll, which don't appear to do anything other than verify function parameter lists don't get modified; is that really the intent? They seem kind of elaborate for that.

[rprichard]

The dereferenceable.ll and dereferenceable-inseltpoison.ll files are also confusing to me. It *sounds* like they're trying to test inferred attributes, but its CHECK* lines would allow any or no attributes on the functions, so it's not actually testing anything attribute-related.

Using --match-full-lines seems fine to me, and this change does look like an improvement.

llvm/test/Transforms/InferFunctionAttrs/annotate.ll

4

Linux isn't nvptx, but it's not passing CHECK-NONVPTX.

Then again, all of the tests pass CHECK, except for the nvptx case. I tested FileCheck, and it seems that CHECK is not implicitly tested when --check-prefixes is specified. So, for nvptx, we were previously only testing __nvvm_reflect and bcmp?

The lines where CHECK is split into CHECK-LINUX and CHECK-NOLINUX are also enabling the test for nvptx.

[probinson]

Sorry it took a while to cycle back to this.

Renamed CHECK-NONVPTX to CHECK-OPEN, because it was used only for the one function declaration, and that way the directive name is not misleading.

[probinson]

The lines where CHECK is split into CHECK-LINUX and CHECK-NOLINUX are also enabling the test for nvptx.

It's true that the nvptx case is now checking more than it used to, but not everything; making it check everything could probably be done, but is it worthwhile? I experimented with passing CHECK to the nvptx case, and it doesn't pass; there would have to be a CHECK-NVPTX line paralleling each CHECK: line, pretty much. Seems like a lot of effort, but is nvptx really that special?
I'll do it if someone says Yes, it's worth the trouble; but unless someone can say that, I'd rather not.

[probinson]

Ping

[rprichard]

In D110720#3109821, @probinson wrote:

The lines where CHECK is split into CHECK-LINUX and CHECK-NOLINUX are also enabling the test for nvptx.

It's true that the nvptx case is now checking more than it used to, but not everything; making it check everything could probably be done, but is it worthwhile? I experimented with passing CHECK to the nvptx case, and it doesn't pass; there would have to be a CHECK-NVPTX line paralleling each CHECK: line, pretty much. Seems like a lot of effort, but is nvptx really that special?
I'll do it if someone says Yes, it's worth the trouble; but unless someone can say that, I'd rather not.

Ok, that makes sense to me.

llvm/test/Transforms/InferFunctionAttrs/annotate.ll

-; RUN: opt < %s -mtriple=x86_64-- -inferattrs -S | FileCheck --check-prefixes=CHECK,CHECK-NOLINUX,CHECK-UNKNOWN %s
-; RUN: opt < %s -mtriple=x86_64-- -passes=inferattrs -S | FileCheck --check-prefixes=CHECK,CHECK-NOLINUX,CHECK-UNKNOWN %s
-; RUN: opt < %s -mtriple=x86_64-apple-macosx10.8.0 -inferattrs -S | FileCheck --check-prefixes=CHECK,CHECK-KNOWN,CHECK-NOLINUX,CHECK-DARWIN %s
-; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -inferattrs -S | FileCheck --check-prefixes=CHECK,CHECK-KNOWN,CHECK-LINUX %s
-; RUN: opt < %s -mtriple=nvptx -inferattrs -S | FileCheck --check-prefixes=CHECK-NOLINUX,CHECK-NVPTX %s
+; RUN: opt < %s -mtriple=x86_64-- -inferattrs -S | FileCheck --match-full-lines --check-prefixes=CHECK,CHECK-NOLINUX,CHECK-OPEN,CHECK-UNKNOWN %s
+; RUN: opt < %s -mtriple=x86_64-- -passes=inferattrs -S | FileCheck --match-full-lines --check-prefixes=CHECK,CHECK-NOLINUX,CHECK-OPEN,CHECK-UNKNOWN %s
+; RUN: opt < %s -mtriple=x86_64-apple-macosx10.8.0 -inferattrs -S | FileCheck --match-full-lines --check-prefixes=CHECK,CHECK-KNOWN,CHECK-NOLINUX,CHECK-OPEN,CHECK-DARWIN %s
+; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -inferattrs -S | FileCheck --match-full-lines --check-prefixes=CHECK,CHECK-KNOWN,CHECK-LINUX %s
+; RUN: opt < %s -mtriple=nvptx -inferattrs -S | FileCheck --match-full-lines --check-prefixes=CHECK-NOLINUX,CHECK-NVPTX %s
 
 declare i32 @__nvvm_reflect(i8*)
 ; CHECK-NVPTX: declare noundef i32 @__nvvm_reflect(i8* noundef) [[NOFREE_NOUNWIND_READNONE:#[0-9]+]]
 
 
 ; Check all the libc functions (thereby also exercising the prototype check).
 ; Note that it's OK to modify these as attributes might be missing. These checks
 ; reflect the currently inferred attributes.
 
 ; Use an opaque pointer type for all the (possibly opaque) structs.
 %opaque = type opaque
 
-; CHECK: declare double @__acos_finite(double)
+; CHECK-LINUX: declare double @__acos_finite(double) [[NOFREE:#[0-9]+]]
+; CHECK-NOLINUX: declare double @__acos_finite(double)
 declare double @__acos_finite(double)
 
-; CHECK: declare float @__acosf_finite(float)
+; CHECK-LINUX: declare float @__acosf_finite(float) [[NOFREE]]
+; CHECK-NOLINUX: declare float @__acosf_finite(float)
 declare float @__acosf_finite(float)
 
-; CHECK: declare double @__acosh_finite(double)
+; CHECK-LINUX: declare double @__acosh_finite(double) [[NOFREE]]
+; CHECK-NOLINUX: declare double @__acosh_finite(double)
 declare double @__acosh_finite(double)
 
-; CHECK: declare float @__acoshf_finite(float)
+; CHECK-LINUX: declare float @__acoshf_finite(float) [[NOFREE]]
+; CHECK-NOLINUX: declare float @__acoshf_finite(float)
 declare float @__acoshf_finite(float)
 
-; CHECK: declare x86_fp80 @__acoshl_finite(x86_fp80)
+; CHECK-LINUX: declare x86_fp80 @__acoshl_finite(x86_fp80) [[NOFREE]]
+; CHECK-NOLINUX: declare x86_fp80 @__acoshl_finite(x86_fp80)
 declare x86_fp80 @__acoshl_finite(x86_fp80)
 
-; CHECK: declare x86_fp80 @__acosl_finite(x86_fp80)
+; CHECK-LINUX: declare x86_fp80 @__acosl_finite(x86_fp80) [[NOFREE]]
+; CHECK-NOLINUX: declare x86_fp80 @__acosl_finite(x86_fp80)
 declare x86_fp80 @__acosl_finite(x86_fp80)
 
-; CHECK: declare double @__asin_finite(double)
+; CHECK-LINUX: declare double @__asin_finite(double) [[NOFREE]]
+; CHECK-NOLINUX: declare double @__asin_finite(double)
 declare double @__asin_finite(double)
 
-; CHECK: declare float @__asinf_finite(float)
+; CHECK-LINUX: declare float @__asinf_finite(float) [[NOFREE]]
+; CHECK-NOLINUX: declare float @__asinf_finite(float)
 declare float @__asinf_finite(float)
 
-; CHECK: declare x86_fp80 @__asinl_finite(x86_fp80)
+; CHECK-LINUX: declare x86_fp80 @__asinl_finite(x86_fp80) [[NOFREE]]
+; CHECK-NOLINUX: declare x86_fp80 @__asinl_finite(x86_fp80)
 declare x86_fp80 @__asinl_finite(x86_fp80)
 
-; CHECK: declare double @__atan2_finite(double, double)
+; CHECK-LINUX: declare double @__atan2_finite(double, double) [[NOFREE]]
+; CHECK-NOLINUX: declare double @__atan2_finite(double, double)
 declare double @__atan2_finite(double, double)
 
-; CHECK: declare float @__atan2f_finite(float, float)
+; CHECK-LINUX: declare float @__atan2f_finite(float, float) [[NOFREE]]
+; CHECK-NOLINUX: declare float @__atan2f_finite(float, float)
 declare float @__atan2f_finite(float, float)
 
-; CHECK: declare x86_fp80 @__atan2l_finite(x86_fp80, x86_fp80)
+; CHECK-LINUX: declare x86_fp80 @__atan2l_finite(x86_fp80, x86_fp80) [[NOFREE]]
+; CHECK-NOLINUX: declare x86_fp80 @__atan2l_finite(x86_fp80, x86_fp80)
 declare x86_fp80 @__atan2l_finite(x86_fp80, x86_fp80)
 
-; CHECK: declare double @__atanh_finite(double)
+; CHECK-LINUX: declare double @__atanh_finite(double) [[NOFREE]]
+; CHECK-NOLINUX: declare double @__atanh_finite(double)
 declare double @__atanh_finite(double)
 
-; CHECK: declare float @__atanhf_finite(float)
+; CHECK-LINUX: declare float @__atanhf_finite(float) [[NOFREE]]
+; CHECK-NOLINUX: declare float @__atanhf_finite(float)
 declare float @__atanhf_finite(float)
 
-; CHECK: declare x86_fp80 @__atanhl_finite(x86_fp80)
+; CHECK-LINUX: declare x86_fp80 @__atanhl_finite(x86_fp80) [[NOFREE]]
+; CHECK-NOLINUX: declare x86_fp80 @__atanhl_finite(x86_fp80)
 declare x86_fp80 @__atanhl_finite(x86_fp80)
 
-; CHECK: declare double @__cosh_finite(double)
+; CHECK-LINUX: declare double @__cosh_finite(double) [[NOFREE]]
+; CHECK-NOLINUX: declare double @__cosh_finite(double)
 declare double @__cosh_finite(double)
 
-; CHECK: declare float @__coshf_finite(float)
+; CHECK-LINUX: declare float @__coshf_finite(float) [[NOFREE]]
+; CHECK-NOLINUX: declare float @__coshf_finite(float)
 declare float @__coshf_finite(float)
 
-; CHECK: declare x86_fp80 @__coshl_finite(x86_fp80)
+; CHECK-LINUX: declare x86_fp80 @__coshl_finite(x86_fp80) [[NOFREE]]
+; CHECK-NOLINUX: declare x86_fp80 @__coshl_finite(x86_fp80)
 declare x86_fp80 @__coshl_finite(x86_fp80)
 
 ; CHECK: declare double @__cospi(double)
 declare double @__cospi(double)
 
 ; CHECK: declare float @__cospif(float)
 declare float @__cospif(float)
 
-; CHECK: declare double @__exp10_finite(double)
+; CHECK-LINUX: declare double @__exp10_finite(double) [[NOFREE]]
+; CHECK-NOLINUX: declare double @__exp10_finite(double)
 declare double @__exp10_finite(double)
 
-; CHECK: declare float @__exp10f_finite(float)
+; CHECK-LINUX: declare float @__exp10f_finite(float) [[NOFREE]]
+; CHECK-NOLINUX: declare float @__exp10f_finite(float)
 declare float @__exp10f_finite(float)
 
-; CHECK: declare x86_fp80 @__exp10l_finite(x86_fp80)
+; CHECK-LINUX: declare x86_fp80 @__exp10l_finite(x86_fp80) [[NOFREE]]
+; CHECK-NOLINUX: declare x86_fp80 @__exp10l_finite(x86_fp80)
 declare x86_fp80 @__exp10l_finite(x86_fp80)
 
-; CHECK: declare double @__exp2_finite(double)
+; CHECK-LINUX: declare double @__exp2_finite(double) [[NOFREE]]
+; CHECK-NOLINUX: declare double @__exp2_finite(double)
 declare double @__exp2_finite(double)
 
-; CHECK: declare float @__exp2f_finite(float)
+; CHECK-LINUX: declare float @__exp2f_finite(float) [[NOFREE]]
+; CHECK-NOLINUX: declare float @__exp2f_finite(float)
 declare float @__exp2f_finite(float)
 
-; CHECK: declare x86_fp80 @__exp2l_finite(x86_fp80)
+; CHECK-LINUX: declare x86_fp80 @__exp2l_finite(x86_fp80) [[NOFREE]]
+; CHECK-NOLINUX: declare x86_fp80 @__exp2l_finite(x86_fp80)
 declare x86_fp80 @__exp2l_finite(x86_fp80)
 
-; CHECK: declare double @__exp_finite(double)
+; CHECK-LINUX: declare double @__exp_finite(double) [[NOFREE]]
+; CHECK-NOLINUX: declare double @__exp_finite(double)
 declare double @__exp_finite(double)
 
-; CHECK: declare float @__expf_finite(float)
+; CHECK-LINUX: declare float @__expf_finite(float) [[NOFREE]]
+; CHECK-NOLINUX: declare float @__expf_finite(float)
 declare float @__expf_finite(float)
 
-; CHECK: declare x86_fp80 @__expl_finite(x86_fp80)
+; CHECK-LINUX: declare x86_fp80 @__expl_finite(x86_fp80) [[NOFREE]]
+; CHECK-NOLINUX: declare x86_fp80 @__expl_finite(x86_fp80)
 declare x86_fp80 @__expl_finite(x86_fp80)
 
-; CHECK: declare double @__log10_finite(double)
+; CHECK-LINUX: declare double @__log10_finite(double) [[NOFREE]]
+; CHECK-NOLINUX: declare double @__log10_finite(double)
 declare double @__log10_finite(double)
 
-; CHECK: declare float @__log10f_finite(float)
+; CHECK-LINUX: declare float @__log10f_finite(float) [[NOFREE]]
+; CHECK-NOLINUX: declare float @__log10f_finite(float)
 declare float @__log10f_finite(float)
 
-; CHECK: declare x86_fp80 @__log10l_finite(x86_fp80)
+; CHECK-LINUX: declare x86_fp80 @__log10l_finite(x86_fp80) [[NOFREE]]
+; CHECK-NOLINUX: declare x86_fp80 @__log10l_finite(x86_fp80)
 declare x86_fp80 @__log10l_finite(x86_fp80)
 
-; CHECK: declare double @__log2_finite(double)
+; CHECK-LINUX: declare double @__log2_finite(double) [[NOFREE]]
+; CHECK-NOLINUX: declare double @__log2_finite(double)
 declare double @__log2_finite(double)
 
-; CHECK: declare float @__log2f_finite(float)
+; CHECK-LINUX: declare float @__log2f_finite(float) [[NOFREE]]
+; CHECK-NOLINUX: declare float @__log2f_finite(float)
 declare float @__log2f_finite(float)
 
-; CHECK: declare x86_fp80 @__log2l_finite(x86_fp80)
+; CHECK-LINUX: declare x86_fp80 @__log2l_finite(x86_fp80) [[NOFREE]]
+; CHECK-NOLINUX: declare x86_fp80 @__log2l_finite(x86_fp80)
 declare x86_fp80 @__log2l_finite(x86_fp80)
 
-; CHECK: declare double @__log_finite(double)
+; CHECK-LINUX: declare double @__log_finite(double) [[NOFREE]]
+; CHECK-NOLINUX: declare double @__log_finite(double)
 declare double @__log_finite(double)
 
-; CHECK: declare float @__logf_finite(float)
+; CHECK-LINUX: declare float @__logf_finite(float) [[NOFREE]]
+; CHECK-NOLINUX: declare float @__logf_finite(float)
 declare float @__logf_finite(float)
 
-; CHECK: declare x86_fp80 @__logl_finite(x86_fp80)
+; CHECK-LINUX: declare x86_fp80 @__logl_finite(x86_fp80) [[NOFREE]]
+; CHECK-NOLINUX: declare x86_fp80 @__logl_finite(x86_fp80)
 declare x86_fp80 @__logl_finite(x86_fp80)
 
-; CHECK: declare double @__pow_finite(double, double)
+; CHECK-LINUX: declare double @__pow_finite(double, double) [[NOFREE]]
+; CHECK-NOLINUX: declare double @__pow_finite(double, double)
 declare double @__pow_finite(double, double)
 
-; CHECK: declare float @__powf_finite(float, float)
+; CHECK-LINUX: declare float @__powf_finite(float, float) [[NOFREE]]
+; CHECK-NOLINUX: declare float @__powf_finite(float, float)
 declare float @__powf_finite(float, float)
 
-; CHECK: declare x86_fp80 @__powl_finite(x86_fp80, x86_fp80)
+; CHECK-LINUX: declare x86_fp80 @__powl_finite(x86_fp80, x86_fp80) [[NOFREE]]
+; CHECK-NOLINUX: declare x86_fp80 @__powl_finite(x86_fp80, x86_fp80)
 declare x86_fp80 @__powl_finite(x86_fp80, x86_fp80)
 
-; CHECK: declare double @__sinh_finite(double)
+; CHECK-LINUX: declare double @__sinh_finite(double) [[NOFREE]]
+; CHECK-NOLINUX: declare double @__sinh_finite(double)
 declare double @__sinh_finite(double)
 
-; CHECK: declare float @__sinhf_finite(float)
+; CHECK-LINUX: declare float @__sinhf_finite(float) [[NOFREE]]
+; CHECK-NOLINUX: declare float @__sinhf_finite(float)
 declare float @__sinhf_finite(float)
 
-; CHECK: declare x86_fp80 @__sinhl_finite(x86_fp80)
+; CHECK-LINUX: declare x86_fp80 @__sinhl_finite(x86_fp80) [[NOFREE]]
+; CHECK-NOLINUX: declare x86_fp80 @__sinhl_finite(x86_fp80)
 declare x86_fp80 @__sinhl_finite(x86_fp80)
 
 ; CHECK: declare double @__sinpi(double)
 declare double @__sinpi(double)
 
 ; CHECK: declare float @__sinpif(float)
 declare float @__sinpif(float)
 

 declare double @nearbyint(double)
 
 ; CHECK: declare float @nearbyintf(float) [[NOFREE_NOUNWIND_WILLRETURN]]
 declare float @nearbyintf(float)
 
 ; CHECK: declare x86_fp80 @nearbyintl(x86_fp80) [[NOFREE_NOUNWIND_WILLRETURN]]
 declare x86_fp80 @nearbyintl(x86_fp80)
 
-; CHECK: declare noundef i32 @open(i8* nocapture noundef readonly, i32 noundef, ...) [[NOFREE:#[0-9]+]]
+; CHECK-LINUX: declare noundef i32 @open(i8* nocapture noundef readonly, i32 noundef, ...) [[NOFREE]]
+; CHECK-OPEN: declare noundef i32 @open(i8* nocapture noundef readonly, i32 noundef, ...) [[NOFREE:#[0-9]+]]
 declare i32 @open(i8*, i32, ...)
 
 ; CHECK-LINUX: declare noundef i32 @open64(i8* nocapture noundef readonly, i32 noundef, ...) [[NOFREE]]
 declare i32 @open64(i8*, i32, ...)
 
 ; CHECK: declare noalias noundef %opaque* @opendir(i8* nocapture noundef readonly) [[NOFREE_NOUNWIND]]
 declare %opaque* @opendir(i8*)
 

llvm/test/Transforms/InferFunctionAttrs/no-proto.ll

-; RUN: opt < %s -mtriple=x86_64-unknown-linux -inferattrs -S | FileCheck %s
-; RUN: opt < %s -mtriple=x86_64-apple-macosx10.8.0 -inferattrs -S | FileCheck %s
+; RUN: opt < %s -mtriple=x86_64-unknown-linux -inferattrs -S | FileCheck --match-full-lines %s
+; RUN: opt < %s -mtriple=x86_64-apple-macosx10.8.0 -inferattrs -S | FileCheck --match-full-lines %s
 
 ; Check that we don't modify libc functions with invalid prototypes.
 
 ; CHECK: declare void @__acos_finite(...)
 declare void @__acos_finite(...)
 
 ; CHECK: declare void @__acosf_finite(...)
 declare void @__acosf_finite(...)

llvm/test/Transforms/InferFunctionAttrs/nobuiltin.ll

 ; RUN: opt -S -inferattrs < %s | FileCheck %s
 
-; CHECK: Function Attrs: nobuiltin allocsize(0)
+; CHECK: Function Attrs: nobuiltin allocsize(0){{$}}
 ; CHECK: declare i8* @_Znwm(i32)
 declare i8* @_Znwm(i32) nobuiltin allocsize(0)