[flang] Folding for quadmath 128 bit floating point intrinsics

[PeteSteinfeld]

Summary

This update allows constant folding for many 128 bit floating point intrinsics
through the library quadmath, which is only available on some platforms.

[klausler]

flang/lib/Evaluate/host.h

170

I'm confused by this specialization -- shouldn't the more general template now at line 186 work for 128-bit complex anyway?

[PeteSteinfeld]

flang/lib/Evaluate/host.h

170

Without this specialization, I get compilation errors from intrinsics-library.cpp. Here's an excerpt:

/local/home/psteinfeld/dev/llvm-project/flang/lib/Evaluate/intrinsics-library.cpp: In instantiation of ‘constexpr const Fortran::evaluate::DynamicType Fortran::evaluate::FuncTypeAnalyzer<__float128 (*)(__float128)>::result’:
/local/home/psteinfeld/dev/llvm-project/flang/lib/Evaluate/intrinsics-library.cpp:188:57:   required from ‘static constexpr Fortran::evaluate::HostRuntimeFunction Fortran::evaluate::FolderFactory<HostFuncType, func>::Create(const string_view&) [with HostFuncType = __float128 (*)(__float128); HostFuncType func = acosq; std::string_view = std::basic_string_view<char>]’
/local/home/psteinfeld/dev/llvm-project/flang/lib/Evaluate/intrinsics-library.cpp:325:50:   required from here
/local/home/psteinfeld/dev/llvm-project/flang/lib/Evaluate/intrinsics-library.cpp:105:67: error: ‘Fortran::evaluate::host::FortranType<__float128>’ {aka ‘struct Fortran::evaluate::host::UnknownType’} has no member named ‘GetType’
  105 |   static constexpr DynamicType result{host::FortranType<HostTR>{}.GetType()};
      |                                             ~~~~~~~~~~~~~~~~~~~~~~^~~~~~~
/local/home/psteinfeld/dev/llvm-project/flang/lib/Evaluate/intrinsics-library.cpp:105:32: error: no matching function for call to ‘Fortran::evaluate::DynamicType::DynamicType(<brace-enclosed initializer list>)’
  105 |   static constexpr DynamicType result{host::FortranType<HostTR>{}.GetType()};
      |                                ^~~~~~
In file included from /local/home/psteinfeld/dev/llvm-project/flang/lib/Evaluate/character.h:12,
                 from /local/home/psteinfeld/dev/llvm-project/flang/lib/Evaluate/fold-implementation.h:12,
                 from /local/home/psteinfeld/dev/llvm-project/flang/lib/Evaluate/intrinsics-library.cpp:15:
/local/home/psteinfeld/dev/llvm-project/flang/include/flang/Evaluate/type.h:243:13: note: candidate: ‘constexpr Fortran::evaluate::DynamicType::DynamicType()’
  243 |   constexpr DynamicType() {}
      |             ^~~~~~~~~~~
/local/home/psteinfeld/dev/llvm-project/flang/include/flang/Evaluate/type.h:243:13: note:   candidate expects 0 arguments, 1 provided

[klausler]

flang/lib/Evaluate/host.h

170

That seems to imply that HostTypeExists<RealT> is false, which seems wrong if you just defined it for KIND=16.

I think that the general template for COMPLEX should be made to work, with some if constexpr and #ifdef HAS_FLOAT128 guards to yield __complex128 instead of std::complex<HostType<RealT>> when it should do so.

If you can't make that happen, can you at least be consistent above with your use of the kind code 16 and the use of common::RealKindForPrecision(113)?

[PeteSteinfeld]

flang/lib/Evaluate/host.h

170

Thanks for your help with this.

I flailed around, but I cannot get things to compile without a separate specialization for 128 bit complex. I did clean up the KIND specification and moved the 128 bit version of the complex specialization closer to the other one.

Let me know if there's something I'm missing.

[PeteSteinfeld]

Responding to Peter's comments.

[PeteSteinfeld]

Attempting to get Debian to compile.

[klausler]

LGTM once the build issue with a missing "quadmath.h" header is fixed.

[PeteSteinfeld]

These changes are to try to get builds to succeed on Debian. I'm now testing
both if the quadmath library exists and if the header file quadmath.h exists in
order to enable use of the quadmath library for folding.

[PeteSteinfeld]

Polishing up the CMake files.

flang/include/flang/Common/float128.h

-/*===-- flang/Runtime/float128.h ----------------------------------*- C -*-===
+/*===-- flang/Common/float128.h ----------------------------------*- 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
  *
  *===----------------------------------------------------------------------===*/
 
 /* This header is usable in both C and C++ code.
  * Isolates build compiler checks to determine the presence of an IEEE-754
  * quad-precision type named __float128 type that isn't __ibm128
  * (double/double). We don't care whether the type has underlying hardware
  * support or is emulated.
  *
  * 128-bit arithmetic may be available via "long double"; this can
  * be determined by LDBL_MANT_DIG == 113.  A machine may have both 128-bit
  * long double and __float128; prefer long double by testing for it first.
  */
 
-#ifndef FORTRAN_RUNTIME_FLOAT128_H_
-#define FORTRAN_RUNTIME_FLOAT128_H_
+#ifndef FORTRAN_COMMON_FLOAT128_H_
+#define FORTRAN_COMMON_FLOAT128_H_
 
 #ifdef __cplusplus
 /*
  * libc++ does not fully support __float128 right now, e.g.
  * std::complex<__float128> multiplication ends up calling
  * copysign() that is not defined for __float128.
  * In order to check for libc++'s _LIBCPP_VERSION macro
  * we need to include at least one libc++ header file.

 #define HAS_FLOAT128 1
 #endif
 #elif defined __PPC__ && __GNUC__ >= 8
 #define HAS_FLOAT128 1
 #endif
 #endif /* (defined(__FLOAT128__) || defined(__SIZEOF_FLOAT128__)) && \
           !defined(_LIBCPP_VERSION)  && !defined(__CUDA_ARCH__) */
 
-#endif /* FORTRAN_RUNTIME_FLOAT128_H_ */
+#endif /* FORTRAN_COMMON_FLOAT128_H_ */

flang/include/flang/Runtime/cpp-type.h

 //===-- include/flang/Runtime/cpp-type.h ------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 // Maps Fortran intrinsic types to C++ types used in the runtime.
 
 #ifndef FORTRAN_RUNTIME_CPP_TYPE_H_
 #define FORTRAN_RUNTIME_CPP_TYPE_H_
 
 #include "flang/Common/Fortran.h"
+#include "flang/Common/float128.h"
 #include "flang/Common/uint128.h"
-#include "flang/Runtime/float128.h"
 #include <cfloat>
 #include <complex>
 #include <cstdint>
 #include <type_traits>
 
 namespace Fortran::runtime {
 
 using common::TypeCategory;

flang/include/flang/Runtime/numeric.h

 //===-- include/flang/Runtime/numeric.h -------------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 // Defines API between compiled code and the implementations of various numeric
 // intrinsic functions in the runtime library.
 
 #ifndef FORTRAN_RUNTIME_NUMERIC_H_
 #define FORTRAN_RUNTIME_NUMERIC_H_
 
+#include "flang/Common/float128.h"
 #include "flang/Runtime/cpp-type.h"
 #include "flang/Runtime/entry-names.h"
 
 namespace Fortran::runtime {
 extern "C" {
 
 // CEILING
 CppTypeFor<TypeCategory::Integer, 1> RTNAME(Ceiling4_1)(

flang/include/flang/Runtime/reduction.h

 //===-- include/flang/Runtime/reduction.h -----------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 // Defines the API for the reduction transformational intrinsic functions.
 
 #ifndef FORTRAN_RUNTIME_REDUCTION_H_
 #define FORTRAN_RUNTIME_REDUCTION_H_
 
+#include "flang/Common/float128.h"
 #include "flang/Common/uint128.h"
 #include "flang/Runtime/cpp-type.h"
 #include "flang/Runtime/entry-names.h"
-#include "flang/Runtime/float128.h"
 #include <cfloat>
 #include <cinttypes>
 #include <complex>
 #include <cstdint>
 
 namespace Fortran::runtime {
 
 class Descriptor;

flang/include/flang/Runtime/transformational.h

 // These are naive allocating implementations; optimized forms that manipulate
 // pointer descriptors or that supply functional views of arrays remain to
 // be defined and may instead be part of lowering (see docs/ArrayComposition.md)
 // for details).
 
 #ifndef FORTRAN_RUNTIME_TRANSFORMATIONAL_H_
 #define FORTRAN_RUNTIME_TRANSFORMATIONAL_H_
 
+#include "flang/Common/float128.h"
 #include "flang/Runtime/cpp-type.h"
 #include "flang/Runtime/entry-names.h"
-#include "flang/Runtime/float128.h"
 #include <cinttypes>
 
 namespace Fortran::runtime {
 
 class Descriptor;
 
 extern "C" {
 

flang/lib/Evaluate/CMakeLists.txt

if(LIBPGMATH)
     else()
       message(STATUS "Libpgmath will not be used because C99 complex is not supported.")
     endif()
   else()
     message(STATUS "Libpgmath not found in: ${LIBPGMATH_DIR}")
   endif()
 endif()
 
+check_include_file(quadmath.h FOUND_QUADMATH_HEADER)
+check_library_exists(quadmath sinq "" FOUND_QUADMATH_LIB)
+if(FOUND_QUADMATH_HEADER AND FOUND_QUADMATH_LIB)
+  add_compile_definitions(HAS_QUADMATHLIB)
+endif()
+
 add_flang_library(FortranEvaluate
   call.cpp
   characteristics.cpp
   check-expression.cpp
   common.cpp
   complex.cpp
   constant.cpp
   expression.cpp

flang/lib/Evaluate/host.h

 // Define a compile-time mapping between Fortran intrinsic types and host
 // hardware types if possible. The purpose is to avoid having to do any kind of
 // assumption on whether a "float" matches the Scalar<Type<TypeCategory::Real,
 // 4>> outside of this header. The main tools are HostTypeExists<T> and
 // HostType<T>. HostTypeExists<T>() will return true if and only if a host
 // hardware type maps to Fortran intrinsic type T. Then HostType<T> can be used
 // to safely refer to this hardware type.
 
+#if HAS_QUADMATHLIB
+#include "quadmath.h"
+#include "flang/Common/float128.h"
+#endif
 #include "flang/Evaluate/type.h"
 #include <cfenv>
 #include <complex>
 #include <cstdint>
 #include <limits>
 #include <string>
 #include <type_traits>
 
struct HostTypeHelper<
     Type<TypeCategory::Real, common::RealKindForPrecision(64)>> {
   // X87 80bits
   using Type = std::conditional_t<sizeof(long double) >= 10 &&
           std::numeric_limits<long double>::digits == 64 &&
           std::numeric_limits<long double>::max_exponent == 16384,
       long double, UnsupportedType>;
 };
 
-template <>
-struct HostTypeHelper<
-    Type<TypeCategory::Real, common::RealKindForPrecision(113)>> {
+#if HAS_QUADMATHLIB
+template <> struct HostTypeHelper<Type<TypeCategory::Real, 16>> {
+  // IEEE 754 128bits
+  using Type = __float128;
+};
+#else
+template <> struct HostTypeHelper<Type<TypeCategory::Real, 16>> {
   // IEEE 754 128bits
   using Type = std::conditional_t<sizeof(long double) == 16 &&
           std::numeric_limits<long double>::digits == 113 &&
           std::numeric_limits<long double>::max_exponent == 16384,
       long double, UnsupportedType>;
 };
+#endif
 
 template <int KIND> struct HostTypeHelper<Type<TypeCategory::Complex, KIND>> {
   using RealT = Fortran::evaluate::Type<TypeCategory::Real, KIND>;
   using Type = std::conditional_t<HostTypeExists<RealT>(),
       std::complex<HostType<RealT>>, UnsupportedType>;
 };
 
+#if HAS_QUADMATHLIB
+template <> struct HostTypeHelper<Type<TypeCategory::Complex, 16>> {
+  using RealT = Fortran::evaluate::Type<TypeCategory::Real, 16>;
+  using Type = __complex128;
+};
+#endif
+
 template <int KIND> struct HostTypeHelper<Type<TypeCategory::Logical, KIND>> {
   using Type = std::conditional_t<KIND <= 8, std::uint8_t, UnsupportedType>;
 };
 
 template <int KIND> struct HostTypeHelper<Type<TypeCategory::Character, KIND>> {
   using Type =
       Scalar<typename Fortran::evaluate::Type<TypeCategory::Character, KIND>>;
 };

flang/lib/Evaluate/intrinsics-library.cpp

 #include "fold-implementation.h"
 #include "host.h"
 #include "flang/Common/static-multimap-view.h"
 #include "flang/Evaluate/expression.h"
 #include <cfloat>
 #include <cmath>
 #include <complex>
 #include <functional>
+#if HAS_QUADMATHLIB
+#include "quadmath.h"
+#include "flang/Common/float128.h"
+#endif
 #include <type_traits>
 
 namespace Fortran::evaluate {
 
 // Define a vector like class that can hold an arbitrary number of
 // Dynamic type and be built at compile time. This is like a
 // std::vector<DynamicType>, but constexpr only.
 template <typename... FortranType> struct TypeVectorStorage {
static constexpr HostRuntimeFunction table[]{
       FolderFactory<F, F{::y1f}>::Create("bessel_y1"),
       FolderFactory<FN, FN{::ynf}>::Create("bessel_yn"),
   };
   static constexpr HostRuntimeMap map{table};
   static_assert(map.Verify(), "map must be sorted");
 };
 #endif
 
+#if HAS_QUADMATHLIB
+template <> struct HostRuntimeLibrary<__float128, LibraryVersion::Libm> {
+  using F = FuncPointer<__float128, __float128>;
+  using F2 = FuncPointer<__float128, __float128, __float128>;
+  static constexpr HostRuntimeFunction table[]{
+      FolderFactory<F, F{::acosq}>::Create("acos"),
+      FolderFactory<F, F{::acoshq}>::Create("acosh"),
+      FolderFactory<F, F{::asinq}>::Create("asin"),
+      FolderFactory<F, F{::asinhq}>::Create("asinh"),
+      FolderFactory<F, F{::atanq}>::Create("atan"),
+      FolderFactory<F2, F2{::atan2q}>::Create("atan2"),
+      FolderFactory<F, F{::atanhq}>::Create("atanh"),
+      FolderFactory<F, F{::cosq}>::Create("cos"),
+      FolderFactory<F, F{::coshq}>::Create("cosh"),
+      FolderFactory<F, F{::erfq}>::Create("erf"),
+      FolderFactory<F, F{::erfcq}>::Create("erfc"),
+      FolderFactory<F, F{::expq}>::Create("exp"),
+      FolderFactory<F, F{::tgammaq}>::Create("gamma"),
+      FolderFactory<F, F{::logq}>::Create("log"),
+      FolderFactory<F, F{::log10q}>::Create("log10"),
+      FolderFactory<F, F{::lgammaq}>::Create("log_gamma"),
+      FolderFactory<F2, F2{::powq}>::Create("pow"),
+      FolderFactory<F, F{::sinq}>::Create("sin"),
+      FolderFactory<F, F{::sinhq}>::Create("sinh"),
+      FolderFactory<F, F{::tanq}>::Create("tan"),
+      FolderFactory<F, F{::tanhq}>::Create("tanh"),
+  };
+  static constexpr HostRuntimeMap map{table};
+  static_assert(map.Verify(), "map must be sorted");
+};
+template <> struct HostRuntimeLibrary<__complex128, LibraryVersion::Libm> {
+  using F = FuncPointer<__complex128, __complex128>;
+  using F2 = FuncPointer<__complex128, __complex128, __complex128>;
+  static constexpr HostRuntimeFunction table[]{
+      FolderFactory<F, F{::cacosq}>::Create("acos"),
+      FolderFactory<F, F{::cacoshq}>::Create("acosh"),
+      FolderFactory<F, F{::casinq}>::Create("asin"),
+      FolderFactory<F, F{::casinhq}>::Create("asinh"),
+      FolderFactory<F, F{::catanq}>::Create("atan"),
+      FolderFactory<F, F{::catanhq}>::Create("atanh"),
+      FolderFactory<F, F{::ccosq}>::Create("cos"),
+      FolderFactory<F, F{::ccoshq}>::Create("cosh"),
+      FolderFactory<F, F{::cexpq}>::Create("exp"),
+      FolderFactory<F, F{::clogq}>::Create("log"),
+      FolderFactory<F2, F2{::cpowq}>::Create("pow"),
+      FolderFactory<F, F{::csinq}>::Create("sin"),
+      FolderFactory<F, F{::csinhq}>::Create("sinh"),
+      FolderFactory<F, F{::csqrtq}>::Create("sqrt"),
+      FolderFactory<F, F{::ctanq}>::Create("tan"),
+      FolderFactory<F, F{::ctanhq}>::Create("tanh"),
+  };
+  static constexpr HostRuntimeMap map{table};
+  static_assert(map.Verify(), "map must be sorted");
+};
+#endif
+
 template <> struct HostRuntimeLibrary<double, LibraryVersion::LibmExtensions> {
   using F = FuncPointer<double, double>;
   using FN = FuncPointer<double, int, double>;
   static constexpr HostRuntimeFunction table[]{
       FolderFactory<F, F{::j0}>::Create("bessel_j0"),
       FolderFactory<F, F{::j1}>::Create("bessel_j1"),
       FolderFactory<FN, FN{::jn}>::Create("bessel_jn"),
       FolderFactory<F, F{::y0}>::Create("bessel_y0"),
static constexpr HostRuntimeFunction table[]{
       FolderFactory<F, F{::y0l}>::Create("bessel_y0"),
       FolderFactory<F, F{::y1l}>::Create("bessel_y1"),
       FolderFactory<FN, FN{::ynl}>::Create("bessel_yn"),
   };
   static constexpr HostRuntimeMap map{table};
   static_assert(map.Verify(), "map must be sorted");
 };
 #endif // LDBL_MANT_DIG == 80 || LDBL_MANT_DIG == 113
-#endif
+#endif //_POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 600
 
 /// Define pgmath description
 #if LINK_WITH_LIBPGMATH
 // Only use libpgmath for folding if it is available.
 // First declare all libpgmaths functions
 #define PGMATH_LINKING
 #define PGMATH_DECLARE
 #include "flang/Evaluate/pgmath.h.inc"
if (resultType.category() == TypeCategory::Real) {
     }
     if (const auto *map{GetHostRuntimeMapHelper<double, version>(resultType)}) {
       return map;
     }
     if (const auto *map{
             GetHostRuntimeMapHelper<long double, version>(resultType)}) {
       return map;
     }
+#if HAS_QUADMATHLIB
+    if (const auto *map{
+            GetHostRuntimeMapHelper<__float128, version>(resultType)}) {
+      return map;
+    }
+#endif
   }
   if (resultType.category() == TypeCategory::Complex) {
     if (const auto *map{GetHostRuntimeMapHelper<std::complex<float>, version>(
             resultType)}) {
       return map;
     }
     if (const auto *map{GetHostRuntimeMapHelper<std::complex<double>, version>(
             resultType)}) {
       return map;
     }
     if (const auto *map{
             GetHostRuntimeMapHelper<std::complex<long double>, version>(
                 resultType)}) {
       return map;
     }
+#if HAS_QUADMATHLIB
+    if (const auto *map{
+            GetHostRuntimeMapHelper<__complex128, version>(resultType)}) {
+      return map;
+    }
+#endif
   }
   return nullptr;
 }
 static const HostRuntimeMap *GetHostRuntimeMap(
     LibraryVersion version, DynamicType resultType) {
   switch (version) {
   case LibraryVersion::Libm:
     return GetHostRuntimeMapVersion<LibraryVersion::Libm>(resultType);

flang/lib/Frontend/CMakeLists.txt

 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
 
+check_include_file(quadmath.h FOUND_QUADMATH_HEADER)
+check_library_exists(quadmath sinq "" FOUND_QUADMATH_LIB)
+if(FOUND_QUADMATH_HEADER AND FOUND_QUADMATH_LIB)
+  set(QUADMATHLIB quadmath)
+endif()
+
 add_flang_library(flangFrontend
   CompilerInstance.cpp
   CompilerInvocation.cpp
   CodeGenOptions.cpp
   FrontendAction.cpp
   FrontendActions.cpp
   FrontendOptions.cpp
   LangOptions.cpp
add_flang_library(flangFrontend
   HLFIRTransforms
   MLIRTransforms
   MLIRBuiltinToLLVMIRTranslation
   MLIRLLVMToLLVMIRTranslation
   MLIRSCFToControlFlow
   MLIRTargetLLVMIRImport
   ${dialect_libs}
   ${extension_libs}
+  ${QUADMATHLIB}
 
   LINK_COMPONENTS
   Passes
   Analysis
   Extensions
   IRReader
   Option
   Support

flang/runtime/dot-product.cpp

 //===-- runtime/dot-product.cpp -------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "float.h"
 #include "terminator.h"
 #include "tools.h"
+#include "flang/Common/float128.h"
 #include "flang/Runtime/cpp-type.h"
 #include "flang/Runtime/descriptor.h"
 #include "flang/Runtime/reduction.h"
 #include <cfloat>
 #include <cinttypes>
 
 namespace Fortran::runtime {
 

flang/runtime/extrema.cpp

 //===-- runtime/extrema.cpp -----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // Implements MAXLOC, MINLOC, MAXVAL, & MINVAL for all required operand types
 // and shapes and (for MAXLOC & MINLOC) result integer kinds.  Also implements
 // NORM2 using common infrastructure.
 
 #include "reduction-templates.h"
+#include "flang/Common/float128.h"
 #include "flang/Runtime/character.h"
-#include "flang/Runtime/float128.h"
 #include "flang/Runtime/reduction.h"
 #include <algorithm>
 #include <cfloat>
 #include <cinttypes>
 #include <cmath>
 #include <optional>
 
 namespace Fortran::runtime {

flang/runtime/numeric.cpp

 //===-- runtime/numeric.cpp -----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime/numeric.h"
 #include "terminator.h"
-#include "flang/Runtime/float128.h"
+#include "flang/Common/float128.h"
 #include <cfloat>
 #include <climits>
 #include <cmath>
 #include <limits>
 
 namespace Fortran::runtime {
 
 template <typename RES>

flang/runtime/product.cpp

 //===-- runtime/product.cpp -----------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // Implements PRODUCT for all required operand types and shapes.
 
 #include "reduction-templates.h"
-#include "flang/Runtime/float128.h"
+#include "flang/Common/float128.h"
 #include "flang/Runtime/reduction.h"
 #include <cfloat>
 #include <cinttypes>
 #include <complex>
 
 namespace Fortran::runtime {
 template <typename INTERMEDIATE> class NonComplexProductAccumulator {
 public:

flang/runtime/random.cpp

 //===-- runtime/random.cpp ------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // Implements the intrinsic subroutines RANDOM_INIT, RANDOM_NUMBER, and
 // RANDOM_SEED.
 
 #include "flang/Runtime/random.h"
 #include "lock.h"
 #include "terminator.h"
+#include "flang/Common/float128.h"
 #include "flang/Common/leading-zero-bit-count.h"
 #include "flang/Common/uint128.h"
 #include "flang/Runtime/cpp-type.h"
 #include "flang/Runtime/descriptor.h"
-#include "flang/Runtime/float128.h"
 #include <algorithm>
 #include <cmath>
 #include <cstdint>
 #include <ctime>
 #include <limits>
 #include <memory>
 #include <random>
 

flang/runtime/sum.cpp

 //===-- runtime/sum.cpp ---------------------------------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 // Implements SUM for all required operand types and shapes.
 //
 // Real and complex SUM reductions attempt to reduce floating-point
 // cancellation on intermediate results by using "Kahan summation"
 // (basically the same as manual "double-double").
 
 #include "reduction-templates.h"
-#include "flang/Runtime/float128.h"
+#include "flang/Common/float128.h"
 #include "flang/Runtime/reduction.h"
 #include <cfloat>
 #include <cinttypes>
 #include <complex>
 
 namespace Fortran::runtime {
 
 template <typename INTERMEDIATE> class IntegerSumAccumulator {

flang/runtime/transformational.cpp

 // these cases as implying a hidden constraint, these implementations
 // work with arbitrary lower bounds.  This may be technically an extension
 // of the standard but it more likely to conform with its intent.
 
 #include "flang/Runtime/transformational.h"
 #include "copy.h"
 #include "terminator.h"
 #include "tools.h"
+#include "flang/Common/float128.h"
 #include "flang/Runtime/descriptor.h"
 
 namespace Fortran::runtime {
 
 // Utility for CSHIFT & EOSHIFT rank > 1 cases that determines the shift count
 // for each of the vector sections of the result.
 class ShiftControl {
 public:

flang/tools/bbc/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
 Passes
 TargetParser
 )
 
 add_flang_tool(bbc bbc.cpp
 DEPENDS
 FIROptCodeGenPassIncGen
 )
 
 llvm_update_compile_flags(bbc)
 get_property(dialect_libs GLOBAL PROPERTY MLIR_DIALECT_LIBS)
 get_property(extension_libs GLOBAL PROPERTY MLIR_EXTENSION_LIBS)
+
+check_include_file(quadmath.h FOUND_QUADMATH_HEADER)
+check_library_exists(quadmath sinq "" FOUND_QUADMATH_LIB)
+if(FOUND_QUADMATH_HEADER AND FOUND_QUADMATH_LIB)
+  set(QUADMATHLIB quadmath)
+endif()
+
 target_link_libraries(bbc PRIVATE
 FIRDialect
 FIRDialectSupport
 FIRSupport
 FIRTransforms
 FIRBuilder
 HLFIRDialect
 HLFIRTransforms
 ${dialect_libs}
 ${extension_libs}
 MLIRAffineToStandard
 MLIRSCFToControlFlow
 FortranCommon
 FortranParser
 FortranEvaluate
 FortranSemantics
 FortranLower
+${QUADMATHLIB}
 )

flang/unittests/Evaluate/CMakeLists.txt

 set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR})
 add_library(FortranEvaluateTesting
   testing.cpp
   fp-testing.cpp
 )
 if (LLVM_LINK_LLVM_DYLIB)
   set(llvm_libs LLVM)
 else()
   llvm_map_components_to_libnames(llvm_libs Support)
 endif()
+
+check_include_file(quadmath.h FOUND_QUADMATH_HEADER)
+check_library_exists(quadmath sinq "" FOUND_QUADMATH_LIB)
+if(FOUND_QUADMATH_HEADER AND FOUND_QUADMATH_LIB)
+  set(QUADMATHLIB quadmath)
+endif()
+
 target_link_libraries(FortranEvaluateTesting
-    ${llvm_libs})
+  ${llvm_libs} ${QUADMATHLIB})
 
 add_flang_nongtest_unittest(leading-zero-bit-count
   FortranEvaluateTesting
 )
 
 add_flang_nongtest_unittest(bit-population-count
   FortranEvaluateTesting
 )

flang/unittests/Runtime/Numeric.cpp

 //===-- flang/unittests/Runtime/Numeric.cpp ---------------------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime/numeric.h"
 #include "gtest/gtest.h"
+#include "flang/Common/float128.h"
 #include <cmath>
 #include <limits>
 
 using namespace Fortran::runtime;
 using Fortran::common::TypeCategory;
 template <int KIND> using Int = CppTypeFor<TypeCategory::Integer, KIND>;
 template <int KIND> using Real = CppTypeFor<TypeCategory::Real, KIND>;
 

flang/unittests/Runtime/Reduction.cpp

 //===-- flang/unittests/Runtime/Reductions.cpp ----------------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime/reduction.h"
 #include "gtest/gtest.h"
 #include "tools.h"
+#include "flang/Common/float128.h"
 #include "flang/Runtime/allocatable.h"
 #include "flang/Runtime/cpp-type.h"
 #include "flang/Runtime/descriptor.h"
 #include "flang/Runtime/type-code.h"
 #include <cstdint>
 #include <cstring>
 #include <string>
 #include <vector>

flang/unittests/Runtime/Transformational.cpp

 //===-- flang/unittests/Runtime/Transformational.cpp ----------------------===//
 //
 // 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
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Runtime/transformational.h"
 #include "gtest/gtest.h"
 #include "tools.h"
+#include "flang/Common/float128.h"
 #include "flang/Runtime/type-code.h"
 #include <vector>
 
 using namespace Fortran::runtime;
 using Fortran::common::TypeCategory;
 
 template <int KIND>
 using BesselFuncType = std::function<void(Descriptor &, int32_t, int32_t,