[AArch64][SVE] clang: Add missing svbfloat16_t tests

[c-rhodes]

Summary

Patch adds tests for mangling of svbfloat16_t and several other type
related tests.

[fpetrogalli]

clang/test/CodeGenCXX/aarch64-sve-typeinfo.cpp

4

I wonder if we should keep the bf16 tests separate, as +bf16 is not needed to generate any of the other SVE types. I don't have strong opinions here, but it seems a better thing to do to isolate the bfloat tests in SVE in a separate file. What do you think, @c-rhodes?

[c-rhodes]

clang/test/CodeGenCXX/aarch64-sve-typeinfo.cpp

4

I wonder if we should keep the bf16 tests separate, as +bf16 is not needed to generate any of the other SVE types. I don't have strong opinions here, but it seems a better thing to do to isolate the bfloat tests in SVE in a separate file. What do you think, @c-rhodes?

I don't think either +sve or +bf16 are actually required in any of these tests since they're directly using the ACLE types and not including arm_sve.h. Where I've added +bf16 I've done so to be consistent, but notice there's some tests with no target feature and some that have run lines covering both. I'd prefer to keep to tests together.

[sdesmalen]

LGTM!

[fpetrogalli]

Ship it! :)

clang/test/CodeGen/aarch64-sve.c

 // RUN: not %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve \
 // RUN:  -emit-llvm -o - %s -debug-info-kind=limited 2>&1 | FileCheck %s -check-prefix=CHECK-DEBUG
 // RUN: %clang_cc1 -triple aarch64-none-linux-gnu -target-feature +sve \
 // RUN:  -emit-llvm -o - %s 2>&1 | FileCheck %s -check-prefix=CHECK
 
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVInt8_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVInt16_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVInt32_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVInt64_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVUint8_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVUint16_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVUint32_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVUint64_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVFloat16_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVFloat32_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVFloat64_t'
+// CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVBFloat16_t'
 // CHECK-DEBUG: cannot yet generate debug info for SVE type '__SVBool_t'
 
 // CHECK: @ptr = global <vscale x 16 x i8>* null, align 8
 // CHECK: %s8 = alloca <vscale x 16 x i8>, align 16
 // CHECK: %s16 = alloca <vscale x 8 x i16>, align 16
 // CHECK: %s32 = alloca <vscale x 4 x i32>, align 16
 // CHECK: %s64 = alloca <vscale x 2 x i64>, align 16
 // CHECK: %u8 = alloca <vscale x 16 x i8>, align 16
 // CHECK: %u16 = alloca <vscale x 8 x i16>, align 16
 // CHECK: %u32 = alloca <vscale x 4 x i32>, align 16
 // CHECK: %u64 = alloca <vscale x 2 x i64>, align 16
 // CHECK: %f16 = alloca <vscale x 8 x half>, align 16
 // CHECK: %f32 = alloca <vscale x 4 x float>, align 16
 // CHECK: %f64 = alloca <vscale x 2 x double>, align 16
+// CHECK: %bf16 = alloca <vscale x 8 x bfloat>, align 16
 // CHECK: %b8 = alloca <vscale x 16 x i1>, align 2
 
 __SVInt8_t *ptr;
 
 void test_locals(void) {
   __SVInt8_t s8;
   __SVInt16_t s16;
   __SVInt32_t s32;
   __SVInt64_t s64;
 
   __SVUint8_t u8;
   __SVUint16_t u16;
   __SVUint32_t u32;
   __SVUint64_t u64;
 
   __SVFloat16_t f16;
   __SVFloat32_t f32;
   __SVFloat64_t f64;
 
+  __SVBFloat16_t bf16;
+
   __SVBool_t b8;
 }

clang/test/CodeGenCXX/aarch64-mangle-sve-vectors.cpp

 // RUN: %clang_cc1 -triple aarch64-none-linux-gnu %s -emit-llvm -o - \
 // RUN:   | FileCheck %s
 // RUN: %clang_cc1 -triple aarch64-none-linux-gnu %s -emit-llvm -o - \
-// RUN:   -target-feature +sve | FileCheck %s
+// RUN:   -target-feature +sve,+bf16 | FileCheck %s
 
 template<typename T> struct S {};
 
 // CHECK: _Z2f11SIu10__SVInt8_tE
 void f1(S<__SVInt8_t>) {}
 // CHECK: _Z2f21SIu11__SVInt16_tE
 void f2(S<__SVInt16_t>) {}
 // CHECK: _Z2f31SIu11__SVInt32_tE

 // CHECK: _Z2f81SIu12__SVUint64_tE
 void f8(S<__SVUint64_t>) {}
 // CHECK: _Z2f91SIu13__SVFloat16_tE
 void f9(S<__SVFloat16_t>) {}
 // CHECK: _Z3f101SIu13__SVFloat32_tE
 void f10(S<__SVFloat32_t>) {}
 // CHECK: _Z3f111SIu13__SVFloat64_tE
 void f11(S<__SVFloat64_t>) {}
-// CHECK: _Z3f121SIu10__SVBool_tE
-void f12(S<__SVBool_t>) {}
+// CHECK: _Z3f121SIu14__SVBFloat16_tE
+void f12(S<__SVBFloat16_t>) {}
+// CHECK: _Z3f131SIu10__SVBool_tE
+void f13(S<__SVBool_t>) {}
 
 // The tuple types don't use the internal name for mangling.
 
 // CHECK: _Z3f131SI10svint8x2_tE
 void f13(S<__clang_svint8x2_t>) {}
 // CHECK: _Z3f141SI10svint8x3_tE
 void f14(S<__clang_svint8x3_t>) {}
 // CHECK: _Z3f151SI10svint8x4_tE

 // CHECK: _Z3f421SI13svfloat32x4_tE
 void f42(S<__clang_svfloat32x4_t>) {}
 // CHECK: _Z3f431SI13svfloat64x2_tE
 void f43(S<__clang_svfloat64x2_t>) {}
 // CHECK: _Z3f441SI13svfloat64x3_tE
 void f44(S<__clang_svfloat64x3_t>) {}
 // CHECK: _Z3f451SI13svfloat64x4_tE
 void f45(S<__clang_svfloat64x4_t>) {}
+// CHECK: _Z3f461SI14svbfloat16x2_tE
+void f46(S<__clang_svbfloat16x2_t>) {}
+// CHECK: _Z3f471SI14svbfloat16x3_tE
+void f47(S<__clang_svbfloat16x3_t>) {}
+// CHECK: _Z3f481SI14svbfloat16x4_tE
+void f48(S<__clang_svbfloat16x4_t>) {}

clang/test/CodeGenCXX/aarch64-sve-typeinfo.cpp

 // RUN: %clang_cc1 -triple aarch64-none-linux-gnu %s -emit-llvm -o - \
 // RUN:   | FileCheck %s
 // RUN: %clang_cc1 -triple aarch64-none-linux-gnu %s -emit-llvm -o - \
-// RUN:   -target-feature +sve | FileCheck %s
+// RUN:   -target-feature +sve,+bf16 | FileCheck %s
 
 namespace std { class type_info; };
 
 auto &s8 = typeid(__SVInt8_t);
 auto &s16 = typeid(__SVInt16_t);
 auto &s32 = typeid(__SVInt32_t);
 auto &s64 = typeid(__SVInt64_t);
 
 auto &u8 = typeid(__SVUint8_t);
 auto &u16 = typeid(__SVUint16_t);
 auto &u32 = typeid(__SVUint32_t);
 auto &u64 = typeid(__SVUint64_t);
 
 auto &f16 = typeid(__SVFloat16_t);
 auto &f32 = typeid(__SVFloat32_t);
 auto &f64 = typeid(__SVFloat64_t);
 
+auto &bf16 = typeid(__SVBFloat16_t);
+
 auto &b8 = typeid(__SVBool_t);
 
 // CHECK-DAG: @_ZTSu10__SVInt8_t = {{.*}} c"u10__SVInt8_t\00"
 // CHECK-DAG: @_ZTIu10__SVInt8_t = {{.*}} @_ZTVN10__cxxabiv123__fundamental_type_infoE, {{.*}} @_ZTSu10__SVInt8_t
 
 // CHECK-DAG: @_ZTSu11__SVInt16_t = {{.*}} c"u11__SVInt16_t\00"
 // CHECK-DAG: @_ZTIu11__SVInt16_t = {{.*}} @_ZTVN10__cxxabiv123__fundamental_type_infoE, {{.*}} @_ZTSu11__SVInt16_t
 

 // CHECK-DAG: @_ZTSu13__SVFloat16_t = {{.*}} c"u13__SVFloat16_t\00"
 // CHECK-DAG: @_ZTIu13__SVFloat16_t = {{.*}} @_ZTVN10__cxxabiv123__fundamental_type_infoE, {{.*}} @_ZTSu13__SVFloat16_t
 
 // CHECK-DAG: @_ZTSu13__SVFloat32_t = {{.*}} c"u13__SVFloat32_t\00"
 // CHECK-DAG: @_ZTIu13__SVFloat32_t = {{.*}} @_ZTVN10__cxxabiv123__fundamental_type_infoE, {{.*}} @_ZTSu13__SVFloat32_t
 
 // CHECK-DAG: @_ZTSu13__SVFloat64_t = {{.*}} c"u13__SVFloat64_t\00"
 // CHECK-DAG: @_ZTIu13__SVFloat64_t = {{.*}} @_ZTVN10__cxxabiv123__fundamental_type_infoE, {{.*}} @_ZTSu13__SVFloat64_t
+//
+// CHECK-DAG: @_ZTSu14__SVBFloat16_t = {{.*}} c"u14__SVBFloat16_t\00"
+// CHECK-DAG: @_ZTIu14__SVBFloat16_t = {{.*}} @_ZTVN10__cxxabiv123__fundamental_type_infoE, {{.*}} @_ZTSu14__SVBFloat16_t
 
 // CHECK-DAG: @_ZTSu10__SVBool_t = {{.*}} c"u10__SVBool_t\00"
 // CHECK-DAG: @_ZTIu10__SVBool_t = {{.*}} @_ZTVN10__cxxabiv123__fundamental_type_infoE, {{.*}} @_ZTSu10__SVBool_t

clang/test/CodeGenObjC/aarch64-sve-types.m

 // RUN: not %clang_cc1 -triple aarch64-none-linux-gnu %s -emit-llvm -o - \
 // RUN:   2>&1 | FileCheck %s
 // RUN: not %clang_cc1 -triple aarch64-none-linux-gnu %s -emit-llvm -o - \
-// RUN:   -target-feature +sve 2>&1 | FileCheck %s
+// RUN:   -target-feature +sve,+bf16 2>&1 | FileCheck %s
 
 // CHECK: error: cannot yet @encode type __SVInt8_t
 const char s8[] = @encode(__SVInt8_t);
 // CHECK: error: cannot yet @encode type __SVInt16_t
 const char s16[] = @encode(__SVInt16_t);
 // CHECK: error: cannot yet @encode type __SVInt32_t
 const char s32[] = @encode(__SVInt32_t);
 // CHECK: error: cannot yet @encode type __SVInt64_t

 
 // CHECK: error: cannot yet @encode type __SVFloat16_t
 const char f16[] = @encode(__SVFloat16_t);
 // CHECK: error: cannot yet @encode type __SVFloat32_t
 const char f32[] = @encode(__SVFloat32_t);
 // CHECK: error: cannot yet @encode type __SVFloat64_t
 const char f64[] = @encode(__SVFloat64_t);
 
+// CHECK: error: cannot yet @encode type __SVBFloat16_t
+const char bf16[] = @encode(__SVBFloat16_t);
+
 // CHECK: error: cannot yet @encode type __SVBool_t
 const char b8[] = @encode(__SVBool_t);

clang/test/PCH/aarch64-sve-types.c

 __SVUint16_t *u16;
 __SVUint32_t *u32;
 __SVUint64_t *u64;
 
 __SVFloat16_t *f16;
 __SVFloat32_t *f32;
 __SVFloat64_t *f64;
 
+__SVBFloat16_t *bf16;
+
 __SVBool_t *b8;

clang/test/Sema/aarch64-sve-types.c

-// RUN: %clang_cc1 %s -triple aarch64-none-linux-gnu -target-feature +sve -fsyntax-only -verify
+// RUN: %clang_cc1 %s -triple aarch64-none-linux-gnu -target-feature +sve,+bf16 -fsyntax-only -verify
 
 void f() {
   int size_s8[sizeof(__SVInt8_t) == 0 ? 1 : -1];        // expected-error {{invalid application of 'sizeof' to sizeless type '__SVInt8_t'}}
   int align_s8[__alignof__(__SVInt8_t) == 16 ? 1 : -1]; // expected-error {{invalid application of '__alignof' to sizeless type '__SVInt8_t'}}
 
   int size_s16[sizeof(__SVInt16_t) == 0 ? 1 : -1];        // expected-error {{invalid application of 'sizeof' to sizeless type '__SVInt16_t'}}
   int align_s16[__alignof__(__SVInt16_t) == 16 ? 1 : -1]; // expected-error {{invalid application of '__alignof' to sizeless type '__SVInt16_t'}}
 
void f() {
   int align_f16[__alignof__(__SVFloat16_t) == 16 ? 1 : -1]; // expected-error {{invalid application of '__alignof' to sizeless type '__SVFloat16_t'}}
 
   int size_f32[sizeof(__SVFloat32_t) == 0 ? 1 : -1];        // expected-error {{invalid application of 'sizeof' to sizeless type '__SVFloat32_t'}}
   int align_f32[__alignof__(__SVFloat32_t) == 16 ? 1 : -1]; // expected-error {{invalid application of '__alignof' to sizeless type '__SVFloat32_t'}}
 
   int size_f64[sizeof(__SVFloat64_t) == 0 ? 1 : -1];        // expected-error {{invalid application of 'sizeof' to sizeless type '__SVFloat64_t'}}
   int align_f64[__alignof__(__SVFloat64_t) == 16 ? 1 : -1]; // expected-error {{invalid application of '__alignof' to sizeless type '__SVFloat64_t'}}
 
+  int size_bf16[sizeof(__SVBFloat16_t) == 0 ? 1 : -1];        // expected-error {{invalid application of 'sizeof' to sizeless type '__SVBFloat16_t'}}
+  int align_bf16[__alignof__(__SVBFloat16_t) == 16 ? 1 : -1]; // expected-error {{invalid application of '__alignof' to sizeless type '__SVBFloat16_t'}}
+
   int size_b8[sizeof(__SVBool_t) == 0 ? 1 : -1];       // expected-error {{invalid application of 'sizeof' to sizeless type '__SVBool_t'}}
   int align_b8[__alignof__(__SVBool_t) == 2 ? 1 : -1]; // expected-error {{invalid application of '__alignof' to sizeless type '__SVBool_t'}}
 }

clang/test/SemaObjC/aarch64-sve-types.m

 @property(nullable) __SVUint16_t u16; // expected-error {{cannot be applied to non-pointer type}}
 @property(nullable) __SVUint32_t u32; // expected-error {{cannot be applied to non-pointer type}}
 @property(nullable) __SVUint64_t u64; // expected-error {{cannot be applied to non-pointer type}}
 
 @property(nullable) __SVFloat16_t f16; // expected-error {{cannot be applied to non-pointer type}}
 @property(nullable) __SVFloat32_t f32; // expected-error {{cannot be applied to non-pointer type}}
 @property(nullable) __SVFloat64_t f64; // expected-error {{cannot be applied to non-pointer type}}
 
+@property(nullable) __SVBFloat16_t bf16; // expected-error {{cannot be applied to non-pointer type}}
+
 @property(nullable) __SVBool_t b8; // expected-error {{cannot be applied to non-pointer type}}
 @end