Change long double to float128

Use __float128 for clang and _Float128 for gcc.
Default to long double for other compilers.

Author: MDevereau

llvm/include/llvm/ADT/APFloat.h

@@ -19,6 +19,7 @@
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/FloatingPointMode.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Support/float128.h"
 #include <memory>
 
 #define APFLOAT_DISPATCH_ON_SEMANTICS(METHOD_CALL)                             \
@@ -299,7 +300,7 @@ class IEEEFloat final : public APFloatBase {
   IEEEFloat(const fltSemantics &, integerPart);
   IEEEFloat(const fltSemantics &, uninitializedTag);
   IEEEFloat(const fltSemantics &, const APInt &);
-  explicit IEEEFloat(long double ld);
+  explicit IEEEFloat(float128 ld);
   explicit IEEEFloat(double d);
   explicit IEEEFloat(float f);
   IEEEFloat(const IEEEFloat &);
@@ -355,7 +356,7 @@ class IEEEFloat final : public APFloatBase {
   Expected<opStatus> convertFromString(StringRef, roundingMode);
   APInt bitcastToAPInt() const;
   double convertToDouble() const;
-  long double convertToQuad() const;
+  float128 convertToQuad() const;
   float convertToFloat() const;
 
   /// @}
@@ -944,7 +945,7 @@ class APFloat : public APFloatBase {
   APFloat(const fltSemantics &Semantics, uninitializedTag)
       : U(Semantics, uninitialized) {}
   APFloat(const fltSemantics &Semantics, const APInt &I) : U(Semantics, I) {}
-  explicit APFloat(long double ld) : U(IEEEFloat(ld), IEEEquad()) {}
+  explicit APFloat(float128 ld) : U(IEEEFloat(ld), IEEEquad()) {}
   explicit APFloat(double d) : U(IEEEFloat(d), IEEEdouble()) {}
   explicit APFloat(float f) : U(IEEEFloat(f), IEEEsingle()) {}
   APFloat(const APFloat &RHS) = default;
@@ -1226,7 +1227,7 @@ class APFloat : public APFloatBase {
   /// \pre The APFloat must be built using semantics, that can be represented by
   /// the host float type without loss of precision. It can be IEEEquad and
   /// shorter semantics, like IEEEdouble and others.
-  long double convertToQuad() const;
+  float128 convertToQuad() const;
 
   /// Converts this APFloat to host float value.
   ///

llvm/include/llvm/ADT/APInt.h

@@ -17,6 +17,7 @@
 
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/MathExtras.h"
+#include "llvm/Support/float128.h"
 #include <cassert>
 #include <climits>
 #include <cstring>
@@ -1670,9 +1671,9 @@ class [[nodiscard]] APInt {
   /// any bit width. Exactly 64 bits will be translated.
   double bitsToDouble() const { return llvm::bit_cast<double>(getWord(0)); }
 
-  long double bitsToQuad() const {
+  float128 bitsToQuad() const {
     __uint128_t ul = ((__uint128_t)U.pVal[1] << 64) + U.pVal[0];
-    return llvm::bit_cast<long double>(ul);
+    return llvm::bit_cast<float128>(ul);
   }
 
   /// Converts APInt bits to a float
@@ -1700,14 +1701,12 @@ class [[nodiscard]] APInt {
     return APInt(sizeof(float) * CHAR_BIT, llvm::bit_cast<uint32_t>(V));
   }
 
-  static APInt longDoubleToBits(long double V) {
-    assert(sizeof(long double) == 16 && "Expected 16 byte long double");
-
+  static APInt longDoubleToBits(float128 V) {
     const uint64_t Words[2] = {
         static_cast<uint64_t>(V),
         static_cast<uint64_t>(llvm::bit_cast<__uint128_t>(V) >> 64),
     };
-    return APInt(sizeof(long double) * CHAR_BIT, 2, Words);
+    return APInt(sizeof(float128) * CHAR_BIT, 2, Words);
   }
 
   /// @}

llvm/include/llvm/IR/Constants.h

@@ -290,7 +290,7 @@ class ConstantFP final : public ConstantData {
   /// host double and as the target format.
   static Constant *get(Type *Ty, double V);
 
-  static Constant *get128(Type *Ty, long double V);
+  static Constant *get128(Type *Ty, float128 V);
 
   /// If Ty is a vector type, return a Constant with a splat of the given
   /// value. Otherwise return a ConstantFP for the given value.

llvm/include/llvm/Support/float128.h

@@ -0,0 +1,20 @@
+//===-- llvm/Support/float128.h - Compiler abstraction support --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_FLOAT128
+#define LLVM_FLOAT128
+
+#if defined(__clang__)
+typedef __float128 float128;
+#elif defined(__GNUC__) || defined(__GNUG__)
+typedef _Float128 float128;
+#else
+typedef long double float128;
+#endif
+
+#endif // LLVM_FLOAT128

llvm/lib/Analysis/ConstantFolding.cpp

@@ -1760,7 +1760,7 @@ inline bool llvm_fenv_testexcept() {
 
 Constant *ConstantFoldLogf128(const APFloat &V, Type *Ty) {
 #ifdef HAS_LOGF128
-  long double l = logf128(V.convertToQuad());
+  float128 l = logf128(V.convertToQuad());
   return ConstantFP::get128(Ty, l);
 #else
   return nullptr;

llvm/lib/IR/Constants.cpp

@@ -976,7 +976,7 @@ Constant *ConstantFP::get(Type *Ty, double V) {
   return C;
 }
 
-Constant *ConstantFP::get128(Type *Ty, long double V) {
+Constant *ConstantFP::get128(Type *Ty, float128 V) {
   LLVMContext &Context = Ty->getContext();
 
   APFloat FV(V);

llvm/lib/Support/APFloat.cpp

@@ -3670,7 +3670,7 @@ double IEEEFloat::convertToDouble() const {
   return api.bitsToDouble();
 }
 
-long double IEEEFloat::convertToQuad() const {
+float128 IEEEFloat::convertToQuad() const {
   assert(semantics == (const llvm::fltSemantics *)&semIEEEquad &&
          "Float semantics are not IEEEquads");
   APInt api = bitcastToAPInt();
@@ -3965,7 +3965,7 @@ IEEEFloat::IEEEFloat(double d) {
   initFromAPInt(&semIEEEdouble, APInt::doubleToBits(d));
 }
 
-IEEEFloat::IEEEFloat(long double ld) {
+IEEEFloat::IEEEFloat(float128 ld) {
   initFromAPInt(&semIEEEquad, APInt::longDoubleToBits(ld));
 }
 
@@ -5276,7 +5276,7 @@ double APFloat::convertToDouble() const {
   return Temp.getIEEE().convertToDouble();
 }
 
-long double APFloat::convertToQuad() const {
+float128 APFloat::convertToQuad() const {
   if (&getSemantics() == (const llvm::fltSemantics *)&semIEEEquad)
     return getIEEE().convertToQuad();
   assert(getSemantics().isRepresentableBy(semIEEEquad) &&