OpenCL: Extend argument promotion rules to vector types

[arsenm]

Summary

The spec is ambiguous on whether vector types are allowed to be
implicitly converted. The only legal context I think this can
be used for OpenCL is printf, where it seems necessary.

[Anastasia]

The spec is ambiguous on whether vector types are allowed to be
implicitly converted. The only legal context I think this can
be used for OpenCL is printf, where it seems necessary.

s6.2.1, seems to say "Implicit conversions between built-in vector data types are disallowed." though. But considering that we disallow functions without a prototype. It should be fine.

However, is there any way to construct a test for this? Could it be tested similarly to https://reviews.llvm.org/D55023?

[arsenm]

Add codegen test

[Anastasia]

LGTM! Apart from the test can be changed.

test/CodeGenOpenCL/printf.cl

2

I would prefer to test this with spir target since it's not AMD specific. We can use pragma extension enable/disable. :)

[arsenm]

r348083

lib/Sema/SemaExpr.cpp

ExprResult Sema::DefaultArgumentPromotion(Expr *E) {
   QualType Ty = E->getType();
   assert(!Ty.isNull() && "DefaultArgumentPromotion - missing type");
 
   ExprResult Res = UsualUnaryConversions(E);
   if (Res.isInvalid())
     return ExprError();
   E = Res.get();
 
+  QualType ScalarTy = Ty;
+  unsigned NumElts = 0;
+  if (const ExtVectorType *VecTy = Ty->getAs<ExtVectorType>()) {
+    NumElts = VecTy->getNumElements();
+    ScalarTy = VecTy->getElementType();
+  }
+
   // If this is a 'float'  or '__fp16' (CVR qualified or typedef)
   // promote to double.
   // Note that default argument promotion applies only to float (and
   // half/fp16); it does not apply to _Float16.
-  const BuiltinType *BTy = Ty->getAs<BuiltinType>();
+  const BuiltinType *BTy = ScalarTy->getAs<BuiltinType>();
   if (BTy && (BTy->getKind() == BuiltinType::Half ||
               BTy->getKind() == BuiltinType::Float)) {
     if (getLangOpts().OpenCL &&
         !getOpenCLOptions().isEnabled("cl_khr_fp64")) {
-        if (BTy->getKind() == BuiltinType::Half) {
-            E = ImpCastExprToType(E, Context.FloatTy, CK_FloatingCast).get();
-        }
+        QualType Ty = Context.FloatTy;
+        if (NumElts != 0)
+          Ty = Context.getExtVectorType(Ty, NumElts);
+        E = ImpCastExprToType(E, Ty, CK_FloatingCast).get();
     } else {
-      E = ImpCastExprToType(E, Context.DoubleTy, CK_FloatingCast).get();
+      QualType Ty = Context.DoubleTy;
+      if (NumElts != 0)
+        Ty = Context.getExtVectorType(Ty, NumElts);
+      E = ImpCastExprToType(E, Ty, CK_FloatingCast).get();
     }
   }
 
   // C++ performs lvalue-to-rvalue conversion as a default argument
   // promotion, even on class types, but note:
   //   C++11 [conv.lval]p2:
   //     When an lvalue-to-rvalue conversion occurs in an unevaluated
   //     operand or a subexpression thereof the value contained in the

test/CodeGenOpenCL/printf.cl

+// REQUIRES: amdgpu-registered-target
+// RUN: %clang_cc1 -cl-std=CL1.2 -triple amdgcn-unknown-unknown -disable-llvm-passes -emit-llvm -o - %s | FileCheck -check-prefixes=FP64,ALL %s
+// RUN: %clang_cc1 -cl-std=CL1.2 -triple r600-unknown-unknown -disable-llvm-passes -emit-llvm -o - %s | FileCheck -check-prefixes=NOFP64,ALL %s
+
+typedef __attribute__((ext_vector_type(2))) float float2;
+typedef __attribute__((ext_vector_type(2))) half half2;
+
+#ifdef cl_khr_fp64
+typedef __attribute__((ext_vector_type(2))) double double2;
+#endif
+
+int printf(__constant const char* st, ...) __attribute__((format(printf, 1, 2)));
+
+
+// ALL-LABEL: @test_printf_float2(
+// FP64: %conv = fpext <2 x float> %0 to <2 x double>
+// FP64: %call = call i32 (i8 addrspace(4)*, ...) @printf(i8 addrspace(4)* getelementptr inbounds ([5 x i8], [5 x i8] addrspace(4)* @.str, i32 0, i32 0), <2 x double> %conv)
+
+// NOFP64:  call i32 (i8 addrspace(4)*, ...) @printf(i8 addrspace(4)* getelementptr inbounds ([5 x i8], [5 x i8] addrspace(4)* @.str, i32 0, i32 0), <2 x float> %0)
+kernel void test_printf_float2(float2 arg) {
+  printf("%v2f", arg);
+}
+
+// ALL-LABEL: @test_printf_half2(
+// FP64: %conv = fpext <2 x half> %0 to <2 x double>
+// FP64:  %call = call i32 (i8 addrspace(4)*, ...) @printf(i8 addrspace(4)* getelementptr inbounds ([5 x i8], [5 x i8] addrspace(4)* @.str, i32 0, i32 0), <2 x double> %conv) #2
+
+// NOFP64: %conv = fpext <2 x half> %0 to <2 x float>
+// NOFP64:  %call = call i32 (i8 addrspace(4)*, ...) @printf(i8 addrspace(4)* getelementptr inbounds ([5 x i8], [5 x i8] addrspace(4)* @.str, i32 0, i32 0), <2 x float> %conv) #2
+kernel void test_printf_half2(half2 arg) {
+  printf("%v2f", arg);
+}
+
+#ifdef cl_khr_fp64
+// FP64-LABEL: @test_printf_double2(
+// FP64: call i32 (i8 addrspace(4)*, ...) @printf(i8 addrspace(4)* getelementptr inbounds ([5 x i8], [5 x i8] addrspace(4)* @.str, i32 0, i32 0), <2 x double> %0) #2
+kernel void test_printf_double2(double2 arg) {
+  printf("%v2f", arg);
+}
+#endif