Fix floating point promotions for overload purposes

[t.p.northover]

Summary

This has a couple of changes to how Clang determines whether a floating-point promotion has occurred for C++ (and __attribute__((overloadable))) purposes.

First, I think the special rules for C are based on a misconception. C99 referred to promotions to "long double" but it actually meant conversions, and the only real promotions that happened were the "float -> double" default argument promotion for varargs (and obviously nothing to do with overload resolution). C11 fixed this wording to remove all mention of promotions. So this patch makes all overload resolution follow C++ rules, which seems like the least surprising behaviour for attribute((overloadable)).

Second, this allows "half -> double" promotion unconditionally. Since half is a non-standard type there's a bit of guesswork here, but it seems like the most consistent extension of C++'s wording to that type (with special mention going to allowing "half -> float" too). It definitely seems reasonable that the decision should not depend on NativeHalfTypes.

Does the change look reasonable to others?

clang/lib/Sema/SemaOverload.cpp

for (const auto *it : UD->fields()) {
     }
   }
   return false;
 }
 
 /// IsIntegralPromotion - Determines whether the conversion from the
 /// expression From (whose potentially-adjusted type is FromType) to
 /// ToType is an integral promotion (C++ 4.5). If so, returns true and
-/// sets PromotedType to the promoted type.
+/// sets From to the promoted type.
 bool Sema::IsIntegralPromotion(Expr *From, QualType FromType, QualType ToType) {
   const BuiltinType *To = ToType->getAs<BuiltinType>();
   // All integers are built-in.
   if (!To) {
     return false;
   }
 
   // An rvalue of type char, signed char, unsigned char, short int, or
if (FromType->isBooleanType() && To->getKind() == BuiltinType::Int) {
     return true;
   }
 
   return false;
 }
 
 /// IsFloatingPointPromotion - Determines whether the conversion from
 /// FromType to ToType is a floating point promotion (C++ 4.6). If so,
-/// returns true and sets PromotedType to the promoted type.
+/// returns true.
 bool Sema::IsFloatingPointPromotion(QualType FromType, QualType ToType) {
   if (const BuiltinType *FromBuiltin = FromType->getAs<BuiltinType>())
     if (const BuiltinType *ToBuiltin = ToType->getAs<BuiltinType>()) {
       /// An rvalue of type float can be converted to an rvalue of type
       /// double. (C++ 4.6p1).
       if (FromBuiltin->getKind() == BuiltinType::Float &&
           ToBuiltin->getKind() == BuiltinType::Double)
         return true;
 
-      // C99 6.3.1.5p1:
-      //   When a float is promoted to double or long double, or a
-      //   double is promoted to long double [...].
-      if (!getLangOpts().CPlusPlus &&
-          (FromBuiltin->getKind() == BuiltinType::Float ||
-           FromBuiltin->getKind() == BuiltinType::Double) &&
-          (ToBuiltin->getKind() == BuiltinType::LongDouble ||
-           ToBuiltin->getKind() == BuiltinType::Float128))
-        return true;
-
-      // Half can be promoted to float.
-      if (!getLangOpts().NativeHalfType &&
-           FromBuiltin->getKind() == BuiltinType::Half &&
-          ToBuiltin->getKind() == BuiltinType::Float)
+      /// Behave as if C++ 4.6 was modified by:
+      /// - Inserting a paragraph:
+      ///     "A prvalue of type half can be converted to a prvalue of type
+      ///      double. The value is unchanged."
+      /// - Updating paragraph 2 to:
+      ///     "These conversions are called floating point promotions."
+      if (FromBuiltin->getKind() == BuiltinType::Half &&
+          ToBuiltin->getKind() == BuiltinType::Double)
         return true;
     }
 
   return false;
 }
 
 /// \brief Determine if a conversion is a complex promotion.
 ///

clang/test/CodeGenCXX/fp16-overload.cpp

 // RUN: %clang_cc1 -emit-llvm -o - -triple arm-none-linux-gnueabi %s | FileCheck %s
+// RUN: %clang_cc1 -DWITH_AMBIGUOUS -verify %s
+// RUN: %clang_cc1 -DWITH_AMBIGUOUS -fnative-half-type -fallow-half-arguments-and-returns -verify %s
 
-extern int foo(float x);
-extern int foo(double x);
+typedef __fp16 half;
+half x;
 
-__fp16 a;
+void half_to_float_or_double(float x);
+void half_to_float_or_double(double x);
 
-// CHECK: call i32 @_Z3foof
-// CHECK-NOT: call i32 @_Z3food
-int bar (void) { return foo(a); }
+// CHECK:     call void @_Z23half_to_float_or_doubled
+// CHECK-NOT: call void @_Z23half_to_float_or_doublef
+void test1() {
+  half_to_float_or_double(x);
+}
+
+extern void half_to_int_or_double(int x);
+extern void half_to_int_or_double(double x);
+
+// CHECK:     call void @_Z21half_to_int_or_doubled
+// CHECK-NOT: call void @_Z21half_to_int_or_doublei
+void test2() {
+  half_to_int_or_double(x);
+}
+
+#ifdef WITH_AMBIGUOUS
+extern void half_to_int_or_float(int x);    // expected-note {{candidate function}}
+extern void half_to_int_or_float(float x);  // expected-note {{candidate function}}
+
+void test3() {
+  half_to_int_or_float(x);  // expected-error {{call to 'half_to_int_or_float' is ambiguous}}
+}
+#endif

clang/test/Sema/overloadable-complex.c

 
 void test_foo_3(float fv, double dv, float _Complex fc, double _Complex dc) {
   char *cp1 = foo(fv);
   char *cp2 = foo(dv);
   int *ip = foo(fc);
   long *lp = foo(dc);
 }
 
-char *promote_or_convert(double _Complex) __attribute__((__overloadable__));  // expected-note 2 {{candidate function}}
-int *promote_or_convert(long double _Complex) __attribute__((__overloadable__)); // expected-note 2 {{candidate function}} 
+char *promote_or_convert(double _Complex) __attribute__((__overloadable__));  // expected-note {{candidate function}}
+int *promote_or_convert(long double _Complex) __attribute__((__overloadable__));  // expected-note {{candidate function}}
 
 void test_promote_or_convert(float f, float _Complex fc) {
-  char *cp = promote_or_convert(fc); // expected-error{{call to 'promote_or_convert' is ambiguous}}
-  int *ip2 = promote_or_convert(f); // expected-error{{call to 'promote_or_convert' is ambiguous}}
+  char *cp = promote_or_convert(fc);
+  char *ip2 = promote_or_convert(f);  // expected-error{{call to 'promote_or_convert' is ambiguous}}
 }
 
 char *promote_or_convert2(float) __attribute__((__overloadable__));
 int *promote_or_convert2(double _Complex) __attribute__((__overloadable__));
 
 void test_promote_or_convert2(float _Complex fc) {
   int *cp = promote_or_convert2(fc);
 }
 
 char *promote_or_convert3(int _Complex) __attribute__((__overloadable__));
 int *promote_or_convert3(long _Complex) __attribute__((__overloadable__));
 
 void test_promote_or_convert3(short _Complex sc) {
   char *cp = promote_or_convert3(sc);
 }
+
+char *promote_or_convert4(float _Complex) __attribute__((__overloadable__));  // expected-note 2 {{candidate function}}
+int *promote_or_convert4(long double _Complex) __attribute__((__overloadable__));  // expected-note 2 {{candidate function}}
+
+void test_promote_or_convert4(double d, double _Complex dc) {
+  char *cp = promote_or_convert4(dc);  // expected-error{{call to 'promote_or_convert4' is ambiguous}}
+  int *ip2 = promote_or_convert4(d);  // expected-error{{call to 'promote_or_convert4' is ambiguous}}
+}

clang/test/SemaCXX/floating-point-promotion.cpp

+// RUN: %clang_cc1 -fsyntax-only -fallow-half-arguments-and-returns -verify %s
+// RUN: %clang_cc1 -fsyntax-only -fallow-half-arguments-and-returns -fnative-half-type -verify %s
+
+#include <stdint.h>
+
+typedef __fp16 half;
+
+// [e-mail]:* 1+ {{candidate function}}
+
+extern void half_to_int_or_float(int x);
+extern void half_to_int_or_float(float x);
+void test1(half h) {
+  half_to_int_or_float(h);  // expected-error {{call to 'half_to_int_or_float' is ambiguous}}
+}
+
+extern void half_to_int_or_double(int x);
+extern void half_to_int_or_double(double x);
+void test2(half h) {
+  half_to_int_or_double(h);
+}
+
+extern void half_to_int_or_long_double(int x);
+extern void half_to_int_or_long_double(long double x);
+void test3(half h) {
+  half_to_int_or_long_double(h);  // expected-error {{call to 'half_to_int_or_long_double' is ambiguous}}
+}
+
+extern void half_to_float_or_double(float x);
+extern void half_to_float_or_double(double x);
+void test4(half h) {
+  half_to_float_or_double(h);
+}
+
+extern void half_to_float_or_long_double(float x);
+extern void half_to_float_or_long_double(long double x);
+void test5(half h) {
+  half_to_float_or_long_double(h);  // expected-error {{call to 'half_to_float_or_long_double' is ambiguous}}
+}
+
+extern void float_to_int_or_half(int x);
+extern void float_to_int_or_half(half x);
+void test6(float f) {
+  float_to_int_or_half(f);  // expected-error {{call to 'float_to_int_or_half' is ambiguous}}
+}
+
+extern void float_to_int_or_double(int x);
+extern void float_to_int_or_double(double x);
+void test7(float f) {
+  float_to_int_or_double(f);
+}
+
+extern void float_to_int_or_long_double(int x);
+extern void float_to_int_or_long_double(long double x);
+void test8(float f) {
+  float_to_int_or_long_double(f);  // expected-error {{call to 'float_to_int_or_long_double' is ambiguous}}
+}
+
+extern void float_to_half_or_double(half x);
+extern void float_to_half_or_double(double x);
+void test9(float f) {
+  float_to_half_or_double(f);
+}
+
+extern void float_to_half_or_long_double(half x);
+extern void float_to_half_or_long_double(long double x);
+void test10(float f) {
+  float_to_half_or_long_double(f);  // expected-error {{call to 'float_to_half_or_long_double' is ambiguous}}
+}
+
+extern void double_to_int_or_half(int x);
+extern void double_to_int_or_half(half x);
+void test11(double d) {
+  double_to_int_or_half(d);  // expected-error {{call to 'double_to_int_or_half' is ambiguous}}
+}
+
+extern void double_to_int_or_float(int x);
+extern void double_to_int_or_float(float x);
+void test12(double d) {
+  double_to_int_or_float(d);  // expected-error {{call to 'double_to_int_or_float' is ambiguous}}
+}
+
+extern void double_to_int_or_long_double(int x);
+extern void double_to_int_or_long_double(long double x);
+void test13(double d) {
+  double_to_int_or_long_double(d);  // expected-error {{call to 'double_to_int_or_long_double' is ambiguous}}
+}
+
+extern void double_to_half_or_float(half x);
+extern void double_to_half_or_float(float x);
+void test14(double d) {
+  double_to_half_or_float(d);  // expected-error {{call to 'double_to_half_or_float' is ambiguous}}
+}
+
+extern void double_to_half_or_long_double(half x);
+extern void double_to_half_or_long_double(long double x);
+void test15(double d) {
+  double_to_half_or_long_double(d);  // expected-error {{call to 'double_to_half_or_long_double' is ambiguous}}
+}
+
+extern void long_double_to_half_or_float(half x);
+extern void long_double_to_half_or_float(float x);
+void test16(long double ld) {
+  double_to_half_or_float(ld);  // expected-error {{call to 'double_to_half_or_float' is ambiguous}}
+}
+
+extern void long_double_to_float_or_double(float x);
+extern void long_double_to_float_or_double(double x);
+void test17(long double ld) {
+  long_double_to_float_or_double(ld);  // expected-error {{call to 'long_double_to_float_or_double' is ambiguous}}
+}