[OpenCL] Added implicit conversion rank for overloading functions with vector data type in OpenCL

[echuraev]

Summary

I added a new rank to ImplicitConversionRank enum to resolve the function overload ambiguity with vector types. Rank of scalar types conversion is lower than vector splat. So, we can choose which function should we call. See test for more details.

[Anastasia]

test/SemaOpenCL/overload-scalar-widening.cl

4 ↗

(On Diff #91308)

I am thinking could this be a CodeGen test instead and we could check that the right overload is selected based on mangled name?

I think in this case it would be good to unify with test/SemaOpenCL/overload_addrspace_resolution.cl which has similar purpose. Also I think CodeGenOpenCL would be a better place for it. :)

[bader]

test/SemaOpenCL/overload_addrspace_resolution.cl

1

Egor, I think you forgot to move the test to CodeGenOpenCL directory.

[Anastasia]

test/SemaOpenCL/overload_addrspace_resolution.cl

1

Yes, I think we can also rename it to something more generic like overload.cl.

It would also be nice to start every separate testing section with a comment. Like here could be:

1. Checking address space resolution
2. Checking vector vs scalar resolution

[Anastasia]

LGTM! Thanks!

include/clang/Sema/Overload.h

namespace clang {
   /// ImplicitConversionRank - The rank of an implicit conversion
   /// kind. The enumerator values match with Table 9 of (C++
   /// 13.3.3.1.1) and are listed such that better conversion ranks
   /// have smaller values.
   enum ImplicitConversionRank {
     ICR_Exact_Match = 0,         ///< Exact Match
     ICR_Promotion,               ///< Promotion
     ICR_Conversion,              ///< Conversion
+    ICR_OCL_Scalar_Widening,     ///< OpenCL Scalar Widening
     ICR_Complex_Real_Conversion, ///< Complex <-> Real conversion
     ICR_Writeback_Conversion,    ///< ObjC ARC writeback conversion
     ICR_C_Conversion,            ///< Conversion only allowed in the C standard.
                                  ///  (e.g. void* to char*)
     ICR_C_Conversion_Extension   ///< Conversion not allowed by the C standard,
                                  ///  but that we accept as an extension anyway.
   };
 

lib/Sema/SemaOverload.cpp

static const ImplicitConversionRank
     ICR_Conversion,
     ICR_Conversion,
     ICR_Conversion,
     ICR_Conversion,
     ICR_Conversion,
     ICR_Conversion,
     ICR_Conversion,
     ICR_Conversion,
-    ICR_Conversion,
+    ICR_OCL_Scalar_Widening,
     ICR_Complex_Real_Conversion,
     ICR_Conversion,
     ICR_Conversion,
     ICR_Writeback_Conversion,
     ICR_Exact_Match, // NOTE(gbiv): This may not be completely right --
                      // it was omitted by the patch that added
                      // ICK_Zero_Event_Conversion
     ICR_C_Conversion,

test/SemaOpenCL/overload_addrspace_resolution.cl

-// RUN: %clang_cc1 -cl-std=CL2.0 -emit-llvm -o - -triple x86_64-unknown-unknown %s | FileCheck %s
+// RUN: %clang_cc1 -cl-std=CL2.0 -emit-llvm -o - -triple spir-unknown-unknown %s | FileCheck %s
 
+typedef short short4 __attribute__((ext_vector_type(4)));
+
+// CHECK-DAG: declare spir_func <4 x i16> @_Z5clampDv4_sS_S_(<4 x i16>, <4 x i16>, <4 x i16>)
+short4 __attribute__ ((overloadable)) clamp(short4 x, short4 minval, short4 maxval);
+// CHECK-DAG: declare spir_func <4 x i16> @_Z5clampDv4_sss(<4 x i16>, i16 signext, i16 signext)
+short4 __attribute__ ((overloadable)) clamp(short4 x, short minval, short maxval);
 void __attribute__((overloadable)) foo(global int *a, global int *b);
 void __attribute__((overloadable)) foo(generic int *a, generic int *b);
 void __attribute__((overloadable)) bar(generic int *global *a, generic int *global *b);
 void __attribute__((overloadable)) bar(generic int *generic *a, generic int *generic *b);
 
 void kernel ker() {
   global int *a;
   global int *b;
   generic int *c;
   local int *d;
+  short4 e0=0;
   generic int *generic *gengen;
   generic int *local *genloc;
   generic int *global *genglob;
-  // CHECK: call void @_Z3fooPU8CLglobaliS0_(i32* undef, i32* undef)
+  // CHECK-DAG: call spir_func void @_Z3fooPU3AS1iS0_(i32 addrspace(1)* undef, i32 addrspace(1)* undef)
   foo(a, b);
-  // CHECK: call void @_Z3fooPU9CLgenericiS0_(i32* undef, i32* undef)
+  // CHECK-DAG: call spir_func void @_Z3fooPU3AS4iS0_(i32 addrspace(4)* undef, i32 addrspace(4)* undef)
   foo(b, c);
-  // CHECK: call void @_Z3fooPU9CLgenericiS0_(i32* undef, i32* undef)
+  // CHECK-DAG: call spir_func void @_Z3fooPU3AS4iS0_(i32 addrspace(4)* undef, i32 addrspace(4)* undef)
   foo(a, d);
 
-  // CHECK: call void @_Z3barPU9CLgenericPU9CLgenericiS2_(i32** undef, i32** undef)
+  // CHECK-DAG: call spir_func void @_Z3barPU3AS4PU3AS4iS2_(i32 addrspace(4)* addrspace(4)* undef, i32 addrspace(4)* addrspace(4)* undef)
   bar(gengen, genloc);
-  // CHECK: call void @_Z3barPU9CLgenericPU9CLgenericiS2_(i32** undef, i32** undef)
+  // CHECK-DAG: call spir_func void @_Z3barPU3AS4PU3AS4iS2_(i32 addrspace(4)* addrspace(4)* undef, i32 addrspace(4)* addrspace(4)* undef)
   bar(gengen, genglob);
-  // CHECK: call void @_Z3barPU8CLglobalPU9CLgenericiS2_(i32** undef, i32** undef)
+  // CHECK-DAG: call spir_func void @_Z3barPU3AS1PU3AS4iS2_(i32 addrspace(4)* addrspace(1)* undef, i32 addrspace(4)* addrspace(1)* undef)
   bar(genglob, genglob);
+  // CHECK-DAG: call spir_func <4 x i16> @_Z5clampDv4_sss(<4 x i16> zeroinitializer, i16 signext 0, i16 signext 255)
+  clamp(e0, 0, 255);
+  // CHECK-DAG: call spir_func <4 x i16> @_Z5clampDv4_sS_S_(<4 x i16> zeroinitializer, <4 x i16> zeroinitializer, <4 x i16> zeroinitializer)
+  clamp(e0, e0, e0);
 }