[PowerPC] Remove the lax warning for explicit casts

[maryammo]

Summary

This patch is to remove the erroneous lax vector conversion warning for CStyle; explicit; casts
that was added as part of D126540.

[nemanjai]

LGTM other than the missing template test.

clang/test/Parser/lax-conv.cpp

5

Can you also add one template test?

template <typename VEC> VEC __attribute__((noinline)) test(vector unsigned char a, vector unsigned char b) {
  return (VEC)(a * b);
}

vector unsigned char test1(vector unsigned char a, vector unsigned char b) {
  return test<vector unsigned char>(a, b);
}

vector unsigned long long test2(vector unsigned char a, vector unsigned char b) {
  return test<vector unsigned long long>(a, b);
}

[maryammo]

Adding test for template

clang/lib/Sema/SemaOverload.cpp

 
 /// Determine whether the conversion from FromType to ToType is a valid
 /// vector conversion.
 ///
 /// \param ICK Will be set to the vector conversion kind, if this is a vector
 /// conversion.
 static bool IsVectorConversion(Sema &S, QualType FromType, QualType ToType,
                                ImplicitConversionKind &ICK, Expr *From,
-                               bool InOverloadResolution) {
+                               bool InOverloadResolution, bool CStyle) {
   // We need at least one of these types to be a vector type to have a vector
   // conversion.
   if (!ToType->isVectorType() && !FromType->isVectorType())
     return false;
 
   // Identical types require no conversions.
   if (S.Context.hasSameUnqualifiedType(FromType, ToType))
     return false;
static bool IsVectorConversion(Sema &S, QualType FromType, QualType ToType,
   //   only
   if (ToType->isVectorType() && FromType->isVectorType()) {
     if (S.Context.areCompatibleVectorTypes(FromType, ToType) ||
         (S.isLaxVectorConversion(FromType, ToType) &&
          !ToType->hasAttr(attr::ArmMveStrictPolymorphism))) {
       if (S.isLaxVectorConversion(FromType, ToType) &&
           S.anyAltivecTypes(FromType, ToType) &&
           !S.areSameVectorElemTypes(FromType, ToType) &&
-          !InOverloadResolution) {
+          !InOverloadResolution && !CStyle) {
         S.Diag(From->getBeginLoc(), diag::warn_deprecated_lax_vec_conv_all)
             << FromType << ToType;
       }
       ICK = ICK_Vector_Conversion;
       return true;
     }
   }
 
if (S.Context.hasSameUnqualifiedType(FromType, ToType)) {
     SCS.Second = ICK_Pointer_Conversion;
     SCS.IncompatibleObjC = IncompatibleObjC;
     FromType = FromType.getUnqualifiedType();
   } else if (S.IsMemberPointerConversion(From, FromType, ToType,
                                          InOverloadResolution, FromType)) {
     // Pointer to member conversions (4.11).
     SCS.Second = ICK_Pointer_Member;
   } else if (IsVectorConversion(S, FromType, ToType, SecondICK, From,
-                                InOverloadResolution)) {
+                                InOverloadResolution, CStyle)) {
     SCS.Second = SecondICK;
     FromType = ToType.getUnqualifiedType();
   } else if (!S.getLangOpts().CPlusPlus &&
              S.Context.typesAreCompatible(ToType, FromType)) {
     // Compatible conversions (Clang extension for C function overloading)
     SCS.Second = ICK_Compatible_Conversion;
     FromType = ToType.getUnqualifiedType();
   } else if (IsTransparentUnionStandardConversion(S, From, ToType,

clang/test/Parser/cxx-altivec.cpp

-// RUN: %clang_cc1 -triple=powerpc-apple-darwin8 -Wno-deprecate-lax-vec-conv-all -target-feature +altivec -fsyntax-only -verify=expected,novsx -std=c++11 %s
-// RUN: %clang_cc1 -triple=powerpc64-unknown-linux-gnu -Wno-deprecate-lax-vec-conv-all -target-feature +altivec -target-feature +vsx -fsyntax-only -verify=expected,nonaix -std=c++11 %s
-// RUN: %clang_cc1 -triple=powerpc64le-unknown-linux-gnu -Wno-deprecate-lax-vec-conv-all -target-feature +altivec -fsyntax-only -verify=expected,novsx -std=c++11 %s
-// RUN: %clang_cc1 -triple=powerpc64-unknown-linux-gnu -Wno-deprecate-lax-vec-conv-all -target-feature +vsx -target-cpu pwr7 -fsyntax-only -verify=expected,nonaix -std=c++11 %s
-// RUN: %clang_cc1 -triple=powerpc64le-unknown-linux-gnu -Wno-deprecate-lax-vec-conv-all -target-feature -vsx -target-cpu pwr7 -fsyntax-only -verify=expected,novsx -std=c++11 %s
-// RUN: %clang_cc1 -triple=powerpc-ibm-aix -Wno-deprecate-lax-vec-conv-all -target-feature +altivec -fsyntax-only -verify=expected,aix -std=c++11 %s
-// RUN: %clang_cc1 -triple=powerpc64-ibm-aix -Wno-deprecate-lax-vec-conv-all -target-feature +altivec -fsyntax-only -verify=expected,aix -std=c++11 %s
+// RUN: %clang_cc1 -triple=powerpc-apple-darwin8 -target-feature +altivec -fsyntax-only -verify=expected,novsx -std=c++11 %s
+// RUN: %clang_cc1 -triple=powerpc64-unknown-linux-gnu -target-feature +altivec -target-feature +vsx -fsyntax-only -verify=expected,nonaix -std=c++11 %s
+// RUN: %clang_cc1 -triple=powerpc64le-unknown-linux-gnu -target-feature +altivec -fsyntax-only -verify=expected,novsx -std=c++11 %s
+// RUN: %clang_cc1 -triple=powerpc64-unknown-linux-gnu -target-feature +vsx -target-cpu pwr7 -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,novsx -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  short vv_ss;
 __vector unsigned  short vv_us;

clang/test/Parser/lax-conv.cpp

+// RUN: %clang_cc1 -triple=powerpc64-unknown-linux-gnu -target-feature +altivec -target-feature +vsx -target-cpu pwr8 -fsyntax-only -verify=expected,nonaix %s
+// RUN: %clang_cc1 -triple=powerpc64le-unknown-linux-gnu -target-feature +altivec -target-feature +vsx -target-cpu pwr8 -fsyntax-only -verify=expected,novsx %s
+// RUN: %clang_cc1 -triple=powerpc64-ibm-aix -target-feature +altivec -target-feature +vsx -target-cpu pwr8 -fsyntax-only -verify=expected,aix %s
+
+void dummy(vector unsigned int a);
+template <typename VEC> VEC __attribute__((noinline)) test(vector unsigned char a, vector unsigned char b) {
+    return (VEC)(a * b);
+}
+vector unsigned int test1(vector unsigned char RetImplicitConv) {
+  return RetImplicitConv; // expected-warning {{Implicit conversion between vector types (''__vector unsigned char' (vector of 16 'unsigned char' values)' and ''__vector unsigned int' (vector of 4 'unsigned int' values)') is deprecated. In the future, the behavior implied by '-fno-lax-vector-conversions' will be the default.}} 
+}
+vector unsigned int test2(vector unsigned char RetImplicitConvAddConst) {
+  return RetImplicitConvAddConst + 5; // expected-warning {{Implicit conversion between vector types (''__vector unsigned char' (vector of 16 'unsigned char' values)' and ''__vector unsigned int' (vector of 4 'unsigned int' values)') is deprecated. In the future, the behavior implied by '-fno-lax-vector-conversions' will be the default.}} 
+}
+vector unsigned int test3(vector unsigned char RetExplicitConv) {
+  return (vector unsigned int)RetExplicitConv;
+}
+vector unsigned int test4(vector unsigned char RetExplicitConvAddConst) {
+  return (vector unsigned int)RetExplicitConvAddConst + 5;
+}
+vector unsigned int test5(vector unsigned char RetImplicitConvAddSame1,
+                          vector unsigned char RetImplicitConvAddSame2) {
+  return RetImplicitConvAddSame1 + RetImplicitConvAddSame2; // expected-warning {{Implicit conversion between vector types (''__vector unsigned char' (vector of 16 'unsigned char' values)' and ''__vector unsigned int' (vector of 4 'unsigned int' values)') is deprecated. In the future, the behavior implied by '-fno-lax-vector-conversions' will be the default.}} 
+}
+vector unsigned int test6(vector unsigned char RetExplicitConvAddSame1,
+                          vector unsigned char RetExplicitConvAddSame2) {
+  return (vector unsigned int)RetExplicitConvAddSame1 +
+         (vector unsigned int)RetExplicitConvAddSame2;
+}
+vector unsigned int test7(vector unsigned char RetExplicitConvAddSame1Full,
+                          vector unsigned char RetExplicitConvAddSame2Full) {
+  return (vector unsigned int)(RetExplicitConvAddSame1Full +
+                               RetExplicitConvAddSame2Full);
+}
+vector unsigned char test8(vector unsigned char a, vector unsigned char b) {
+    return test<vector unsigned char>(a, b);
+}
+
+vector unsigned long long test9(vector unsigned char a, vector unsigned char b) {
+    return test<vector unsigned long long>(a, b);
+}
+void test1a(vector unsigned char ArgImplicitConv) {
+  return dummy(ArgImplicitConv); // expected-warning {{Implicit conversion between vector types (''__vector unsigned char' (vector of 16 'unsigned char' values)' and ''__vector unsigned int' (vector of 4 'unsigned int' values)') is deprecated. In the future, the behavior implied by '-fno-lax-vector-conversions' will be the default.}}
+}
+void test2a(vector unsigned char ArgImplicitConvAddConst) {
+  return dummy(ArgImplicitConvAddConst + 5); // expected-warning {{Implicit conversion between vector types (''__vector unsigned char' (vector of 16 'unsigned char' values)' and ''__vector unsigned int' (vector of 4 'unsigned int' values)') is deprecated. In the future, the behavior implied by '-fno-lax-vector-conversions' will be the default.}}
+}
+void test3a(vector unsigned char ArgExplicitConv) {
+  return dummy((vector unsigned int)ArgExplicitConv);
+}
+void test4a(vector unsigned char ArgExplicitConvAddConst) {
+  return dummy((vector unsigned int)ArgExplicitConvAddConst + 5);
+}
+void test5a(vector unsigned char ArgImplicitConvAddSame1,
+            vector unsigned char ArgImplicitConvAddSame2) {
+  return dummy(ArgImplicitConvAddSame1 + ArgImplicitConvAddSame2); // expected-warning {{Implicit conversion between vector types (''__vector unsigned char' (vector of 16 'unsigned char' values)' and ''__vector unsigned int' (vector of 4 'unsigned int' values)') is deprecated. In the future, the behavior implied by '-fno-lax-vector-conversions' will be the default.}}
+}
+void test6a(vector unsigned char ArgExplicitConvAddSame1,
+            vector unsigned char ArgExplicitConvAddSame2) {
+  return dummy((vector unsigned int)ArgExplicitConvAddSame1 +
+               (vector unsigned int)ArgExplicitConvAddSame2);
+}
+void test7a(vector unsigned char ArgExplicitConvAddSame1Full,
+            vector unsigned char ArgExplicitConvAddSame2Full) {
+  return dummy((vector unsigned int)(ArgExplicitConvAddSame1Full +
+                                     ArgExplicitConvAddSame2Full));
+}