PNaCl: Add support for GCC/LLVM vector extensions

test/NaCl/PNaClABI/function-signatures.ll

Index: test/NaCl/PNaClABI/function-signatures.ll
diff --git a/test/NaCl/PNaClABI/function-signatures.ll b/test/NaCl/PNaClABI/function-signatures.ll
new file mode 100644
index 0000000000000000000000000000000000000000..5ff1054ea29fd7b631fcd0695adc98f3ca63da79
--- /dev/null
+++ b/test/NaCl/PNaClABI/function-signatures.ll
@@ -0,0 +1,181 @@
+; RUN: not pnacl-abicheck < %s | FileCheck %s
+
+; Test type-checking of function signatures.
+
+; CHECK: Function f_arg_i1 has disallowed type: void (i1)
+; CHECK: Function f_ret_i1 has disallowed type: i1 ()
+define internal void @f_arg_i1(i1 %a) {
+  ret void
+}
+define internal i1 @f_ret_i1() {
+  ret i1 undef
+}
+
+; CHECK: Function f_arg_i8 has disallowed type: void (i8)
+; CHECK: Function f_ret_i8 has disallowed type: i8 ()
+define internal void @f_arg_i8(i8 %a) {
+  ret void
+}
+define internal i8 @f_ret_i8() {
+  ret i8 undef
+}
+
+; CHECK: Function f_arg_i16 has disallowed type: void (i16)
+; CHECK: Function f_ret_i16 has disallowed type: i16 ()
+define internal void @f_arg_i16(i16 %a) {
+  ret void
+}
+define internal i16 @f_ret_i16() {
+  ret i16 undef
+}
+
+; CHECK-NOT: f_{{[a-z]+}}_i32 {{.*}} disallowed
+define internal void @f_arg_i32(i32 %a) {
+  ret void
+}
+define internal i32 @f_ret_i32() {
+  ret i32 undef
+}
+
+; CHECK-NOT: f_{{[a-z]+}}_i64 {{.*}} disallowed
+define internal void @f_arg_i64(i64 %a) {
+  ret void
+}
+define internal i64 @f_ret_i64() {
+  ret i64 undef
+}
+
+; CHECK: Function f_arg_i128 has disallowed type: void (i128)
+; CHECK: Function f_ret_i128 has disallowed type: i128 ()
+define internal void @f_arg_i128(i128 %a) {
+  ret void
+}
+define internal i128 @f_ret_i128() {
+  ret i128 undef
+}
+
+; CHECK-NOT: f_{{[a-z]+}}_float {{.*}} disallowed
+define internal void @f_arg_float(float %a) {
+  ret void
+}
+define internal float @f_ret_float() {
+  ret float undef
+}
+
+; CHECK-NOT: f_{{[a-z]+}}_double {{.*}} disallowed
+define internal void @f_arg_double(double %a) {
+  ret void
+}
+define internal double @f_ret_double() {
+  ret double undef
+}
+
+; CHECK: Function f_arg_1xi1 has disallowed type: void (<1 x i1>)
+; CHECK: Function f_ret_1xi1 has disallowed type: <1 x i1> ()
+define internal void @f_arg_1xi1(<1 x i1> %a) {
+  ret void
+}
+define internal <1 x i1> @f_ret_1xi1() {
+  ret <1 x i1> undef
+}
+
+; CHECK: Function f_arg_2xi1 has disallowed type: void (<2 x i1>)
+; CHECK: Function f_ret_2xi1 has disallowed type: <2 x i1> ()
+define internal void @f_arg_2xi1(<2 x i1> %a) {
+  ret void
+}
+define internal <2 x i1> @f_ret_2xi1() {
+  ret <2 x i1> undef
+}
+
+; CHECK-NOT: f_{{[a-z]+}}_4xi1 {{.*}} disallowed
+define internal void @f_arg_4xi1(<4 x i1> %a) {
+  ret void
+}
+define internal <4 x i1> @f_ret_4xi1() {
+  ret <4 x i1> undef
+}
+
+; CHECK-NOT: f_{{[a-z]+}}_8xi1 {{.*}} disallowed
+define internal void @f_arg_8xi1(<8 x i1> %a) {
+  ret void
+}
+define internal <8 x i1> @f_ret_8xi1() {
+  ret <8 x i1> undef
+}
+
+; CHECK-NOT: f_{{[a-z]+}}_16xi1 {{.*}} disallowed
+define internal void @f_arg_16xi1(<16 x i1> %a) {
+  ret void
+}
+define internal <16 x i1> @f_ret_16xi1() {
+  ret <16 x i1> undef
+}
+
+; CHECK: Function f_arg_32xi1 has disallowed type: void (<32 x i1>)
+; CHECK: Function f_ret_32xi1 has disallowed type: <32 x i1> ()
+define internal void @f_arg_32xi1(<32 x i1> %a) {
+  ret void
+}
+define internal <32 x i1> @f_ret_32xi1() {
+  ret <32 x i1> undef
+}
+
+; CHECK: Function f_arg_64xi1 has disallowed type: void (<64 x i1>)
+; CHECK: Function f_ret_64xi1 has disallowed type: <64 x i1> ()
+define internal void @f_arg_64xi1(<64 x i1> %a) {
+  ret void
+}
+define internal <64 x i1> @f_ret_64xi1() {
+  ret <64 x i1> undef
+}
+
+; CHECK-NOT: f_{{[a-z]+}}_16xi8 {{.*}} disallowed
+define internal void @f_arg_16xi8(<16 x i8> %a) {
+  ret void
+}
+define internal <16 x i8> @f_ret_16xi8() {
+  ret <16 x i8> undef
+}
+
+; CHECK-NOT: f_{{[a-z]+}}_8xi16 {{.*}} disallowed
+define internal void @f_arg_8xi16(<8 x i16> %a) {
+  ret void
+}
+define internal <8 x i16> @f_ret_8xi16() {
+  ret <8 x i16> undef
+}
+
+; CHECK-NOT: f_{{[a-z]+}}_4xi32 {{.*}} disallowed
+define internal void @f_arg_4xi32(<4 x i32> %a) {
+  ret void
+}
+define internal <4 x i32> @f_ret_4xi32() {
+  ret <4 x i32> undef
+}
+
+; CHECK: Function f_arg_2xi64 has disallowed type: void (<2 x i64>)
+; CHECK: Function f_ret_2xi64 has disallowed type: <2 x i64> ()
+define internal void @f_arg_2xi64(<2 x i64> %a) {
+  ret void
+}
+define internal <2 x i64> @f_ret_2xi64() {
+  ret <2 x i64> undef
+}
+
+; CHECK-NOT: f_{{[a-z]+}}_4xfloat {{.*}} disallowed
+define internal void @f_arg_4xfloat(<4 x float> %a) {
+  ret void
+}
+define internal <4 x float> @f_ret_4xfloat() {
+  ret <4 x float> undef
+}
+
+; CHECK: Function f_arg_2xdouble has disallowed type: void (<2 x double>)
+; CHECK: Function f_ret_2xdouble has disallowed type: <2 x double> ()
+define internal void @f_arg_2xdouble(<2 x double> %a) {
+  ret void
+}
+define internal <2 x double> @f_ret_2xdouble() {
+  ret <2 x double> undef
+}