[PPC] some bugs mainly about sign problem fixed in altivec.h

[Zeson]

Summary

It's mainly about signed and unsigned llvm builtins confusion.

1. When function args are bool vector and signed vector, it should be mapped to signed version instruction. Reference: ALTIVECPIM.pdf
2. Some logical right shift vector functions should use unsigned >> operator, which would be translated to lshr IR instruction.
3. Move some test functions needed VSX option support from builtins-ppc-altivec.c to builtins-ppc-vsx.c

[nemanjai]

Thank you for fixing these issues. I certainly see how the shifts really need to get the signedness right because the right shifts need to fill with the sign bit (so that vector bool will still have all 0 or all 1 bits). However, I don't really follow why the comparisons need to be signed. Could you just elaborate a bit on that?
Other than satisfying my curiosity on that, this LGTM.

[Zeson]

In D27251#609014, @nemanjai wrote:

Thank you for fixing these issues. I certainly see how the shifts really need to get the signedness right because the right shifts need to fill with the sign bit (so that vector bool will still have all 0 or all 1 bits). However, I don't really follow why the comparisons need to be signed. Could you just elaborate a bit on that?
Other than satisfying my curiosity on that, this LGTM.

In my opinion, from the table in the PDF above, it seems that vector bool would be treated as unsigned or signed depending on the other argument type and it would be mapped to related machine instruction. As machine instruction, it is just treated as signed or unsigned operand.

[jtony]

lib/Headers/altivec.h

16420–16421

Thanks a lot for your good catch for the macro issue in vec_xst_be, that's a good catch. BTW, Can you move this up also like vec_xst_be?

test/CodeGen/builtins-ppc-vsx.c

1672

I would prefer these definitions occur at the beginning of the file like before.

1682

These test cases should be grouped together with the test cases from 1663 - 1683. Put the vec_xl_be overloads together, and the vec_xst_be together (maybe after vec_xl_be). I am OK with either put these test2 and test3 into test 1, or make them stand-alone, as long as these overloaded test cases for vec_xst_be and vec_xl_be are put together seperately. Thanks for you good catch, this problem is not found in our previous code review.

[Zeson]

Make vec_xst_be and vec_xl_be test cases put together seperately in builtins-ppc-vsx.c
Move up macro __VSX__ to make all vec_xst_be functions included

[kbarton]

Please make explicit the signed for the parameters to the functions you are changing and remove unnecessary casts. I marked the first few that I found, but stopped marking them after the first several.

lib/Headers/altivec.h

13928

The cast for __b is necessary, since it is already a vector signed char.
I don't know whether this will generate superfluous warnings or not, but it's probably best to remove it.

13964–13965

It's better to make the parameter explicitly vector signed short, and remove the cast on the next line, for consistency with other builtins.

14000–14001

same comment - explicitly vector signed int

14039

No cast needed here

14095

No cast needed here

14131–14132

Make signed explicit here

[Zeson]

Remove some unnecessary cast

[Zeson]

In D27251#610629, @kbarton wrote:

Please make explicit the signed for the parameters to the functions you are changing and remove unnecessary casts. I marked the first few that I found, but stopped marking them after the first several.

I think it does not need to make explicit signed for the parameters such as making vector int to vector signed int, making vector short to vector signed short.
The whole file containing lots of such issues can be modified or fixed in another single patch to avoid introducing noise in this patch.

[Zeson]

Hi, All.

The revision has been updated, please review it again.
Thanks a lot.

[kbarton]

Sorry, I don't have time to go through the entire patch in detail right now. But I did notice several places where the lines are too long, which need to get fixed.

lib/Headers/altivec.h

14206

line too long

14381

line too long

14549

line too long

[nemanjai]

@Zeson are you working on an update to this or is this to be abandoned?

[Zeson]

I think this revision is out-of-date. I'd like to abandon it.

lib/Headers/altivec.h

 #endif
 
 /* vec_vsrb */
 
 #define __builtin_altivec_vsrb vec_vsrb
 
 static __inline__ vector signed char __ATTRS_o_ai
 vec_vsrb(vector signed char __a, vector unsigned char __b) {
-  return __a >> (vector signed char)__b;
+  return (vector signed char)((vector unsigned char)__a >> __b);
 }
 
 static __inline__ vector unsigned char __ATTRS_o_ai
 vec_vsrb(vector unsigned char __a, vector unsigned char __b) {
   return __a >> __b;
 }
 
 /* vec_vsrh */
 
 #define __builtin_altivec_vsrh vec_vsrh
 
 static __inline__ vector short __ATTRS_o_ai
 vec_vsrh(vector short __a, vector unsigned short __b) {
-  return __a >> (vector short)__b;
+  return (vector short)((vector unsigned short)__a >> __b);
 }
 
 static __inline__ vector unsigned short __ATTRS_o_ai
 vec_vsrh(vector unsigned short __a, vector unsigned short __b) {
   return __a >> __b;
 }
 
 /* vec_vsrw */
 
 #define __builtin_altivec_vsrw vec_vsrw
 
 static __inline__ vector int __ATTRS_o_ai vec_vsrw(vector int __a,
                                                    vector unsigned int __b) {
-  return __a >> (vector int)__b;
+  return (vector int)((vector unsigned int)__a >> __b);
 }
 
 static __inline__ vector unsigned int __ATTRS_o_ai
 vec_vsrw(vector unsigned int __a, vector unsigned int __b) {
   return __a >> __b;
 }
 
 /* vec_sra */

 
 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned char __a,
                                               vector bool char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b, __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
                                               vector signed char __b) {
-  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__b,
-                                      (vector unsigned char)__a);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, __b, (vector signed char)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,
                                               vector unsigned char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __b, (vector unsigned char)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool char __a,

 
 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned short __a,
                                               vector bool short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
                                       __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
                                               vector short __b) {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__b,
-                                      (vector unsigned short)__a);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, __b, (vector signed short)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool short __a,
                                               vector unsigned short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __b,
                                       (vector unsigned short)__a);
 }
 

 }
 
 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned int __a,
                                               vector bool int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b, __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
                                               vector int __b) {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__b,
-                                      (vector unsigned int)__a);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, __b, (vector signed int)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,
                                               vector unsigned int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __b, (vector unsigned int)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool int __a,

 static __inline__ int __ATTRS_o_ai vec_all_ge(vector unsigned long long __a,
                                               vector bool long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
                                       __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
                                               vector signed long long __b) {
-  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__b,
-                                      (vector unsigned long long)__a);
+  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, __b, (vector signed long long)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_ge(vector bool long long __a,
                                               vector unsigned long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __b,
                                       (vector unsigned long long)__a);
 }
 

 
 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned char __a,
                                               vector bool char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __a, (vector unsigned char)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
                                               vector signed char __b) {
-  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a,
-                                      (vector unsigned char)__b);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, (vector signed char)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,
                                               vector unsigned char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool char __a,

 
 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned short __a,
                                               vector bool short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __a,
                                       (vector unsigned short)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
                                               vector short __b) {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
-                                      (vector unsigned short)__b);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, (vector signed short)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool short __a,
                                               vector unsigned short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__a,
                                       __b);
 }
 

 
 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned int __a,
                                               vector bool int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __a, (vector unsigned int)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
                                               vector int __b) {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a,
-                                      (vector unsigned int)__b);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, (vector signed int)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,
                                               vector unsigned int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool int __a,

 static __inline__ int __ATTRS_o_ai vec_all_gt(vector unsigned long long __a,
                                               vector bool long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __a,
                                       (vector unsigned long long)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
                                               vector signed long long __b) {
-  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
-                                      (vector unsigned long long)__b);
+  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, (vector signed long long)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_gt(vector bool long long __a,
                                               vector unsigned long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__a,
                                       __b);
 }
 

 
 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned char __a,
                                               vector bool char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, __a, (vector unsigned char)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
                                               vector signed char __b) {
-  return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a,
-                                      (vector unsigned char)__b);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ, (vector signed char)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,
                                               vector unsigned char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ, (vector unsigned char)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool char __a,

 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned short __a,
                                               vector bool short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, __a,
                                       (vector unsigned short)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
                                               vector short __b) {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
-                                      (vector unsigned short)__b);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ, (vector signed short)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool short __a,
                                               vector unsigned short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ, (vector unsigned short)__a,
                                       __b);
 }
 

 
 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned int __a,
                                               vector bool int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, __a, (vector unsigned int)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
                                               vector int __b) {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a,
-                                      (vector unsigned int)__b);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ, (vector signed int)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,
                                               vector unsigned int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ, (vector unsigned int)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool int __a,

 static __inline__ int __ATTRS_o_ai vec_all_le(vector unsigned long long __a,
                                               vector bool long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, __a,
                                       (vector unsigned long long)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
                                               vector signed long long __b) {
-  return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
-                                      (vector unsigned long long)__b);
+  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ, (vector signed long long)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_le(vector bool long long __a,
                                               vector unsigned long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_EQ, (vector unsigned long long)__a,
                                       __b);
 }
 

 
 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned char __a,
                                               vector bool char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b, __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
                                               vector signed char __b) {
-  return __builtin_altivec_vcmpgtub_p(__CR6_LT, (vector unsigned char)__b,
-                                      (vector unsigned char)__a);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_LT, __b, (vector signed char)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,
                                               vector unsigned char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT, __b, (vector unsigned char)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool char __a,

 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned short __a,
                                               vector bool short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
                                       __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
                                               vector short __b) {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_LT, (vector unsigned short)__b,
-                                      (vector unsigned short)__a);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_LT, __b, (vector signed short)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool short __a,
                                               vector unsigned short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT, __b,
                                       (vector unsigned short)__a);
 }
 

 
 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned int __a,
                                               vector bool int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b, __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
                                               vector int __b) {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT, (vector unsigned int)__b,
-                                      (vector unsigned int)__a);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_LT, __b, (vector signed int)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,
                                               vector unsigned int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT, __b, (vector unsigned int)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool int __a,

 static __inline__ int __ATTRS_o_ai vec_all_lt(vector unsigned long long __a,
                                               vector bool long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
                                       __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
                                               vector signed long long __b) {
-  return __builtin_altivec_vcmpgtud_p(__CR6_LT, (vector unsigned long long)__b,
-                                      (vector unsigned long long)__a);
+  return __builtin_altivec_vcmpgtsd_p(__CR6_LT, __b, (vector signed long long)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_all_lt(vector bool long long __a,
                                               vector unsigned long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_LT, __b,
                                       (vector unsigned long long)__a);
 }
 
static __inline__ int __ATTRS_o_ai vec_all_ne(vector bool long long __a,
   return __builtin_altivec_vcmpequd_p(__CR6_EQ, (vector signed long long)__a,
                                       (vector signed long long)__b);
 }
 #endif
 
 static __inline__ int __ATTRS_o_ai vec_all_ne(vector float __a,
                                               vector float __b) {
 #ifdef __VSX__
-  return __builtin_vsx_xvcmpeqdp_p(__CR6_EQ, __a, __b);
+  return __builtin_vsx_xvcmpeqsp_p(__CR6_EQ, __a, __b);
 #else
   return __builtin_altivec_vcmpeqfp_p(__CR6_EQ, __a, __b);
 #endif
 }
 
 #ifdef __VSX__
 static __inline__ int __ATTRS_o_ai vec_all_ne(vector double __a,
                                               vector double __b) {

 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned char __a,
                                               vector bool char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
                                       __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
                                               vector signed char __b) {
-  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__b,
-                                      (vector unsigned char)__a);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, __b, (vector signed char)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool char __a,
                                               vector unsigned char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __b,
                                       (vector unsigned char)__a);
 }
 

 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned short __a,
                                               vector bool short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
                                       __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
                                               vector short __b) {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__b,
-                                      (vector unsigned short)__a);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, __b, (vector signed short)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool short __a,
                                               vector unsigned short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __b,
                                       (vector unsigned short)__a);
 }
 

 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned int __a,
                                               vector bool int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
                                       __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
                                               vector int __b) {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__b,
-                                      (vector unsigned int)__a);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, __b, (vector signed int)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool int __a,
                                               vector unsigned int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __b,
                                       (vector unsigned int)__a);
 }
 

 static __inline__ int __ATTRS_o_ai vec_any_ge(vector unsigned long long __a,
                                               vector bool long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
                                       (vector unsigned long long)__b, __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
                                               vector signed long long __b) {
-  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
-                                      (vector unsigned long long)__b,
-                                      (vector unsigned long long)__a);
+  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, __b, (vector signed long long)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_ge(vector bool long long __a,
                                               vector unsigned long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __b,
                                       (vector unsigned long long)__a);
 }
 

 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned char __a,
                                               vector bool char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __a,
                                       (vector unsigned char)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
                                               vector signed char __b) {
-  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
-                                      (vector unsigned char)__b);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, (vector signed char)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool char __a,
                                               vector unsigned char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__a,
                                       __b);
 }
 

 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned short __a,
                                               vector bool short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __a,
                                       (vector unsigned short)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
                                               vector short __b) {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
-                                      (vector unsigned short)__b);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, (vector signed short)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool short __a,
                                               vector unsigned short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__a,
                                       __b);
 }
 

 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned int __a,
                                               vector bool int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __a,
                                       (vector unsigned int)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
                                               vector int __b) {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
-                                      (vector unsigned int)__b);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, (vector signed int)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool int __a,
                                               vector unsigned int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__a,
                                       __b);
 }
 

 static __inline__ int __ATTRS_o_ai vec_any_gt(vector unsigned long long __a,
                                               vector bool long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __a,
                                       (vector unsigned long long)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
                                               vector signed long long __b) {
-  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
-                                      (vector unsigned long long)__a,
-                                      (vector unsigned long long)__b);
+  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, (vector signed long long)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_gt(vector bool long long __a,
                                               vector unsigned long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
                                       (vector unsigned long long)__a, __b);
 }
 

 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned char __a,
                                               vector bool char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, __a,
                                       (vector unsigned char)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
                                               vector signed char __b) {
-  return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
-                                      (vector unsigned char)__b);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_LT_REV, (vector signed char)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool char __a,
                                               vector unsigned char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_LT_REV, (vector unsigned char)__a,
                                       __b);
 }
 

 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned short __a,
                                               vector bool short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, __a,
                                       (vector unsigned short)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
                                               vector short __b) {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
-                                      (vector unsigned short)__b);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_LT_REV, (vector signed short)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool short __a,
                                               vector unsigned short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_LT_REV, (vector unsigned short)__a,
                                       __b);
 }
 

 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned int __a,
                                               vector bool int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, __a,
                                       (vector unsigned int)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
                                               vector int __b) {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
-                                      (vector unsigned int)__b);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_LT_REV, (vector signed int)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool int __a,
                                               vector unsigned int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_LT_REV, (vector unsigned int)__a,
                                       __b);
 }
 

 static __inline__ int __ATTRS_o_ai vec_any_le(vector unsigned long long __a,
                                               vector bool long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV, __a,
                                       (vector unsigned long long)__b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
                                               vector signed long long __b) {
-  return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
-                                      (vector unsigned long long)__a,
-                                      (vector unsigned long long)__b);
+  return __builtin_altivec_vcmpgtsd_p(__CR6_LT_REV, (vector signed long long)__a, __b);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_le(vector bool long long __a,
                                               vector unsigned long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_LT_REV,
                                       (vector unsigned long long)__a, __b);
 }
 

 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned char __a,
                                               vector bool char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
                                       __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
                                               vector signed char __b) {
-  return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, (vector unsigned char)__b,
-                                      (vector unsigned char)__a);
+  return __builtin_altivec_vcmpgtsb_p(__CR6_EQ_REV, __b, (vector signed char)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool char __a,
                                               vector unsigned char __b) {
   return __builtin_altivec_vcmpgtub_p(__CR6_EQ_REV, __b,
                                       (vector unsigned char)__a);
 }
 

 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned short __a,
                                               vector bool short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
                                       __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
                                               vector short __b) {
-  return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, (vector unsigned short)__b,
-                                      (vector unsigned short)__a);
+  return __builtin_altivec_vcmpgtsh_p(__CR6_EQ_REV, __b, (vector signed short)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool short __a,
                                               vector unsigned short __b) {
   return __builtin_altivec_vcmpgtuh_p(__CR6_EQ_REV, __b,
                                       (vector unsigned short)__a);
 }
 

 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned int __a,
                                               vector bool int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
                                       __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
                                               vector int __b) {
-  return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, (vector unsigned int)__b,
-                                      (vector unsigned int)__a);
+  return __builtin_altivec_vcmpgtsw_p(__CR6_EQ_REV, __b, (vector signed int)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool int __a,
                                               vector unsigned int __b) {
   return __builtin_altivec_vcmpgtuw_p(__CR6_EQ_REV, __b,
                                       (vector unsigned int)__a);
 }
 

 static __inline__ int __ATTRS_o_ai vec_any_lt(vector unsigned long long __a,
                                               vector bool long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
                                       (vector unsigned long long)__b, __a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
                                               vector signed long long __b) {
-  return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV,
-                                      (vector unsigned long long)__b,
-                                      (vector unsigned long long)__a);
+  return __builtin_altivec_vcmpgtsd_p(__CR6_EQ_REV, __b, (vector signed long long)__a);
 }
 
 static __inline__ int __ATTRS_o_ai vec_any_lt(vector bool long long __a,
                                               vector unsigned long long __b) {
   return __builtin_altivec_vcmpgtud_p(__CR6_EQ_REV, __b,
                                       (vector unsigned long long)__a);
 }
 

 vec_xl(signed long long __offset, unsigned __int128 *__ptr) {
   return *(vector unsigned __int128 *)(__ptr + __offset);
 }
 #endif
 
 /* vec_xl_be */
 
 #ifdef __LITTLE_ENDIAN__
+#ifdef __VSX__
 static __inline__ vector signed char __ATTRS_o_ai
 vec_xl_be(signed long long __offset, signed char *__ptr) {
   vector signed char __vec = __builtin_vsx_lxvd2x_be(__offset, __ptr);
   return __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
                                  13, 12, 11, 10, 9, 8);
 }
 
 static __inline__ vector unsigned char __ATTRS_o_ai

 vec_xl_be(signed long long  __offset, unsigned int *__ptr) {
   return (vector unsigned int)__builtin_vsx_lxvw4x_be(__offset, __ptr);
 }
 
 static __inline__ vector float __ATTRS_o_ai
 vec_xl_be(signed long long  __offset, float *__ptr) {
   return (vector float)__builtin_vsx_lxvw4x_be(__offset, __ptr);
 }
 
-#ifdef __VSX__
 static __inline__ vector signed long long __ATTRS_o_ai
 vec_xl_be(signed long long  __offset, signed long long *__ptr) {
   return (vector signed long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
 }
 
 static __inline__ vector unsigned long long __ATTRS_o_ai
 vec_xl_be(signed long long  __offset, unsigned long long *__ptr) {
   return (vector unsigned long long)__builtin_vsx_lxvd2x_be(__offset, __ptr);
 }
static inline __ATTRS_o_ai void vec_xst(vector unsigned __int128 __vec,
                                         unsigned __int128 *__ptr) {
   *(vector unsigned __int128 *)(__ptr + __offset) = __vec;
 }
 #endif
 
 /* vec_xst_be */
 
 #ifdef __LITTLE_ENDIAN__
+#ifdef __VSX__
 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed char __vec,
                                                signed long long  __offset,
                                                signed char *__ptr) {
   vector signed char __tmp =
      __builtin_shufflevector(__vec, __vec, 7, 6, 5, 4, 3, 2, 1, 0, 15, 14,
                              13, 12, 11, 10, 9, 8);
   __builtin_vsx_stxvd2x_be(__tmp, __offset, __ptr);
 }

 }
 
 static __inline__ void __ATTRS_o_ai vec_xst_be(vector float __vec,
                                                signed long long  __offset,
                                                float *__ptr) {
   __builtin_vsx_stxvw4x_be(__vec, __offset, __ptr);
 }
 
-#ifdef __VSX__
 static __inline__ void __ATTRS_o_ai vec_xst_be(vector signed long long __vec,
                                                signed long long  __offset,
                                                signed long long *__ptr) {
   __builtin_vsx_stxvd2x_be(__vec, __offset, __ptr);
 }
 
 static __inline__ void __ATTRS_o_ai vec_xst_be(vector unsigned long long __vec,
                                                signed long long  __offset,

test/CodeGen/builtins-ppc-altivec.c

 // CHECK: lshr <4 x i32>
 // CHECK-LE: lshr <4 x i32>
 
   res_vui = vec_sr(vui, vui);
 // CHECK: lshr <4 x i32>
 // CHECK-LE: lshr <4 x i32>
 
   res_vsc = vec_vsrb(vsc, vuc);
-// CHECK: shr <16 x i8>
-// CHECK-LE: shr <16 x i8>
+// CHECK: lshr <16 x i8>
+// CHECK-LE: lshr <16 x i8>
 
   res_vuc = vec_vsrb(vuc, vuc);
-// CHECK: shr <16 x i8>
-// CHECK-LE: shr <16 x i8>
+// CHECK: lshr <16 x i8>
+// CHECK-LE: lshr <16 x i8>
 
   res_vs  = vec_vsrh(vs, vus);
-// CHECK: shr <8 x i16>
-// CHECK-LE: shr <8 x i16>
+// CHECK: lshr <8 x i16>
+// CHECK-LE: lshr <8 x i16>
 
   res_vus = vec_vsrh(vus, vus);
-// CHECK: shr <8 x i16>
-// CHECK-LE: shr <8 x i16>
+// CHECK: lshr <8 x i16>
+// CHECK-LE: lshr <8 x i16>
 
   res_vi  = vec_vsrw(vi, vui);
-// CHECK: shr <4 x i32>
-// CHECK-LE: shr <4 x i32>
+// CHECK: lshr <4 x i32>
+// CHECK-LE: lshr <4 x i32>
 
   res_vui = vec_vsrw(vui, vui);
-// CHECK: shr <4 x i32>
-// CHECK-LE: shr <4 x i32>
+// CHECK: lshr <4 x i32>
+// CHECK-LE: lshr <4 x i32>
 
   /* vec_sra */
   res_vsc = vec_sra(vsc, vuc);
 // CHECK: @llvm.ppc.altivec.vsrab
 // CHECK-LE: @llvm.ppc.altivec.vsrab
 
   res_vuc = vec_sra(vuc, vuc);
 // CHECK: @llvm.ppc.altivec.vsrab

 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_all_ge(vuc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_all_ge(vbc, vsc);
-// CHECK: @llvm.ppc.altivec.vcmpgtub.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsb.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsb.p
 
   res_i = vec_all_ge(vbc, vuc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_all_ge(vbc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_all_ge(vus, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_all_ge(vbs, vs);
-// CHECK: @llvm.ppc.altivec.vcmpgtuh.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsh.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsh.p
 
   res_i = vec_all_ge(vbs, vus);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_all_ge(vbs, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_all_ge(vui, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_all_ge(vbi, vi);
-// CHECK: @llvm.ppc.altivec.vcmpgtuw.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsw.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsw.p
 
   res_i = vec_all_ge(vbi, vui);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_all_ge(vbi, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p

 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_all_gt(vuc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_all_gt(vbc, vsc);
-// CHECK: @llvm.ppc.altivec.vcmpgtub.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsb.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsb.p
 
   res_i = vec_all_gt(vbc, vuc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_all_gt(vbc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_all_gt(vus, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_all_gt(vbs, vs);
-// CHECK: @llvm.ppc.altivec.vcmpgtuh.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsh.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsh.p
 
   res_i = vec_all_gt(vbs, vus);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_all_gt(vbs, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_all_gt(vui, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_all_gt(vbi, vi);
-// CHECK: @llvm.ppc.altivec.vcmpgtuw.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsw.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsw.p
 
   res_i = vec_all_gt(vbi, vui);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_all_gt(vbi, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p

 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_all_le(vuc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_all_le(vbc, vsc);
-// CHECK: @llvm.ppc.altivec.vcmpgtub.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsb.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsb.p
 
   res_i = vec_all_le(vbc, vuc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_all_le(vbc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_all_le(vus, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_all_le(vbs, vs);
-// CHECK: @llvm.ppc.altivec.vcmpgtuh.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsh.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsh.p
 
   res_i = vec_all_le(vbs, vus);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_all_le(vbs, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_all_le(vui, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_all_le(vbi, vi);
-// CHECK: @llvm.ppc.altivec.vcmpgtuw.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsw.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsw.p
 
   res_i = vec_all_le(vbi, vui);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_all_le(vbi, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p

 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_all_lt(vuc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_all_lt(vbc, vsc);
-// CHECK: @llvm.ppc.altivec.vcmpgtub.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsb.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsb.p
 
   res_i = vec_all_lt(vbc, vuc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_all_lt(vbc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_all_lt(vus, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_all_lt(vbs, vs);
-// CHECK: @llvm.ppc.altivec.vcmpgtuh.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsh.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsh.p
 
   res_i = vec_all_lt(vbs, vus);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_all_lt(vbs, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_all_lt(vui, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_all_lt(vbi, vi);
-// CHECK: @llvm.ppc.altivec.vcmpgtuw.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsw.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsw.p
 
   res_i = vec_all_lt(vbi, vui);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_all_lt(vbi, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p

 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_any_ge(vuc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_any_ge(vbc, vsc);
-// CHECK: @llvm.ppc.altivec.vcmpgtub.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsb.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsb.p
 
   res_i = vec_any_ge(vbc, vuc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_any_ge(vbc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_any_ge(vus, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_any_ge(vbs, vs);
-// CHECK: @llvm.ppc.altivec.vcmpgtuh.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsh.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsh.p
 
   res_i = vec_any_ge(vbs, vus);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_any_ge(vbs, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_any_ge(vui, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_any_ge(vbi, vi);
-// CHECK: @llvm.ppc.altivec.vcmpgtuw.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsw.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsw.p
 
   res_i = vec_any_ge(vbi, vui);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_any_ge(vbi, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p

 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_any_gt(vuc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_any_gt(vbc, vsc);
-// CHECK: @llvm.ppc.altivec.vcmpgtub.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsb.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsb.p
 
   res_i = vec_any_gt(vbc, vuc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_any_gt(vbc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_any_gt(vus, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_any_gt(vbs, vs);
-// CHECK: @llvm.ppc.altivec.vcmpgtuh.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsh.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsh.p
 
   res_i = vec_any_gt(vbs, vus);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_any_gt(vbs, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_any_gt(vui, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_any_gt(vbi, vi);
-// CHECK: @llvm.ppc.altivec.vcmpgtuw.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsw.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsw.p
 
   res_i = vec_any_gt(vbi, vui);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_any_gt(vbi, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p

 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_any_le(vuc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_any_le(vbc, vsc);
-// CHECK: @llvm.ppc.altivec.vcmpgtub.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsb.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsb.p
 
   res_i = vec_any_le(vbc, vuc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_any_le(vbc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_any_le(vus, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_any_le(vbs, vs);
-// CHECK: @llvm.ppc.altivec.vcmpgtuh.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsh.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsh.p
 
   res_i = vec_any_le(vbs, vus);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_any_le(vbs, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_any_le(vui, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_any_le(vbi, vi);
-// CHECK: @llvm.ppc.altivec.vcmpgtuw.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsw.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsw.p
 
   res_i = vec_any_le(vbi, vui);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_any_le(vbi, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p

 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_any_lt(vuc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_any_lt(vbc, vsc);
-// CHECK: @llvm.ppc.altivec.vcmpgtub.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsb.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsb.p
 
   res_i = vec_any_lt(vbc, vuc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p
 
   res_i = vec_any_lt(vbc, vbc);
 // CHECK: @llvm.ppc.altivec.vcmpgtub.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtub.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_any_lt(vus, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_any_lt(vbs, vs);
-// CHECK: @llvm.ppc.altivec.vcmpgtuh.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsh.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsh.p
 
   res_i = vec_any_lt(vbs, vus);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p
 
   res_i = vec_any_lt(vbs, vbs);
 // CHECK: @llvm.ppc.altivec.vcmpgtuh.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuh.p

 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_any_lt(vui, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_any_lt(vbi, vi);
-// CHECK: @llvm.ppc.altivec.vcmpgtuw.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsw.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsw.p
 
   res_i = vec_any_lt(vbi, vui);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
 
   res_i = vec_any_lt(vbi, vbi);
 // CHECK: @llvm.ppc.altivec.vcmpgtuw.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtuw.p
void test10() {
   vec_xst(vui, param_sll, &param_ui);
   // CHECK: store <4 x i32> %{{[0-9]+}}, <4 x i32>* %{{[0-9]+}}, align 16
   // CHECK-LE: store <4 x i32> %{{[0-9]+}}, <4 x i32>* %{{[0-9]+}}, align 16
 
   vec_xst(vf, param_sll, &param_f);
   // CHECK: store <4 x float> %{{[0-9]+}}, <4 x float>* %{{[0-9]+}}, align 16
   // CHECK-LE: store <4 x float> %{{[0-9]+}}, <4 x float>* %{{[0-9]+}}, align 16
 }
-
-/* ----------------------------- vec_xl_be ---------------------------------- */
-void test11() {
-  // CHECK-LABEL: define void @test11
-  // CHECK-LE-LABEL: define void @test11
-  res_vsc = vec_xl_be(param_sll, &param_sc);
-  // CHECK: load <16 x i8>, <16 x i8>* %{{[0-9]+}}, align 16
-  // CHECK-LE: call <2 x double> @llvm.ppc.vsx.lxvd2x.be(i8* %{{[0-9]+}})
-  // CHECK-LE: shufflevector <16 x i8> %{{[0-9]+}}, <16 x i8> %{{[0-9]+}}, <16 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0, i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8>
-
-  res_vuc = vec_xl_be(param_sll, &param_uc);
-  // CHECK: load <16 x i8>, <16 x i8>* %{{[0-9]+}}, align 16
-  // CHECK-LE: call <2 x double> @llvm.ppc.vsx.lxvd2x.be(i8* %{{[0-9]+}})
-  // CHECK-LE: shufflevector <16 x i8> %{{[0-9]+}}, <16 x i8> %{{[0-9]+}}, <16 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0, i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8>
-
-  res_vs = vec_xl_be(param_sll, &param_s);
-  // CHECK: load <8 x i16>, <8 x i16>* %{{[0-9]+}}, align 16
-  // CHECK-LE: call <2 x double> @llvm.ppc.vsx.lxvd2x.be(i8* %{{[0-9]+}})
-  // CHECK-LE: shufflevector <8 x i16> %{{[0-9]+}}, <8 x i16> %{{[0-9]+}}, <8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4>
-
-  res_vus = vec_xl_be(param_sll, &param_us);
-  // CHECK: load <8 x i16>, <8 x i16>* %{{[0-9]+}}, align 16
-  // CHECK-LE: call <2 x double> @llvm.ppc.vsx.lxvd2x.be(i8* %{{[0-9]+}})
-  // CHECK-LE: shufflevector <8 x i16> %{{[0-9]+}}, <8 x i16> %{{[0-9]+}}, <8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4>
-
-  res_vi = vec_xl_be(param_sll, &param_i);
-  // CHECK: load <4 x i32>, <4 x i32>* %{{[0-9]+}}, align 16
-  // CHECK-LE: call <4 x i32> @llvm.ppc.vsx.lxvw4x.be(i8* %{{[0-9]+}})
-
-  res_vui = vec_xl_be(param_sll, &param_ui);
-  // CHECK: load <4 x i32>, <4 x i32>* %{{[0-9]+}}, align 16
-  // CHECK-LE: call <4 x i32> @llvm.ppc.vsx.lxvw4x.be(i8* %{{[0-9]+}})
-
-  res_vf = vec_xl_be(param_sll, &param_f);
-  // CHECK: load <4 x float>, <4 x float>* %{{[0-9]+}}, align 16
-  // CHECK-LE: call <4 x i32> @llvm.ppc.vsx.lxvw4x.be(i8* %{{[0-9]+}})
-}
-
-/* ----------------------------- vec_xst_be --------------------------------- */
-void test12() {
-  // CHECK-LABEL: define void @test12
-  // CHECK-LE-LABEL: define void @test12
-  vec_xst_be(vsc, param_sll, &param_sc);
-  // CHECK: store <16 x i8> %{{[0-9]+}}, <16 x i8>* %{{[0-9]+}}, align 16
-  // CHECK-LE: shufflevector <16 x i8> %{{[0-9]+}}, <16 x i8> %{{[0-9]+}}, <16 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0, i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8>
-  // CHECK-LE: call void @llvm.ppc.vsx.stxvd2x.be(<2 x double> %{{[0-9]+}}, i8* %{{[0-9]+}})
-
-  vec_xst_be(vuc, param_sll, &param_uc);
-  // CHECK: store <16 x i8> %{{[0-9]+}}, <16 x i8>* %{{[0-9]+}}, align 16
-  // CHECK-LE: shufflevector <16 x i8> %{{[0-9]+}}, <16 x i8> %{{[0-9]+}}, <16 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0, i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8>
-  // CHECK-LE: call void @llvm.ppc.vsx.stxvd2x.be(<2 x double> %{{[0-9]+}}, i8* %{{[0-9]+}})
-
-  vec_xst_be(vs, param_sll, &param_s);
-  // CHECK: store <8 x i16> %{{[0-9]+}}, <8 x i16>* %{{[0-9]+}}, align 16
-  // CHECK-LE: shufflevector <8 x i16> %{{[0-9]+}}, <8 x i16> %{{[0-9]+}}, <8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4>
-  // CHECK-LE: call void @llvm.ppc.vsx.stxvd2x.be(<2 x double> %{{[0-9]+}}, i8* %{{[0-9]+}})
-
-  vec_xst_be(vus, param_sll, &param_us);
-  // CHECK: store <8 x i16> %{{[0-9]+}}, <8 x i16>* %{{[0-9]+}}, align 16
-  // CHECK-LE: shufflevector <8 x i16> %{{[0-9]+}}, <8 x i16> %{{[0-9]+}}, <8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4>
-  // CHECK-LE: call void @llvm.ppc.vsx.stxvd2x.be(<2 x double> %{{[0-9]+}}, i8* %{{[0-9]+}})
-
-  vec_xst_be(vi, param_sll, &param_i);
-  // CHECK: store <4 x i32> %{{[0-9]+}}, <4 x i32>* %{{[0-9]+}}, align 16
-  // CHECK-LE: call void @llvm.ppc.vsx.stxvw4x.be(<4 x i32> %{{[0-9]+}}, i8* %{{[0-9]+}})
-
-  vec_xst_be(vui, param_sll, &param_ui);
-  // CHECK: store <4 x i32> %{{[0-9]+}}, <4 x i32>* %{{[0-9]+}}, align 16
-  // CHECK-LE: call void @llvm.ppc.vsx.stxvw4x.be(<4 x i32> %{{[0-9]+}}, i8* %{{[0-9]+}})
-
-  vec_xst_be(vf, param_sll, &param_f);
-  // CHECK: store <4 x float> %{{[0-9]+}}, <4 x float>* %{{[0-9]+}}, align 16
-  // CHECK-LE: call void @llvm.ppc.vsx.stxvw4x.be(<4 x i32> %{{[0-9]+}}, i8* %{{[0-9]+}})
-}

test/CodeGen/builtins-ppc-p8vector.c

// CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
   res_i = vec_all_ne(vbll, vbll);
 // CHECK: @llvm.ppc.altivec.vcmpequd.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpequd.p
 // CHECK-PPC: error: call to 'vec_all_ne' is ambiguous
 
   dummy();
 // CHECK: @dummy
 
+  res_i = vec_all_ne(vfa, vfa);
+// CHECK: @llvm.ppc.vsx.xvcmpeqsp.p
+// CHECK-LE: @llvm.ppc.vsx.xvcmpeqsp.p
+
   res_i = vec_all_ne(vda, vda);
 // CHECK: @llvm.ppc.vsx.xvcmpeqdp.p
 // CHECK-LE: @llvm.ppc.vsx.xvcmpeqdp.p
 
   dummy();
 // CHECK: @dummy
 
   res_i = vec_all_nge(vda, vda);

 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
 
   res_i = vec_all_ge(vull, vbll);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
 
   res_i = vec_all_ge(vbll, vsll);
-// CHECK: @llvm.ppc.altivec.vcmpgtud.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
 
   res_i = vec_all_ge(vbll, vull);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_all_ge' is ambiguous
 
   res_i = vec_all_ge(vbll, vbll);

 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
 
   res_i = vec_all_gt(vull, vbll);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
 
   res_i = vec_all_gt(vbll, vsll);
-// CHECK: @llvm.ppc.altivec.vcmpgtud.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
 
   res_i = vec_all_gt(vbll, vull);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_all_gt' is ambiguous
 
   res_i = vec_all_gt(vbll, vbll);

 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous
 
   res_i = vec_all_le(vull, vbll);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous
 
   res_i = vec_all_le(vbll, vsll);
-// CHECK: @llvm.ppc.altivec.vcmpgtud.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous
 
   res_i = vec_all_le(vbll, vull);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_all_le' is ambiguous
 
   res_i = vec_all_le(vbll, vbll);

 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
 
   res_i = vec_all_lt(vull, vbll);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
 
   res_i = vec_all_lt(vbll, vsll);
-// CHECK: @llvm.ppc.altivec.vcmpgtud.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
 
   res_i = vec_all_lt(vbll, vull);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_all_lt' is ambiguous
 
   res_i = vec_all_lt(vbll, vbll);

 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
 
   res_i = vec_any_ge(vull, vbll);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
 
   res_i = vec_any_ge(vbll, vsll);
-// CHECK: @llvm.ppc.altivec.vcmpgtud.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
 
   res_i = vec_any_ge(vbll, vull);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_any_ge' is ambiguous
 
   res_i = vec_any_ge(vbll, vbll);

 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
 
   res_i = vec_any_gt(vull, vbll);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
 
   res_i = vec_any_gt(vbll, vsll);
-// CHECK: @llvm.ppc.altivec.vcmpgtud.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
 
   res_i = vec_any_gt(vbll, vull);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_any_gt' is ambiguous
 
   res_i = vec_any_gt(vbll, vbll);

 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous
 
   res_i = vec_any_le(vull, vbll);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous
 
   res_i = vec_any_le(vbll, vsll);
-// CHECK: @llvm.ppc.altivec.vcmpgtud.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous
 
   res_i = vec_any_le(vbll, vull);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_any_le' is ambiguous
 
   res_i = vec_any_le(vbll, vbll);

 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
 
   res_i = vec_any_lt(vull, vbll);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
 
   res_i = vec_any_lt(vbll, vsll);
-// CHECK: @llvm.ppc.altivec.vcmpgtud.p
-// CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
+// CHECK: @llvm.ppc.altivec.vcmpgtsd.p
+// CHECK-LE: @llvm.ppc.altivec.vcmpgtsd.p
 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
 
   res_i = vec_any_lt(vbll, vull);
 // CHECK: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-LE: @llvm.ppc.altivec.vcmpgtud.p
 // CHECK-PPC: error: call to 'vec_any_lt' is ambiguous
 
   res_i = vec_any_lt(vbll, vbll);

test/CodeGen/builtins-ppc-vsx.c

 // CHECK-LE: sub nsw i32 18
 // CHECK-LE: sub nsw i32 31
 // CHECK-LE: @llvm.ppc.altivec.vperm
 
   res_vsll = vec_sll(vsll, vuc);
 // CHECK: @llvm.ppc.altivec.vsl
 // CHECK-LE: @llvm.ppc.altivec.vsl
 
   res_vull = vec_sll(vull, vuc);
 // CHECK: @llvm.ppc.altivec.vsl
 // CHECK-LE: @llvm.ppc.altivec.vsl
 
   res_vsll = vec_slo(vsll, vsc);
 // CHECK: @llvm.ppc.altivec.vslo
 // CHECK-LE: @llvm.ppc.altivec.vslo
 
   res_vsll = vec_slo(vsll, vuc);
 // CHECK: @llvm.ppc.altivec.vslo
 // CHECK-LE: @llvm.ppc.altivec.vslo
 
   res_vull = vec_slo(vull, vsc);
// CHECK-LE: @llvm.ppc.altivec.vsro
   res_vull = vec_sro(vull, vsc);
 // CHECK: @llvm.ppc.altivec.vsro
 // CHECK-LE: @llvm.ppc.altivec.vsro
 
   res_vull = vec_sro(vull, vuc);
 // CHECK: @llvm.ppc.altivec.vsro
 // CHECK-LE: @llvm.ppc.altivec.vsro
 
   res_vsll = vec_xl(sll, asll);
 // CHECK: load <2 x i64>, <2 x i64>* %{{[0-9]+}}, align 16
 // CHECK-LE: load <2 x i64>, <2 x i64>* %{{[0-9]+}}, align 16
 
   res_vull = vec_xl(sll, aull);
 // CHECK: load <2 x i64>, <2 x i64>* %{{[0-9]+}}, align 16
 // CHECK-LE: load <2 x i64>, <2 x i64>* %{{[0-9]+}}, align 16
 
   res_vd = vec_xl(sll, ad);
 // CHECK: load <2 x double>, <2 x double>* %{{[0-9]+}}, align 16
 // CHECK-LE: load <2 x double>, <2 x double>* %{{[0-9]+}}, align 16
 
   vec_xst(vsll, sll, asll);
 // CHECK: store <2 x i64> %{{[0-9]+}}, <2 x i64>* %{{[0-9]+}}, align 16
 // CHECK-LE: store <2 x i64> %{{[0-9]+}}, <2 x i64>* %{{[0-9]+}}, align 16
 
   vec_xst(vull, sll, aull);
 // CHECK: store <2 x i64> %{{[0-9]+}}, <2 x i64>* %{{[0-9]+}}, align 16
 // CHECK-LE: store <2 x i64> %{{[0-9]+}}, <2 x i64>* %{{[0-9]+}}, align 16
 
   vec_xst(vd, sll, ad);
 // CHECK: store <2 x double> %{{[0-9]+}}, <2 x double>* %{{[0-9]+}}, align 16
 // CHECK-LE: store <2 x double> %{{[0-9]+}}, <2 x double>* %{{[0-9]+}}, align 16
 
-res_vsll = vec_xl_be(sll, asll);
+  res_vf = vec_neg(vf);
+// CHECK: fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, {{%[0-9]+}}
+// CHECK-LE: fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, {{%[0-9]+}}
+
+  res_vd = vec_neg(vd);
+// CHECK: fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, {{%[0-9]+}}
+// CHECK-LE: fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, {{%[0-9]+}}
+}
+
+
+/* ----------------------------- vec_xl_be ---------------------------------- */
+void test2() {
+  // CHECK-LABEL: define void @test2
+  // CHECK-LE-LABEL: define void @test2
+  vec_xl_be(sll, asc);
+  // CHECK: load <16 x i8>, <16 x i8>* %{{[0-9]+}}, align 16
+  // CHECK-LE: call <2 x double> @llvm.ppc.vsx.lxvd2x.be(i8* %{{[0-9]+}})
+  // CHECK-LE: shufflevector <16 x i8> %{{[0-9]+}}, <16 x i8> %{{[0-9]+}}, <16 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0, i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8>
+
+  vec_xl_be(sll, auc);
+  // CHECK: load <16 x i8>, <16 x i8>* %{{[0-9]+}}, align 16
+  // CHECK-LE: call <2 x double> @llvm.ppc.vsx.lxvd2x.be(i8* %{{[0-9]+}})
+  // CHECK-LE: shufflevector <16 x i8> %{{[0-9]+}}, <16 x i8> %{{[0-9]+}}, <16 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0, i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8>
+
+  vec_xl_be(sll, ass);
+  // CHECK: load <8 x i16>, <8 x i16>* %{{[0-9]+}}, align 16
+  // CHECK-LE: call <2 x double> @llvm.ppc.vsx.lxvd2x.be(i8* %{{[0-9]+}})
+  // CHECK-LE: shufflevector <8 x i16> %{{[0-9]+}}, <8 x i16> %{{[0-9]+}}, <8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4>
+
+  vec_xl_be(sll, aus);
+  // CHECK: load <8 x i16>, <8 x i16>* %{{[0-9]+}}, align 16
+  // CHECK-LE: call <2 x double> @llvm.ppc.vsx.lxvd2x.be(i8* %{{[0-9]+}})
+  // CHECK-LE: shufflevector <8 x i16> %{{[0-9]+}}, <8 x i16> %{{[0-9]+}}, <8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4>
+
+  vec_xl_be(sll, asi);
+  // CHECK: load <4 x i32>, <4 x i32>* %{{[0-9]+}}, align 16
+  // CHECK-LE: call <4 x i32> @llvm.ppc.vsx.lxvw4x.be(i8* %{{[0-9]+}})
+
+  vec_xl_be(sll, aui);
+  // CHECK: load <4 x i32>, <4 x i32>* %{{[0-9]+}}, align 16
+  // CHECK-LE: call <4 x i32> @llvm.ppc.vsx.lxvw4x.be(i8* %{{[0-9]+}})
+
+  vec_xl_be(sll, asll);
   // CHECK: load <2 x i64>, <2 x i64>* %{{[0-9]+}}, align 16
   // CHECK-LE: call <2 x double> @llvm.ppc.vsx.lxvd2x.be(i8* %{{[0-9]+}})
 
-res_vull = vec_xl_be(sll, aull);
+  vec_xl_be(sll, aull);
   // CHECK: load <2 x i64>, <2 x i64>* %{{[0-9]+}}, align 16
   // CHECK-LE: call <2 x double> @llvm.ppc.vsx.lxvd2x.be(i8* %{{[0-9]+}})
 
-res_vd = vec_xl_be(sll, ad);
+  vec_xl_be(sll, af);
+  // CHECK: load <4 x float>, <4 x float>* %{{[0-9]+}}, align 16
+  // CHECK-LE: call <4 x i32> @llvm.ppc.vsx.lxvw4x.be(i8* %{{[0-9]+}})
+
+  vec_xl_be(sll, ad);
   // CHECK: load <2 x double>, <2 x double>* %{{[0-9]+}}, align 16
   // CHECK-LE: call <2 x double> @llvm.ppc.vsx.lxvd2x.be(i8* %{{[0-9]+}})
+}
+
+/* ----------------------------- vec_xst_be --------------------------------- */
+void test3() {
+  // CHECK-LABEL: define void @test3
+  // CHECK-LE-LABEL: define void @test3
+  vec_xst_be(vsc, sll, asc);
+  // CHECK: store <16 x i8> %{{[0-9]+}}, <16 x i8>* %{{[0-9]+}}, align 16
+  // CHECK-LE: shufflevector <16 x i8> %{{[0-9]+}}, <16 x i8> %{{[0-9]+}}, <16 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0, i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8>
+  // CHECK-LE: call void @llvm.ppc.vsx.stxvd2x.be(<2 x double> %{{[0-9]+}}, i8* %{{[0-9]+}})
+
+  vec_xst_be(vuc, sll, auc);
+  // CHECK: store <16 x i8> %{{[0-9]+}}, <16 x i8>* %{{[0-9]+}}, align 16
+  // CHECK-LE: shufflevector <16 x i8> %{{[0-9]+}}, <16 x i8> %{{[0-9]+}}, <16 x i32> <i32 7, i32 6, i32 5, i32 4, i32 3, i32 2, i32 1, i32 0, i32 15, i32 14, i32 13, i32 12, i32 11, i32 10, i32 9, i32 8>
+  // CHECK-LE: call void @llvm.ppc.vsx.stxvd2x.be(<2 x double> %{{[0-9]+}}, i8* %{{[0-9]+}})
+
+  vec_xst_be(vss, sll, ass);
+  // CHECK: store <8 x i16> %{{[0-9]+}}, <8 x i16>* %{{[0-9]+}}, align 16
+  // CHECK-LE: shufflevector <8 x i16> %{{[0-9]+}}, <8 x i16> %{{[0-9]+}}, <8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4>
+  // CHECK-LE: call void @llvm.ppc.vsx.stxvd2x.be(<2 x double> %{{[0-9]+}}, i8* %{{[0-9]+}})
+
+  vec_xst_be(vus, sll, aus);
+  // CHECK: store <8 x i16> %{{[0-9]+}}, <8 x i16>* %{{[0-9]+}}, align 16
+  // CHECK-LE: shufflevector <8 x i16> %{{[0-9]+}}, <8 x i16> %{{[0-9]+}}, <8 x i32> <i32 3, i32 2, i32 1, i32 0, i32 7, i32 6, i32 5, i32 4>
+  // CHECK-LE: call void @llvm.ppc.vsx.stxvd2x.be(<2 x double> %{{[0-9]+}}, i8* %{{[0-9]+}})
+
+  vec_xst_be(vsi, sll, asi);
+  // CHECK: store <4 x i32> %{{[0-9]+}}, <4 x i32>* %{{[0-9]+}}, align 16
+  // CHECK-LE: call void @llvm.ppc.vsx.stxvw4x.be(<4 x i32> %{{[0-9]+}}, i8* %{{[0-9]+}})
+
+  vec_xst_be(vui, sll, aui);
+  // CHECK: store <4 x i32> %{{[0-9]+}}, <4 x i32>* %{{[0-9]+}}, align 16
+  // CHECK-LE: call void @llvm.ppc.vsx.stxvw4x.be(<4 x i32> %{{[0-9]+}}, i8* %{{[0-9]+}})
 
   vec_xst_be(vsll, sll, asll);
   // CHECK: store <2 x i64> %{{[0-9]+}}, <2 x i64>* %{{[0-9]+}}, align 16
   // CHECK-LE: call void @llvm.ppc.vsx.stxvd2x.be(<2 x double> %{{[0-9]+}}, i8* %{{[0-9]+}})
 
   vec_xst_be(vull, sll, aull);
   // CHECK: store <2 x i64> %{{[0-9]+}}, <2 x i64>* %{{[0-9]+}}, align 16
   // CHECK-LE: call void @llvm.ppc.vsx.stxvd2x.be(<2 x double> %{{[0-9]+}}, i8* %{{[0-9]+}})
 
+  vec_xst_be(vf, sll, af);
+  // CHECK: store <4 x float> %{{[0-9]+}}, <4 x float>* %{{[0-9]+}}, align 16
+  // CHECK-LE: call void @llvm.ppc.vsx.stxvw4x.be(<4 x i32> %{{[0-9]+}}, i8* %{{[0-9]+}})
+
   vec_xst_be(vd, sll, ad);
   // CHECK: store <2 x double> %{{[0-9]+}}, <2 x double>* %{{[0-9]+}}, align 16
   // CHECK-LE: call void @llvm.ppc.vsx.stxvd2x.be(<2 x double> %{{[0-9]+}}, i8* %{{[0-9]+}})
-
-  res_vf = vec_neg(vf);
-// CHECK: fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, {{%[0-9]+}}
-// CHECK-LE: fsub <4 x float> <float -0.000000e+00, float -0.000000e+00, float -0.000000e+00, float -0.000000e+00>, {{%[0-9]+}}
-
-  res_vd = vec_neg(vd);
-// CHECK: fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, {{%[0-9]+}}
-// CHECK-LE: fsub <2 x double> <double -0.000000e+00, double -0.000000e+00>, {{%[0-9]+}}
 }