Support _Float128 and F128 literal in C mode

[MaskRay]

Summary

This adds F128 literal on top of D40673.

Note: rC321948 added some __builtin_*f128 functions.

[hubert.reinterpretcast]

Are we sure this is wise? We know that any future standard C++ type can't be the same as __float128 (without changing the latter) because __float128 mangles the same as 128-bit long double. So by making __float128 the same as _Float128 in C, we're causing the relationship between __float128 and the "corresponding" standard types to differ between C and C++.

I know GCC went in the direction that has this complication. Do we know whether they figured their way out?

[MaskRay]

This is to make more glibc files compilable with Clang. (@zatrazz)

In D111382#3052514, @hubert.reinterpretcast wrote:

Are we sure this is wise? We know that any future standard C++ type can't be the same as __float128 (without changing the latter) because __float128 mangles the same as 128-bit long double. So by making __float128 the same as _Float128 in C, we're causing the relationship between __float128 and the "corresponding" standard types to differ between C and C++.

No, but it's hard to change now. Introducing a GCC incompatible scheme probably does more harm than being compatible with them now...

I know GCC went in the direction that has this complication. Do we know whether they figured their way out?

clang/include/clang/Basic/TokenKinds.def

 KEYWORD(__builtin_COLUMN            , KEYALL)
 
 // __builtin_types_compatible_p is a GNU C extension that we handle like a C++
 // type trait.
 TYPE_TRAIT_2(__builtin_types_compatible_p, TypeCompatible, KEYNOCXX)
 KEYWORD(__builtin_va_arg            , KEYALL)
 KEYWORD(__extension__               , KEYALL)
 KEYWORD(__float128                  , KEYALL)
+ALIAS("_Float128", __float128       , KEYNOCXX)
 KEYWORD(__ibm128                    , KEYALL)
 KEYWORD(__imag                      , KEYALL)
 KEYWORD(__int128                    , KEYALL)
 KEYWORD(__label__                   , KEYALL)
 KEYWORD(__real                      , KEYALL)
 KEYWORD(__thread                    , KEYALL)
 KEYWORD(__FUNCTION__                , KEYALL)
 KEYWORD(__PRETTY_FUNCTION__         , KEYALL)

clang/lib/Frontend/InitPreprocessor.cpp

#undef TOSTR2
   DefineFmt("__UINTPTR", TI.getUIntPtrType(), TI, Builder);
   DefineTypeWidth("__UINTPTR_WIDTH__", TI.getUIntPtrType(), TI, Builder);
 
   if (TI.hasFloat16Type())
     DefineFloatMacros(Builder, "FLT16", &TI.getHalfFormat(), "F16");
   DefineFloatMacros(Builder, "FLT", &TI.getFloatFormat(), "F");
   DefineFloatMacros(Builder, "DBL", &TI.getDoubleFormat(), "");
   DefineFloatMacros(Builder, "LDBL", &TI.getLongDoubleFormat(), "L");
+  if (TI.hasFloat128Type())
+    DefineFloatMacros(Builder, "FLT128", &TI.getFloat128Format(), "F128");
 
   // Define a __POINTER_WIDTH__ macro for stdint.h.
   Builder.defineMacro("__POINTER_WIDTH__",
                       Twine((int)TI.getPointerWidth(0)));
 
   // Define __BIGGEST_ALIGNMENT__ to be compatible with gcc.
   Builder.defineMacro("__BIGGEST_ALIGNMENT__",
                       Twine(TI.getSuitableAlign() / TI.getCharWidth()) );

clang/lib/Lex/LiteralSupport.cpp

case 'F':
       // ToDo: more precise check for CUDA.
       if ((Target.hasFloat16Type() || LangOpts.CUDA) && s + 2 < ThisTokEnd &&
           s[1] == '1' && s[2] == '6') {
         s += 2; // success, eat up 2 characters.
         isFloat16 = true;
         continue;
       }
 
+      if (Target.hasFloat128Type() && s + 3 < ThisTokEnd &&
+          memcmp(s + 1, "128", 3) == 0) {
+        s += 3;
+        isFloat128 = true;
+        continue;
+      }
+
       isFloat = true;
       continue;  // Success.
     case 'q':    // FP Suffix for "__float128"
     case 'Q':
       if (!isFPConstant) break;  // Error for integer constant.
       if (HasSize)
         break;
       HasSize = true;

clang/test/CodeGen/builtins-ppc-p9-f128.c

 // RUN: %clang_cc1 -triple powerpc64le-unknown-linux-gnu -emit-llvm \
 // RUN:   -target-cpu pwr9 -target-feature +float128 -o - %s | FileCheck %s
 
 __float128 A;
 __float128 B;
 __float128 C;
 
+_Float128 f128_1 = 1.0f128;
+_Float128 f128_2 = 2.0F128;
+// CHECK: @f128_1 ={{.*}} global fp128 0xL00000000000000003FFF000000000000, align 16
+// CHECK: @f128_2 ={{.*}} global fp128 0xL00000000000000004000000000000000, align 16
 
 __float128 testSqrtOdd() {
   return __builtin_sqrtf128_round_to_odd(A);
 // CHECK: @llvm.ppc.sqrtf128.round.to.odd(fp128
 // CHECK-NEXT: ret fp128
 }
 
 __float128 testFMAOdd() {

clang/test/Preprocessor/init-x86.c

 // X86_64-LINUX:#define __DBL_MANT_DIG__ 53
 // X86_64-LINUX:#define __DBL_MAX_10_EXP__ 308
 // X86_64-LINUX:#define __DBL_MAX_EXP__ 1024
 // X86_64-LINUX:#define __DBL_MAX__ 1.7976931348623157e+308
 // X86_64-LINUX:#define __DBL_MIN_10_EXP__ (-307)
 // X86_64-LINUX:#define __DBL_MIN_EXP__ (-1021)
 // X86_64-LINUX:#define __DBL_MIN__ 2.2250738585072014e-308
 // X86_64-LINUX:#define __DECIMAL_DIG__ __LDBL_DECIMAL_DIG__
+// X86_64-LINUX:#define __FLT128_DECIMAL_DIG__ 36
+// X86_64-LINUX:#define __FLT128_DENORM_MIN__ 6.47517511943802511092443895822764655e-4966F128
+// X86_64-LINUX:#define __FLT128_DIG__ 33
+// X86_64-LINUX:#define __FLT128_EPSILON__ 1.92592994438723585305597794258492732e-34F128
+// X86_64-LINUX:#define __FLT128_HAS_DENORM__ 1
+// X86_64-LINUX:#define __FLT128_HAS_INFINITY__ 1
+// X86_64-LINUX:#define __FLT128_HAS_QUIET_NAN__ 1
+// X86_64-LINUX:#define __FLT128_MANT_DIG__ 113
+// X86_64-LINUX:#define __FLT128_MAX_10_EXP__ 4932
+// X86_64-LINUX:#define __FLT128_MAX_EXP__ 16384
+// X86_64-LINUX:#define __FLT128_MAX__ 1.18973149535723176508575932662800702e+4932F128
+// X86_64-LINUX:#define __FLT128_MIN_10_EXP__ (-4931)
+// X86_64-LINUX:#define __FLT128_MIN_EXP__ (-16381)
+// X86_64-LINUX:#define __FLT128_MIN__ 3.36210314311209350626267781732175260e-4932F128
 // X86_64-LINUX:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // X86_64-LINUX:#define __FLT_DIG__ 6
 // X86_64-LINUX:#define __FLT_EPSILON__ 1.19209290e-7F
 // X86_64-LINUX:#define __FLT_EVAL_METHOD__ 0
 // X86_64-LINUX:#define __FLT_HAS_DENORM__ 1
 // X86_64-LINUX:#define __FLT_HAS_INFINITY__ 1
 // X86_64-LINUX:#define __FLT_HAS_QUIET_NAN__ 1
 // X86_64-LINUX:#define __FLT_MANT_DIG__ 24

 // X86_64-LINUX:#define __PTRDIFF_TYPE__ long int
 // X86_64-LINUX:#define __PTRDIFF_WIDTH__ 64
 // X86_64-LINUX:#define __REGISTER_PREFIX__
 // X86_64-LINUX:#define __SCHAR_MAX__ 127
 // X86_64-LINUX:#define __SHRT_MAX__ 32767
 // X86_64-LINUX:#define __SIG_ATOMIC_MAX__ 2147483647
 // X86_64-LINUX:#define __SIG_ATOMIC_WIDTH__ 32
 // X86_64-LINUX:#define __SIZEOF_DOUBLE__ 8
+// X86_64-LINUX:#define __SIZEOF_FLOAT128__ 16
 // X86_64-LINUX:#define __SIZEOF_FLOAT__ 4
 // X86_64-LINUX:#define __SIZEOF_INT__ 4
 // X86_64-LINUX:#define __SIZEOF_LONG_DOUBLE__ 16
 // X86_64-LINUX:#define __SIZEOF_LONG_LONG__ 8
 // X86_64-LINUX:#define __SIZEOF_LONG__ 8
 // X86_64-LINUX:#define __SIZEOF_POINTER__ 8
 // X86_64-LINUX:#define __SIZEOF_PTRDIFF_T__ 8
 // X86_64-LINUX:#define __SIZEOF_SHORT__ 2

clang/test/Preprocessor/init.c

 // WEBASSEMBLY-NOT:#define __FLT16_HAS_QUIET_NAN__
 // WEBASSEMBLY-NOT:#define __FLT16_MANT_DIG__
 // WEBASSEMBLY-NOT:#define __FLT16_MAX_10_EXP__
 // WEBASSEMBLY-NOT:#define __FLT16_MAX_EXP__
 // WEBASSEMBLY-NOT:#define __FLT16_MAX__
 // WEBASSEMBLY-NOT:#define __FLT16_MIN_10_EXP__
 // WEBASSEMBLY-NOT:#define __FLT16_MIN_EXP__
 // WEBASSEMBLY-NOT:#define __FLT16_MIN__
+// WEBASSEMBLY-NEXT:#define __FLT128_DECIMAL_DIG__ 36
+// WEBASSEMBLY-NEXT:#define __FLT128_DENORM_MIN__ 6.47517511943802511092443895822764655e-4966F128
+// WEBASSEMBLY-NEXT:#define __FLT128_DIG__ 33
+// WEBASSEMBLY-NEXT:#define __FLT128_EPSILON__ 1.92592994438723585305597794258492732e-34F128
+// WEBASSEMBLY-NEXT:#define __FLT128_HAS_DENORM__ 1
+// WEBASSEMBLY-NEXT:#define __FLT128_HAS_INFINITY__ 1
+// WEBASSEMBLY-NEXT:#define __FLT128_HAS_QUIET_NAN__ 1
+// WEBASSEMBLY-NEXT:#define __FLT128_MANT_DIG__ 113
+// WEBASSEMBLY-NEXT:#define __FLT128_MAX_10_EXP__ 4932
+// WEBASSEMBLY-NEXT:#define __FLT128_MAX_EXP__ 16384
+// WEBASSEMBLY-NEXT:#define __FLT128_MAX__ 1.18973149535723176508575932662800702e+4932F128
+// WEBASSEMBLY-NEXT:#define __FLT128_MIN_10_EXP__ (-4931)
+// WEBASSEMBLY-NEXT:#define __FLT128_MIN_EXP__ (-16381)
+// WEBASSEMBLY-NEXT:#define __FLT128_MIN__ 3.36210314311209350626267781732175260e-4932F128
 // WEBASSEMBLY-NEXT:#define __FLT_DECIMAL_DIG__ 9
 // WEBASSEMBLY-NEXT:#define __FLT_DENORM_MIN__ 1.40129846e-45F
 // WEBASSEMBLY-NEXT:#define __FLT_DIG__ 6
 // WEBASSEMBLY-NEXT:#define __FLT_EPSILON__ 1.19209290e-7F
 // WEBASSEMBLY-NEXT:#define __FLT_EVAL_METHOD__ 0
 // WEBASSEMBLY-NEXT:#define __FLT_HAS_DENORM__ 1
 // WEBASSEMBLY-NEXT:#define __FLT_HAS_INFINITY__ 1
 // WEBASSEMBLY-NEXT:#define __FLT_HAS_QUIET_NAN__ 1

clang/test/Sema/_Float128.c

+// RUN: %clang_cc1 -triple powerpc64-linux -verify %s
+// RUN: %clang_cc1 -triple i686-windows-gnu -verify %s
+// RUN: %clang_cc1 -triple powerpc64-linux -verify=cxx -xc++ %s
+
+#ifdef __cplusplus
+_Float128 f; // cxx-error {{unknown type name '_Float128'}}
+
+#elif defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)
+// expected-no-diagnostics
+_Float128 f;
+_Float128 epsilon = __FLT128_EPSILON__;
+
+#else
+_Float128 f; // expected-error {{__float128 is not supported on this target}}
+float epsilon = __FLT128_EPSILON__; // expected-error {{use of undeclared identifier}}
+
+#endif  // defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)