[PowerPC] Disable vector types when not supported by subtarget features

[lei]

Summary

Update clang to treat vector unsigned long long and friends as invalid
for AltiVec without VSX.

Reported in: https://bugs.llvm.org/show_bug.cgi?id=47782

[lei]

fix spelling in commit message.

[NeHuang]

clang/test/CodeGen/builtins-ppc-int128.c

5

nit: indentation

clang/test/Parser/altivec.c

92

Will this patch also impact vector double? If not, can we move #ifndef __VSX__ down below vector double v_d2;?

clang/test/Parser/cxx-altivec.cpp

91–92

same as above.

[lei]

clang/test/CodeGen/builtins-ppc-int128.c

5

thx. Will fix before comit.

clang/test/Parser/altivec.c

92

This patch doesn't, but this is needed here since I added RUN line to test behavior for when VSX is enabled. Note the test lines was not changed for vector double.

clang/test/Parser/cxx-altivec.cpp

91–92

needed due to new RUN line added.

[nemanjai]

It is not clear what this patch will do with vector [[un]signed] long. This is currently deprecated but still works - and we don't want it to work with no VSX.

clang/lib/Headers/altivec.h

8881

This file is huge and there is a lot of conditional compilation within it. Can you please add comments to terminating endif as to what it is terminating. Presumably this one here terminates __VSX__.

[lei]

Address review comments and add handling for vector long types without vsx.

[nemanjai]

LGTM.

[amyk]

Overall LGTM.

clang/test/CodeGen/builtins-ppc-int128.c

8

nit: RUN line slightly too long.

[lei]

address line comment and update tc to reflect new behaviour.

clang/include/clang/Basic/DiagnosticSemaKinds.td

 def err_invalid_vector_float_decl_spec : Error<
   "cannot use 'float' with '__vector'">;
 def err_invalid_vector_double_decl_spec : Error <
   "use of 'double' with '__vector' requires VSX support to be enabled "
   "(available on POWER7 or later)">;
 def err_invalid_vector_bool_int128_decl_spec : Error <
   "use of '__int128' with '__vector bool' requires VSX support enabled (on "
   "POWER10 or later)">;
+def err_invalid_vector_int128_decl_spec : Error<
+  "use of '__int128' with '__vector' requires extended Altivec support"
+  " (available on POWER8 or later)">;
 def err_invalid_vector_long_long_decl_spec : Error <
-  "use of 'long long' with '__vector bool' requires VSX support (available on "
-  "POWER7 or later) or extended Altivec support (available on POWER8 or later) "
-  "to be enabled">;
+  "use of 'long long' with '__vector' requires VSX support (available on "
+  "POWER7 or later) to be enabled">;
 def err_invalid_vector_long_double_decl_spec : Error<
   "cannot use 'long double' with '__vector'">;
 def warn_vector_long_decl_spec_combination : Warning<
   "Use of 'long' with '__vector' is deprecated">, InGroup<Deprecated>;
 
 def err_redeclaration_different_type : Error<
   "redeclaration of %0 with a different type%diff{: $ vs $|}1,2">;
 def err_bad_variable_name : Error<

clang/lib/Headers/altivec.h

vec_sl(vector unsigned long long __a, vector unsigned long long __b) {
   return __a << (__b % (vector unsigned long long)(sizeof(unsigned long long) *
                                                    __CHAR_BIT__));
 }
 
 static __inline__ vector long long __ATTRS_o_ai
 vec_sl(vector long long __a, vector unsigned long long __b) {
   return (vector long long)vec_sl((vector unsigned long long)__a, __b);
 }
-#else
+#elif defined(__VSX__)
 static __inline__ vector unsigned char __ATTRS_o_ai
 vec_vspltb(vector unsigned char __a, unsigned char __b);
 static __inline__ vector unsigned long long __ATTRS_o_ai
 vec_sl(vector unsigned long long __a, vector unsigned long long __b) {
   __b %= (vector unsigned long long)(sizeof(unsigned long long) * __CHAR_BIT__);
 
   // Big endian element one (the right doubleword) can be left shifted as-is.
   // The other element needs to be swapped into the right doubleword and
return (vector unsigned long long)__builtin_shufflevector(__leftelt,
                                                             __rightelt, 1, 3);
 #endif
 }
 
 static __inline__ vector long long __ATTRS_o_ai
 vec_sl(vector long long __a, vector unsigned long long __b) {
   return (vector long long)vec_sl((vector unsigned long long)__a, __b);
 }
 #endif
 
 /* vec_vslb */
 
 #define __builtin_altivec_vslb vec_vslb
 
 static __inline__ vector signed char __ATTRS_o_ai
 vec_vslb(vector signed char __a, vector unsigned char __b) {
   return vec_sl(__a, __b);
vec_sr(vector unsigned long long __a, vector unsigned long long __b) {
   return __a >> (__b % (vector unsigned long long)(sizeof(unsigned long long) *
                                                    __CHAR_BIT__));
 }
 
 static __inline__ vector long long __ATTRS_o_ai
 vec_sr(vector long long __a, vector unsigned long long __b) {
   return (vector long long)vec_sr((vector unsigned long long)__a, __b);
 }
-#else
+#elif defined(__VSX__)
 static __inline__ vector unsigned long long __ATTRS_o_ai
 vec_sr(vector unsigned long long __a, vector unsigned long long __b) {
   __b %= (vector unsigned long long)(sizeof(unsigned long long) * __CHAR_BIT__);
 
   // Big endian element zero (the left doubleword) can be right shifted as-is.
   // However the shift amount must be in the right doubleword.
   // The other element needs to be swapped into the left doubleword and
   // shifted. Then the left doublewords of the two result vectors are merged.

 vec_sra(vector signed long long __a, vector unsigned long long __b) {
   return __a >> __b;
 }
 
 static __inline__ vector unsigned long long __ATTRS_o_ai
 vec_sra(vector unsigned long long __a, vector unsigned long long __b) {
   return (vector unsigned long long)((vector signed long long)__a >> __b);
 }
-#else
+#elif defined(__VSX__)
 static __inline__ vector signed long long __ATTRS_o_ai
 vec_sra(vector signed long long __a, vector unsigned long long __b) {
   __b %= (vector unsigned long long)(sizeof(unsigned long long) * __CHAR_BIT__);
   return __a >> __b;
 }
 
 static __inline__ vector unsigned long long __ATTRS_o_ai
 vec_sra(vector unsigned long long __a, vector unsigned long long __b) {

 */
 #ifdef __CRYPTO__
 #define vec_sbox_be __builtin_altivec_crypto_vsbox
 #define vec_cipher_be __builtin_altivec_crypto_vcipher
 #define vec_cipherlast_be __builtin_altivec_crypto_vcipherlast
 #define vec_ncipher_be __builtin_altivec_crypto_vncipher
 #define vec_ncipherlast_be __builtin_altivec_crypto_vncipherlast
 
+#ifdef __VSX__
 static __inline__ vector unsigned long long __attribute__((__always_inline__))
 __builtin_crypto_vsbox(vector unsigned long long __a) {
   return __builtin_altivec_crypto_vsbox(__a);
 }
 
 static __inline__ vector unsigned long long __attribute__((__always_inline__))
 __builtin_crypto_vcipher(vector unsigned long long __a,
                          vector unsigned long long __b) {
__builtin_crypto_vncipher(vector unsigned long long __a,
   return __builtin_altivec_crypto_vncipher(__a, __b);
 }
 
 static __inline__ vector unsigned long long __attribute__((__always_inline__))
 __builtin_crypto_vncipherlast(vector unsigned long long __a,
                               vector unsigned long long __b) {
   return __builtin_altivec_crypto_vncipherlast(__a, __b);
 }
+#endif
 
 #define __builtin_crypto_vshasigmad __builtin_altivec_crypto_vshasigmad
 #define __builtin_crypto_vshasigmaw __builtin_altivec_crypto_vshasigmaw
 
 #define vec_shasigma_be(X, Y, Z)                                               \
   _Generic((X), vector unsigned int                                            \
            : __builtin_crypto_vshasigmaw, vector unsigned long long            \
            : __builtin_crypto_vshasigmad)((X), (Y), (Z))

clang/lib/Sema/DeclSpec.cpp

if (TypeSpecType == TST_decltype_auto &&
     TypeQualifiers = 0;
     S.Diag(TSTLoc, diag::err_decltype_auto_cannot_be_combined)
       << Hints[0] << Hints[1] << Hints[2] << Hints[3]
       << Hints[4] << Hints[5] << Hints[6] << Hints[7];
   }
 
   // Validate and finalize AltiVec vector declspec.
   if (TypeAltiVecVector) {
+    // No vector long long without VSX (or ZVector).
+    if ((getTypeSpecWidth() == TypeSpecifierWidth::LongLong) &&
+        !S.Context.getTargetInfo().hasFeature("vsx") &&
+        !S.getLangOpts().ZVector)
+      S.Diag(TSTLoc, diag::err_invalid_vector_long_long_decl_spec);
+
+    // No vector __int128 prior to Power8.
+    if ((TypeSpecType == TST_int128) &&
+        (!S.Context.getTargetInfo().hasFeature("power8-vector")))
+      S.Diag(TSTLoc, diag::err_invalid_vector_int128_decl_spec);
+
     if (TypeAltiVecBool) {
       // Sign specifiers are not allowed with vector bool. (PIM 2.1)
       if (getTypeSpecSign() != TypeSpecifierSign::Unspecified) {
         S.Diag(TSSLoc, diag::err_invalid_vector_bool_decl_spec)
             << getSpecifierName(getTypeSpecSign());
       }
       // Only char/int are valid with vector bool prior to Power10.
       // Power10 adds instructions that produce vector bool data
if (TypeAltiVecBool) {
 
       // Only 'short' and 'long long' are valid with vector bool. (PIM 2.1)
       if ((getTypeSpecWidth() != TypeSpecifierWidth::Unspecified) &&
           (getTypeSpecWidth() != TypeSpecifierWidth::Short) &&
           (getTypeSpecWidth() != TypeSpecifierWidth::LongLong))
         S.Diag(TSWRange.getBegin(), diag::err_invalid_vector_bool_decl_spec)
             << getSpecifierName(getTypeSpecWidth());
 
-      // vector bool long long requires VSX support or ZVector.
-      if ((getTypeSpecWidth() == TypeSpecifierWidth::LongLong) &&
-          (!S.Context.getTargetInfo().hasFeature("vsx")) &&
-          (!S.Context.getTargetInfo().hasFeature("power8-vector")) &&
-          !S.getLangOpts().ZVector)
-        S.Diag(TSTLoc, diag::err_invalid_vector_long_long_decl_spec);
-
       // Elements of vector bool are interpreted as unsigned. (PIM 2.1)
       if ((TypeSpecType == TST_char) || (TypeSpecType == TST_int) ||
           (TypeSpecType == TST_int128) ||
           (getTypeSpecWidth() != TypeSpecifierWidth::Unspecified))
         TypeSpecSign = static_cast<unsigned>(TypeSpecifierSign::Unsigned);
     } else if (TypeSpecType == TST_double) {
       // vector long double and vector long long double are never allowed.
       // vector double is OK for Power7 and later, and ZVector.

clang/test/CodeGen/builtins-ppc-int128.c

+// REQUIRES: powerpc-registered-target
+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -triple powerpc64-unknown-unknown -target-cpu pwr8 \
+// RUN:  -emit-llvm %s -o - -U__XL_COMPAT_ALTIVEC__ | FileCheck %s
+// RUN: %clang_cc1 -target-feature +altivec -target-feature +vsx \
+// RUN:   -triple powerpc64le-unknown-unknown -target-cpu pwr8 \
+// RUN:   -emit-llvm %s -o - -U__XL_COMPAT_ALTIVEC__ | FileCheck %s -check-prefix=CHECK-LE
+#include <altivec.h>
+
+vector signed __int128 res_vslll;
+unsigned long long aull[2] = { 1L, 2L };
+
+void testVectorInt128Pack(){
+// CHECK-LABEL: testVectorInt128Pack
+// CHECK-LABEL-LE: testVectorInt128Pack
+  res_vslll = __builtin_pack_vector_int128(aull[0], aull[1]);
+// CHECK: %[[V1:[0-9]+]] = insertelement <2 x i64> undef, i64 %{{[0-9]+}}, i64 0
+// CHECK-NEXT: %[[V2:[0-9]+]] = insertelement <2 x i64> %[[V1]], i64 %{{[0-9]+}}, i64 1
+// CHECK-NEXT:  bitcast <2 x i64> %[[V2]] to <1 x i128>
+
+// CHECK-LE: %[[V1:[0-9]+]] = insertelement <2 x i64> undef, i64 %{{[0-9]+}}, i64 1
+// CHECK-NEXT-LE: %[[V2:[0-9]+]] = insertelement <2 x i64> %[[V1]], i64 %{{[0-9]+}}, i64 0
+// CHECK-NEXT-LE:  bitcast <2 x i64> %[[V2]] to <1 x i128>
+
+  __builtin_unpack_vector_int128(res_vslll, 0);
+// CHECK:  %[[V1:[0-9]+]] = bitcast <1 x i128> %{{[0-9]+}} to <2 x i64>
+// CHECK-NEXT: %{{[0-9]+}} = extractelement <2 x i64> %[[V1]], i32 0
+
+// CHECK-LE:  %[[V1:[0-9]+]] = bitcast <1 x i128> %{{[0-9]+}} to <2 x i64>
+// CHECK-NEXT-LE: %{{[0-9]+}} = extractelement <2 x i64> %[[V1]], i32 1
+
+  __builtin_unpack_vector_int128(res_vslll, 1);
+// CHECK:  %[[V1:[0-9]+]] = bitcast <1 x i128> %{{[0-9]+}} to <2 x i64>
+// CHECK-NEXT: %{{[0-9]+}} = extractelement <2 x i64> %[[V1]], i32 1
+
+// CHECK-LE:  %[[V1:[0-9]+]] = bitcast <1 x i128> %{{[0-9]+}} to <2 x i64>
+// CHECK-NEXT-LE: %{{[0-9]+}} = extractelement <2 x i64> %[[V1]], i32 0
+}
+

clang/test/CodeGen/builtins-ppc-vsx.c

 vector signed short res_vss;
 vector unsigned short res_vus;
 vector bool int res_vbi;
 vector signed int res_vsi;
 vector unsigned int res_vui;
 vector bool long long res_vbll;
 vector signed long long res_vsll;
 vector unsigned long long res_vull;
-vector signed __int128 res_vslll;
 
 double res_d;
 int res_i;
 float res_af[4];
 double res_ad[2];
 signed char res_asc[16];
 unsigned char res_auc[16];
 signed short res_ass[8];

 // CHECK-NEXT:  bitcast <4 x i32> %{{[0-9]+}} to <2 x double>
 
 // CHECK-LE:  bitcast <2 x double> %{{[0-9]+}} to <4 x i32>
 // CHECK-NEXT-LE:  bitcast <2 x double> %{{[0-9]+}} to <4 x i32>
 // CHECK-NEXT-LE:  shufflevector <4 x i32> %{{[0-9]+}}, <4 x i32> %{{[0-9]+}}, <4 x i32> <i32 0, i32 1, i32 2, i32 3>
 // CHECK-NEXT-LE:  bitcast <4 x i32> %{{[0-9]+}} to <2 x double>
 }
 
-void testVectorInt128Pack(){
-// CHECK-LABEL: testVectorInt128Pack
-// CHECK-LABEL-LE: testVectorInt128Pack
-  res_vslll = __builtin_pack_vector_int128(aull[0], aull[1]);
-// CHECK: %[[V1:[0-9]+]] = insertelement <2 x i64> undef, i64 %{{[0-9]+}}, i64 0
-// CHECK-NEXT: %[[V2:[0-9]+]] = insertelement <2 x i64> %[[V1]], i64 %{{[0-9]+}}, i64 1
-// CHECK-NEXT:  bitcast <2 x i64> %[[V2]] to <1 x i128>
-
-// CHECK-LE: %[[V1:[0-9]+]] = insertelement <2 x i64> undef, i64 %{{[0-9]+}}, i64 1
-// CHECK-NEXT-LE: %[[V2:[0-9]+]] = insertelement <2 x i64> %[[V1]], i64 %{{[0-9]+}}, i64 0
-// CHECK-NEXT-LE:  bitcast <2 x i64> %[[V2]] to <1 x i128>
-
-  __builtin_unpack_vector_int128(res_vslll, 0);
-// CHECK:  %[[V1:[0-9]+]] = bitcast <1 x i128> %{{[0-9]+}} to <2 x i64>
-// CHECK-NEXT: %{{[0-9]+}} = extractelement <2 x i64> %[[V1]], i32 0
-
-// CHECK-LE:  %[[V1:[0-9]+]] = bitcast <1 x i128> %{{[0-9]+}} to <2 x i64>
-// CHECK-NEXT-LE: %{{[0-9]+}} = extractelement <2 x i64> %[[V1]], i32 1
-
-  __builtin_unpack_vector_int128(res_vslll, 1);
-// CHECK:  %[[V1:[0-9]+]] = bitcast <1 x i128> %{{[0-9]+}} to <2 x i64>
-// CHECK-NEXT: %{{[0-9]+}} = extractelement <2 x i64> %[[V1]], i32 1
-
-// CHECK-LE:  %[[V1:[0-9]+]] = bitcast <1 x i128> %{{[0-9]+}} to <2 x i64>
-// CHECK-NEXT-LE: %{{[0-9]+}} = extractelement <2 x i64> %[[V1]], i32 0
-
-}
-
 void test_vector_cpsgn_float(vector float a, vector float b) {
 // CHECK-LABEL: test_vector_cpsgn_float
 // CHECK-DAG: load{{.*}}%__a
 // CHECK-DAG: load{{.*}}%__b
 // CHECK-NOT: SEPARATOR
 // CHECK-DAG: [[RA:%[0-9]+]] = load <4 x float>, <4 x float>* %__a.addr
 // CHECK-DAG: [[RB:%[0-9]+]] = load <4 x float>, <4 x float>* %__b.addr
 // CHECK-NEXT: call <4 x float> @llvm.copysign.v4f32(<4 x float> [[RB]], <4 x float> [[RA]])

clang/test/Parser/altivec-bool-128.c

-// RUN: %clang_cc1 -triple=powerpc64-unknown-linux-gnu \
+// RUN: %clang_cc1 -triple=powerpc64-unknown-linux-gnu -target-cpu pwr8\
 // RUN:            -target-feature +altivec -fsyntax-only -verify %s
-// RUN: %clang_cc1 -triple=powerpc64le-unknown-linux-gnu \
+// RUN: %clang_cc1 -triple=powerpc64le-unknown-linux-gnu -target-cpu pwr8\
 // RUN:            -target-feature +altivec -fsyntax-only -verify %s
 // RUN: %clang_cc1 -triple=powerpc64le-unknown-linux-gnu -target-cpu pwr10 \
 // RUN:            -target-feature +vsx -target-feature -power10-vector \
 // RUN:            -fsyntax-only -verify %s
 
 // Test 'vector bool __int128' type.
 
 // These should have errors.

clang/test/Parser/altivec.c

 // RUN: %clang_cc1 -triple=powerpc-apple-darwin8 -target-feature +altivec -fsyntax-only -verify=expected,nonaix %s
 // RUN: %clang_cc1 -triple=powerpc64-unknown-linux-gnu -target-feature +altivec -fsyntax-only -verify=expected,nonaix %s
-// RUN: %clang_cc1 -triple=powerpc64le-unknown-linux-gnu -target-feature +altivec -fsyntax-only -verify=expected,nonaix %s
+// RUN: %clang_cc1 -triple=powerpc64le-unknown-linux-gnu -target-feature +altivec -target-feature +vsx -fsyntax-only -verify=expected,nonaix %s
 // RUN: %clang_cc1 -triple=powerpc-ibm-aix -target-feature +altivec -fsyntax-only -verify=expected,aix %s
-// RUN: %clang_cc1 -triple=powerpc64-ibm-aix -target-feature +altivec -fsyntax-only -verify=expected,aix %s
+// RUN: %clang_cc1 -triple=powerpc64-ibm-aix -target-feature +altivec -target-feature +vsx -fsyntax-only -verify=expected,aix %s
 
 __vector char vv_c;
 __vector signed char vv_sc;
 __vector unsigned char vv_uc;
 __vector short vv_s;
 __vector signed  short vv_ss;
 __vector unsigned  short vv_us;
 __vector short int vv_si;

 
 // These should have warnings.
 __vector long double  vv_ld;        // expected-error {{cannot use 'long double' with '__vector'}}
 vector long double  v_ld;           // expected-error {{cannot use 'long double' with '__vector'}}
 vector bool v_b;                    // expected-warning {{type specifier missing, defaults to 'int'}}
 vector __bool v___b;                // expected-warning {{type specifier missing, defaults to 'int'}}
 
 // These should have errors.
+#ifndef __VSX__
 __vector double vv_d1;               // expected-error {{use of 'double' with '__vector' requires VSX support to be enabled (available on POWER7 or later)}}
 vector double v_d2;                  // expected-error {{use of 'double' with '__vector' requires VSX support to be enabled (available on POWER7 or later)}}
-__vector bool long long v_bll1;      // expected-error {{use of 'long long' with '__vector bool' requires VSX support (available on POWER7 or later) or extended Altivec support (available on POWER8 or later) to be enabled}}
-__vector __bool long long v_bll2;    // expected-error {{use of 'long long' with '__vector bool' requires VSX support (available on POWER7 or later) or extended Altivec support (available on POWER8 or later) to be enabled}}
-vector bool long long v_bll3;        // expected-error {{use of 'long long' with '__vector bool' requires VSX support (available on POWER7 or later) or extended Altivec support (available on POWER8 or later) to be enabled}}
-vector __bool long long v_bll4;      // expected-error {{use of 'long long' with '__vector bool' requires VSX support (available on POWER7 or later) or extended Altivec support (available on POWER8 or later) to be enabled}}
+__vector bool long long v_bll1;      // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
+__vector __bool long long v_bll2;    // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
+vector bool long long v_bll3;        // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
+vector __bool long long v_bll4;      // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
+#endif
 __vector long double  vv_ld3;        // expected-error {{cannot use 'long double' with '__vector'}}
 vector long double  v_ld4;           // expected-error {{cannot use 'long double' with '__vector'}}
 vector bool float v_bf;              // expected-error {{cannot use 'float' with '__vector bool'}}
 vector bool double v_bd;             // expected-error {{cannot use 'double' with '__vector bool'}}
 vector bool pixel v_bp;              // expected-error {{cannot use '__pixel' with '__vector bool'}}
 vector bool signed char v_bsc;       // expected-error {{cannot use 'signed' with '__vector bool'}}
 vector bool unsigned int v_bsc2;     // expected-error {{cannot use 'unsigned' with '__vector bool'}}
 vector bool long v_bl;               // expected-error {{cannot use 'long' with '__vector bool'}}
 vector __bool float v___bf;          // expected-error {{cannot use 'float' with '__vector bool'}}
 vector __bool double v___bd;         // expected-error {{cannot use 'double' with '__vector bool'}}
 vector __bool pixel v___bp;          // expected-error {{cannot use '__pixel' with '__vector bool'}}
 vector __bool signed char v___bsc;   // expected-error {{cannot use 'signed' with '__vector bool'}}
 vector __bool unsigned int v___bsc2; // expected-error {{cannot use 'unsigned' with '__vector bool'}}
 vector __bool long v___bl;           // expected-error {{cannot use 'long' with '__vector bool'}}
 
+#ifdef __VSX__
 // vector long is deprecated, but vector long long is not.
 vector long long v_ll;
 vector signed long long v_sll;
 vector unsigned long long v_ull;
+#endif
 
 typedef char i8;
 typedef short i16;
 typedef int i32;
 struct S {
   // i8, i16, i32 here are field names, not type names.
   vector bool i8;                    // expected-error {{requires a specifier or qualifier}}
   vector pixel i16;

clang/test/Parser/cxx-altivec-bool-128.cpp

 // RUN: %clang_cc1 -triple=powerpc64-unknown-linux-gnu \
 // RUN:            -target-feature +altivec -fsyntax-only -verify -std=c++11 %s
 // RUN: %clang_cc1 -triple=powerpc64le-unknown-linux-gnu \
 // RUN:            -target-feature +altivec -fsyntax-only -verify -std=c++11 %s
 // RUN: %clang_cc1 -triple=powerpc64le-unknown-linux-gnu -target-cpu pwr10 \
-// RUN:            -target-feature +altivec -target-feature +vsx \
+// RUN:            -target-feature +altivec -target-feature -vsx \
 // RUN:            -target-feature -power10-vector -fsyntax-only -verify %s
 
 #include <altivec.h>
 
 // Test 'vector bool __int128' type.
 
 // These should have errors.
-__vector bool __int128 v1_bi128;          // expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
-__vector __bool __int128 v2_bi128;        // expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
-vector bool __int128 v3_bi128;            // expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
-vector __bool __int128 v4_bi128;          // expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
-__vector bool unsigned __int128 v5_bi128; // expected-error {{cannot use 'unsigned' with '__vector bool'}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
-__vector bool signed __int128 v6_bi128;   // expected-error {{cannot use 'signed' with '__vector bool'}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
-vector bool unsigned __int128 v7_bi128;   // expected-error {{cannot use 'unsigned' with '__vector bool'}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
-vector bool signed __int128 v8_bi128;     // expected-error {{cannot use 'signed' with '__vector bool'}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
-__vector __bool signed __int128 v9_bi128; // expected-error {{cannot use 'signed' with '__vector bool'}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
-vector __bool signed __int128 v10_bi128;  // expected-error {{cannot use 'signed' with '__vector bool'}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
+__vector bool __int128 v1_bi128;          // expected-error {{use of '__int128' with '__vector' requires extended Altivec support (available on POWER8 or later)}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
+__vector __bool __int128 v2_bi128;        // expected-error {{use of '__int128' with '__vector' requires extended Altivec support (available on POWER8 or later)}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
+vector bool __int128 v3_bi128;            // expected-error {{use of '__int128' with '__vector' requires extended Altivec support (available on POWER8 or later)}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
+vector __bool __int128 v4_bi128;          // expected-error {{use of '__int128' with '__vector' requires extended Altivec support (available on POWER8 or later)}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
+__vector bool unsigned __int128 v5_bi128; // expected-error {{cannot use 'unsigned' with '__vector bool'}} expected-error {{use of '__int128' with '__vector' requires extended Altivec support (available on POWER8 or later)}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
+__vector bool signed __int128 v6_bi128;   // expected-error {{cannot use 'signed' with '__vector bool'}} expected-error {{use of '__int128' with '__vector' requires extended Altivec support (available on POWER8 or later)}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
+vector bool unsigned __int128 v7_bi128;   // expected-error {{cannot use 'unsigned' with '__vector bool'}} expected-error {{use of '__int128' with '__vector' requires extended Altivec support (available on POWER8 or later)}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
+vector bool signed __int128 v8_bi128;     // expected-error {{cannot use 'signed' with '__vector bool'}} expected-error {{use of '__int128' with '__vector' requires extended Altivec support (available on POWER8 or later)}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
+__vector __bool signed __int128 v9_bi128; // expected-error {{cannot use 'signed' with '__vector bool'}} expected-error {{use of '__int128' with '__vector' requires extended Altivec support (available on POWER8 or later)}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}
+vector __bool signed __int128 v10_bi128;  // expected-error {{cannot use 'signed' with '__vector bool'}} expected-error {{use of '__int128' with '__vector' requires extended Altivec support (available on POWER8 or later)}} expected-error {{use of '__int128' with '__vector bool' requires VSX support enabled (on POWER10 or later)}}

clang/test/Parser/cxx-altivec.cpp

 // RUN: %clang_cc1 -triple=powerpc-apple-darwin8 -target-feature +altivec -fsyntax-only -verify=expected,nonaix -std=c++11 %s
 // RUN: %clang_cc1 -triple=powerpc64-unknown-linux-gnu -target-feature +altivec -fsyntax-only -verify=expected,nonaix -std=c++11 %s
 // RUN: %clang_cc1 -triple=powerpc64le-unknown-linux-gnu -target-feature +altivec -fsyntax-only -verify=expected,nonaix -std=c++11 %s
+// RUN: %clang_cc1 -triple=powerpc64le-unknown-linux-gnu -target-feature +vsx -target-cpu pwr7 -fsyntax-only -verify=expected,nonaix -std=c++11 %s
 // RUN: %clang_cc1 -triple=powerpc-ibm-aix -target-feature +altivec -fsyntax-only -verify=expected,aix -std=c++11 %s
 // RUN: %clang_cc1 -triple=powerpc64-ibm-aix -target-feature +altivec -fsyntax-only -verify=expected,aix -std=c++11 %s
 #include <altivec.h>
 
 __vector char vv_c;
 __vector signed char vv_sc;
 __vector unsigned char vv_uc;
 __vector short vv_s;
vector signed long int v_sli;       // nonaix-warning {{Use of 'long' with '__vector' is deprecated}}
                                     // aix-error@-1 {{cannot use 'long' with '__vector'}}
 vector unsigned long int v_uli;     // nonaix-warning {{Use of 'long' with '__vector' is deprecated}}
                                     // aix-error@-1 {{cannot use 'long' with '__vector'}}
 
 // These should have warnings.
 __vector long double  vv_ld;        // expected-error {{cannot use 'long double' with '__vector'}}
 vector long double  v_ld;           // expected-error {{cannot use 'long double' with '__vector'}}
 
-// These should have errors.
+#ifndef __VSX__
+// These should have errors for non pwr7 vsx builds.
 __vector double vv_d1;               // expected-error {{use of 'double' with '__vector' requires VSX support to be enabled (available on POWER7 or later)}}
 vector double v_d2;                  // expected-error {{use of 'double' with '__vector' requires VSX support to be enabled (available on POWER7 or later)}}
-__vector bool long long v_bll1;      // expected-error {{use of 'long long' with '__vector bool' requires VSX support (available on POWER7 or later) or extended Altivec support (available on POWER8 or later) to be enabled}}
-__vector __bool long long v_bll2;    // expected-error {{use of 'long long' with '__vector bool' requires VSX support (available on POWER7 or later) or extended Altivec support (available on POWER8 or later) to be enabled}}
-vector bool long long v_bll3;        // expected-error {{use of 'long long' with '__vector bool' requires VSX support (available on POWER7 or later) or extended Altivec support (available on POWER8 or later) to be enabled}}
-vector __bool long long v_bll4;      // expected-error {{use of 'long long' with '__vector bool' requires VSX support (available on POWER7 or later) or extended Altivec support (available on POWER8 or later) to be enabled}}
+__vector bool long long v_bll1;      // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
+__vector __bool long long v_bll2;    // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
+vector bool long long v_bll3;        // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
+vector __bool long long v_bll4;      // expected-error {{use of 'long long' with '__vector' requires VSX support (available on POWER7 or later) to be enabled}}
+#endif
 __vector long double  vv_ld3;        // expected-error {{cannot use 'long double' with '__vector'}}
 vector long double  v_ld4;           // expected-error {{cannot use 'long double' with '__vector'}}
 vector bool v_b;                     // expected-error {{C++ requires a type specifier for all declarations}}
 vector bool float v_bf;              // expected-error {{cannot use 'float' with '__vector bool'}}
 vector bool double v_bd;             // expected-error {{cannot use 'double' with '__vector bool'}}
 vector bool pixel v_bp;              // expected-error {{cannot use '__pixel' with '__vector bool'}}
 vector bool signed char v_bsc;       // expected-error {{cannot use 'signed' with '__vector bool'}}
 vector bool unsigned int v_bsc2;     // expected-error {{cannot use 'unsigned' with '__vector bool'}}
 vector bool long v_bl;               // expected-error {{cannot use 'long' with '__vector bool'}}
 vector __bool float v___bf;          // expected-error {{cannot use 'float' with '__vector bool'}}
 vector __bool double v___bd;         // expected-error {{cannot use 'double' with '__vector bool'}}
 vector __bool pixel v___bp;          // expected-error {{cannot use '__pixel' with '__vector bool'}}
 vector __bool signed char v___bsc;   // expected-error {{cannot use 'signed' with '__vector bool'}}
 vector __bool unsigned int v___bsc2; // expected-error {{cannot use 'unsigned' with '__vector bool'}}
 vector __bool long v___bl;           // expected-error {{cannot use 'long' with '__vector bool'}}
 
+#ifdef __VSX__
 // vector long is deprecated, but vector long long is not.
 vector long long v_ll;
 vector signed long long v_sll;
 vector unsigned long long v_ull;
+#endif
 
 void f() {
   __vector unsigned int v = {0,0,0,0};
   __vector int v__cast = (__vector int)v;
   __vector int v_cast = (vector int)v;
   __vector char vb_cast = (vector char)v;
 
   // Check some casting between gcc and altivec vectors.

clang/test/Sema/altivec-generic-overload.c

-// RUN: %clang_cc1 %s -triple=powerpc64le-unknown-linux -target-feature +altivec -target-feature +vsx -verify -verify-ignore-unexpected=note -pedantic -fsyntax-only
+// RUN: %clang_cc1 %s -triple=powerpc64le-unknown-linux -target-feature +altivec \
+// RUN:  -target-feature +vsx -verify -verify-ignore-unexpected=note -pedantic -fsyntax-only
+// RUN: %clang_cc1 %s -triple=powerpc64le-unknown-linux -target-feature +altivec \
+// RUN:  -target-feature +vsx -verify -verify-ignore-unexpected=note -pedantic -fsyntax-only \
+// RUN:  -target-cpu pwr8
 
 typedef signed char __v16sc __attribute__((__vector_size__(16)));
 typedef unsigned char __v16uc __attribute__((__vector_size__(16)));
 typedef signed short __v8ss __attribute__((__vector_size__(16)));
 typedef unsigned short __v8us __attribute__((__vector_size__(16)));
 typedef signed int __v4si __attribute__((__vector_size__(16)));
 typedef unsigned int __v4ui __attribute__((__vector_size__(16)));
 typedef signed long long __v2sll __attribute__((__vector_size__(16)));
 typedef unsigned long long __v2ull __attribute__((__vector_size__(16)));
 typedef signed __int128 __v1slll __attribute__((__vector_size__(16)));
 typedef unsigned __int128 __v1ulll __attribute__((__vector_size__(16)));
 typedef float __v4f __attribute__((__vector_size__(16)));
 typedef double __v2d __attribute__((__vector_size__(16)));
 
 __v16sc *__attribute__((__overloadable__)) convert1(vector signed char);
 __v16uc *__attribute__((__overloadable__)) convert1(vector unsigned char);
 __v8ss *__attribute__((__overloadable__)) convert1(vector signed short);
 __v8us *__attribute__((__overloadable__)) convert1(vector unsigned short);
 __v4si *__attribute__((__overloadable__)) convert1(vector signed int);
 __v4ui *__attribute__((__overloadable__)) convert1(vector unsigned int);
 __v2sll *__attribute__((__overloadable__)) convert1(vector signed long long);
-__v2ull *__attribute__((__overloadable__)) convert1(vector unsigned long long);
-__v1slll *__attribute__((__overloadable__)) convert1(vector signed __int128);
-__v1ulll *__attribute__((__overloadable__)) convert1(vector unsigned __int128);
 __v4f *__attribute__((__overloadable__)) convert1(vector float);
 __v2d *__attribute__((__overloadable__)) convert1(vector double);
 void __attribute__((__overloadable__)) convert1(vector bool int);
 void __attribute__((__overloadable__)) convert1(vector pixel short);
 
 vector signed char *__attribute__((__overloadable__)) convert2(__v16sc);
 vector unsigned char *__attribute__((__overloadable__)) convert2(__v16uc);
 vector signed short *__attribute__((__overloadable__)) convert2(__v8ss);
 vector unsigned short *__attribute__((__overloadable__)) convert2(__v8us);
 vector signed int *__attribute__((__overloadable__)) convert2(__v4si);
 vector unsigned int *__attribute__((__overloadable__)) convert2(__v4ui);
 vector signed long long *__attribute__((__overloadable__)) convert2(__v2sll);
 vector unsigned long long *__attribute__((__overloadable__)) convert2(__v2ull);
-vector signed __int128 *__attribute__((__overloadable__)) convert2(__v1slll);
-vector unsigned __int128 *__attribute__((__overloadable__)) convert2(__v1ulll);
 vector float *__attribute__((__overloadable__)) convert2(__v4f);
 vector double *__attribute__((__overloadable__)) convert2(__v2d);
 
+#ifdef __POWER8_VECTOR__
+__v1slll *__attribute__((__overloadable__)) convert1(vector signed __int128);
+__v1ulll *__attribute__((__overloadable__)) convert1(vector unsigned __int128);
+__v2ull *__attribute__((__overloadable__)) convert1(vector unsigned long long);
+vector signed __int128 *__attribute__((__overloadable__)) convert2(__v1slll);
+vector unsigned __int128 *__attribute__((__overloadable__)) convert2(__v1ulll);
+#endif
+
 void test() {
   __v16sc gv1;
   __v16uc gv2;
   __v8ss gv3;
   __v8us gv4;
   __v4si gv5;
   __v4ui gv6;
   __v2sll gv7;
+  __v4f gv11;
+  __v2d gv12;
+
+#ifdef __POWER8_VECTOR__
   __v2ull gv8;
   __v1slll gv9;
   __v1ulll gv10;
-  __v4f gv11;
-  __v2d gv12;
+#endif
 
   vector signed char av1;
   vector unsigned char av2;
   vector signed short av3;
   vector unsigned short av4;
   vector signed int av5;
   vector unsigned int av6;
   vector signed long long av7;
   vector unsigned long long av8;
+#ifdef __POWER8_VECTOR__
   vector signed __int128 av9;
   vector unsigned __int128 av10;
+#endif
   vector float av11;
   vector double av12;
   vector bool int av13;
   vector pixel short av14;
 
   __v16sc *gv1_p = convert1(gv1);
   __v16uc *gv2_p = convert1(gv2);
   __v8ss *gv3_p = convert1(gv3);
   __v8us *gv4_p = convert1(gv4);
   __v4si *gv5_p = convert1(gv5);
   __v4ui *gv6_p = convert1(gv6);
   __v2sll *gv7_p = convert1(gv7);
+#ifdef __POWER8_VECTOR__
   __v2ull *gv8_p = convert1(gv8);
   __v1slll *gv9_p = convert1(gv9);
   __v1ulll *gv10_p = convert1(gv10);
+#endif
   __v4f *gv11_p = convert1(gv11);
   __v2d *gv12_p = convert1(gv12);
 
   vector signed char *av1_p = convert2(av1);
   vector unsigned char *av2_p = convert2(av2);
   vector signed short *av3_p = convert2(av3);
   vector unsigned short *av4_p = convert2(av4);
   vector signed int *av5_p = convert2(av5);
   vector unsigned int *av6_p = convert2(av6);
   vector signed long long *av7_p = convert2(av7);
   vector unsigned long long *av8_p = convert2(av8);
+#ifdef __POWER8_VECTOR__
   vector signed __int128 *av9_p = convert2(av9);
   vector unsigned __int128 *av10_p = convert2(av10);
+#endif
   vector float *av11_p = convert2(av11);
   vector double *av12_p = convert2(av12);
   convert2(av13); // expected-error {{call to 'convert2' is ambiguous}}
   convert2(av14); // expected-error {{call to 'convert2' is ambiguous}}
 }

clang/test/Sema/builtins-ppc.c

 // REQUIRES: powerpc-registered-target
 // RUN: %clang_cc1 -target-feature +altivec -target-feature +htm                       \
 // RUN: -triple powerpc64-unknown-unknown -DTEST_HTM -fsyntax-only      \
 // RUN: -verify %s
 
 // RUN: %clang_cc1 -target-feature +altivec -target-feature +crypto                    \
 // RUN: -triple powerpc64le-unknown-unknown -DTEST_CRYPTO -fsyntax-only      \
 // RUN: -verify %s
+// RUN: %clang_cc1 -target-feature +altivec -target-feature +crypto \
+// RUN: -triple powerpc64le-unknown-unknown -DTEST_CRYPTO -fsyntax-only \
+// RUN: -target-feature +vsx -verify %s
 
 #ifdef TEST_HTM
 void test_htm() {
   __builtin_tbegin(4); // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_tend(-1);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_tsr(55);   // expected-error-re {{argument value {{.*}} is outside the valid range}}
   __builtin_tabortwc(-5, 2, 3); // expected-error-re {{argument value {{.*}} is outside the valid range}} 
   __builtin_tabortdc(55, 2, 3); // expected-error-re {{argument value {{.*}} is outside the valid range}}
vector unsigned int test_vshasigmaw_or(void)
   vector unsigned int a = W_INIT
   vector unsigned int b = __builtin_crypto_vshasigmaw(a, 2, 15);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
   vector unsigned int c = __builtin_crypto_vshasigmaw(a, -1, 15); // expected-error-re {{argument value {{.*}} is outside the valid range}}
   vector unsigned int d = __builtin_crypto_vshasigmaw(a, 0, 85);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
   vector unsigned int e = __builtin_crypto_vshasigmaw(a, 1, -15); // expected-error-re {{argument value {{.*}} is outside the valid range}}
   return __builtin_crypto_vshasigmaw(a, 1, 15);
 }
 
+#ifdef __VSX__
 vector unsigned long long test_vshasigmad_or(void)
 {
   vector unsigned long long a = D_INIT
   vector unsigned long long b = __builtin_crypto_vshasigmad(a, 2, 15);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
   vector unsigned long long c = __builtin_crypto_vshasigmad(a, -1, 15); // expected-error-re {{argument value {{.*}} is outside the valid range}}
   vector unsigned long long d = __builtin_crypto_vshasigmad(a, 0, 85);  // expected-error-re {{argument value {{.*}} is outside the valid range}}
   vector unsigned long long e = __builtin_crypto_vshasigmad(a, 1, -15); // expected-error-re {{argument value {{.*}} is outside the valid range}}
   return __builtin_crypto_vshasigmad(a, 0, 15);
 }
+#endif
 
 #endif