Index: libcxx/CMakeLists.txt
===================================================================
--- libcxx/CMakeLists.txt
+++ libcxx/CMakeLists.txt
@@ -94,6 +94,11 @@
    support the C functionality for wide characters. When wide characters are
    not supported, several parts of the library will be disabled, notably the
    wide character specializations of std::basic_string." ON)
+option(LIBCXX_ENABLE_LONG_DOUBLE_MATH
+  "Whether to include support for long double math functions in the library.
+   Disabling long double support can be useful when porting to platforms that
+   don't support the C long double math functions. When long doubles are not
+   supported, several cmath and math.h the library will be disabled." ON)
 option(LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS
   "Whether to turn on vendor availability annotations on declarations that depend
    on definitions in a shared library. By default, we assume that we're not building
@@ -857,6 +862,7 @@
 config_define_if_not(LIBCXX_ENABLE_LOCALIZATION _LIBCPP_HAS_NO_LOCALIZATION)
 config_define_if_not(LIBCXX_ENABLE_UNICODE _LIBCPP_HAS_NO_UNICODE)
 config_define_if_not(LIBCXX_ENABLE_WIDE_CHARACTERS _LIBCPP_HAS_NO_WIDE_CHARACTERS)
+config_define_if_not(LIBCXX_ENABLE_LONG_DOUBLE_MATH _LIBCPP_HAS_NO_LONG_DOUBLE_MATH)
 config_define_if_not(LIBCXX_ENABLE_VENDOR_AVAILABILITY_ANNOTATIONS _LIBCPP_HAS_NO_VENDOR_AVAILABILITY_ANNOTATIONS)
 config_define_if(LIBCXX_ENABLE_DEBUG_MODE _LIBCPP_ENABLE_DEBUG_MODE)
 if (LIBCXX_ENABLE_ASSERTIONS)
Index: libcxx/cmake/caches/Generic-no-long-double-math.cmake
===================================================================
--- /dev/null
+++ libcxx/cmake/caches/Generic-no-long-double-math.cmake
@@ -0,0 +1 @@
+set(LIBCXX_ENABLE_LONG_DOUBLE_MATH OFF CACHE BOOL "")
Index: libcxx/docs/BuildingLibcxx.rst
===================================================================
--- libcxx/docs/BuildingLibcxx.rst
+++ libcxx/docs/BuildingLibcxx.rst
@@ -265,6 +265,16 @@
    support for ``wchar_t``. This is especially useful in embedded settings where
    C Standard Libraries don't always provide all the usual bells and whistles.
 
+.. option:: LIBCXX_ENABLE_LONG_DOUBLE_MATH:BOOL
+
+   **Default**: ``ON``
+
+   This option can be used to disable support for ``long double`` in the math
+   library. It also allows the math library to work on top of a C Standard
+   Library that does not provide support for ``long double`` math functions.
+   This is especially useful in embedded settings where C Standard Libraries
+   don't always provide all the usual bells and whistles.
+
 .. option:: LIBCXX_INSTALL_LIBRARY_DIR:PATH
 
   **Default**: ``lib${LIBCXX_LIBDIR_SUFFIX}``
Index: libcxx/include/__config_site.in
===================================================================
--- libcxx/include/__config_site.in
+++ libcxx/include/__config_site.in
@@ -29,6 +29,7 @@
 #cmakedefine _LIBCPP_HAS_NO_RANDOM_DEVICE
 #cmakedefine _LIBCPP_HAS_NO_LOCALIZATION
 #cmakedefine _LIBCPP_HAS_NO_WIDE_CHARACTERS
+#cmakedefine _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 #cmakedefine01 _LIBCPP_ENABLE_ASSERTIONS_DEFAULT
 #cmakedefine _LIBCPP_ENABLE_DEBUG_MODE
 
Index: libcxx/include/cmath
===================================================================
--- libcxx/include/cmath
+++ libcxx/include/cmath
@@ -541,7 +541,9 @@
 #if _LIBCPP_STD_VER > 14
 inline _LIBCPP_INLINE_VISIBILITY float       hypot(       float __x,       float __y,       float __z ) { return sqrt(__x*__x + __y*__y + __z*__z); }
 inline _LIBCPP_INLINE_VISIBILITY double      hypot(      double __x,      double __y,      double __z ) { return sqrt(__x*__x + __y*__y + __z*__z); }
+#  ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double hypot( long double __x, long double __y, long double __z ) { return sqrt(__x*__x + __y*__y + __z*__z); }
+#  endif
 
 template <class _A1, class _A2, class _A3>
 inline _LIBCPP_INLINE_VISIBILITY
Index: libcxx/include/math.h
===================================================================
--- libcxx/include/math.h
+++ libcxx/include/math.h
@@ -510,9 +510,11 @@
 bool
 isinf(double __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); }
 
+#  ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 isinf(long double __lcpp_x) _NOEXCEPT { return __libcpp_isinf(__lcpp_x); }
+#  endif // !_LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 #endif
 
 #endif // isinf
@@ -558,9 +560,11 @@
 bool
 isnan(double __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); }
 
+#  ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 isnan(long double __lcpp_x) _NOEXCEPT { return __libcpp_isnan(__lcpp_x); }
+#  endif // !_LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 #endif
 
 #endif // isnan
@@ -791,7 +795,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       acos(float __lcpp_x) _NOEXCEPT       {return ::acosf(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double acos(long double __lcpp_x) _NOEXCEPT {return ::acosl(__lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -803,7 +809,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       asin(float __lcpp_x) _NOEXCEPT       {return ::asinf(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double asin(long double __lcpp_x) _NOEXCEPT {return ::asinl(__lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -815,7 +823,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       atan(float __lcpp_x) _NOEXCEPT       {return ::atanf(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double atan(long double __lcpp_x) _NOEXCEPT {return ::atanl(__lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -827,7 +837,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       atan2(float __lcpp_y, float __lcpp_x) _NOEXCEPT             {return ::atan2f(__lcpp_y, __lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double atan2(long double __lcpp_y, long double __lcpp_x) _NOEXCEPT {return ::atan2l(__lcpp_y, __lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1, class _A2>
@@ -850,7 +862,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       ceil(float __lcpp_x) _NOEXCEPT       {return ::ceilf(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double ceil(long double __lcpp_x) _NOEXCEPT {return ::ceill(__lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -862,7 +876,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       cos(float __lcpp_x) _NOEXCEPT       {return ::cosf(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double cos(long double __lcpp_x) _NOEXCEPT {return ::cosl(__lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -874,7 +890,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       cosh(float __lcpp_x) _NOEXCEPT       {return ::coshf(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double cosh(long double __lcpp_x) _NOEXCEPT {return ::coshl(__lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -886,7 +904,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       exp(float __lcpp_x) _NOEXCEPT       {return ::expf(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double exp(long double __lcpp_x) _NOEXCEPT {return ::expl(__lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -898,7 +918,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       fabs(float __lcpp_x) _NOEXCEPT       {return ::fabsf(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double fabs(long double __lcpp_x) _NOEXCEPT {return ::fabsl(__lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -910,7 +932,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       floor(float __lcpp_x) _NOEXCEPT       {return ::floorf(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double floor(long double __lcpp_x) _NOEXCEPT {return ::floorl(__lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -922,7 +946,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       fmod(float __lcpp_x, float __lcpp_y) _NOEXCEPT             {return ::fmodf(__lcpp_x, __lcpp_y);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double fmod(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fmodl(__lcpp_x, __lcpp_y);}
+#      endif
 #    endif
 
 template <class _A1, class _A2>
@@ -945,7 +971,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       frexp(float __lcpp_x, int* __lcpp_e) _NOEXCEPT       {return ::frexpf(__lcpp_x, __lcpp_e);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double frexp(long double __lcpp_x, int* __lcpp_e) _NOEXCEPT {return ::frexpl(__lcpp_x, __lcpp_e);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -957,7 +985,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       ldexp(float __lcpp_x, int __lcpp_e) _NOEXCEPT       {return ::ldexpf(__lcpp_x, __lcpp_e);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double ldexp(long double __lcpp_x, int __lcpp_e) _NOEXCEPT {return ::ldexpl(__lcpp_x, __lcpp_e);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -969,7 +999,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       log(float __lcpp_x) _NOEXCEPT       {return ::logf(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double log(long double __lcpp_x) _NOEXCEPT {return ::logl(__lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -981,7 +1013,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       log10(float __lcpp_x) _NOEXCEPT       {return ::log10f(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double log10(long double __lcpp_x) _NOEXCEPT {return ::log10l(__lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -993,14 +1027,18 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       modf(float __lcpp_x, float* __lcpp_y) _NOEXCEPT             {return ::modff(__lcpp_x, __lcpp_y);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double modf(long double __lcpp_x, long double* __lcpp_y) _NOEXCEPT {return ::modfl(__lcpp_x, __lcpp_y);}
+#      endif
 #    endif
 
 // pow
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       pow(float __lcpp_x, float __lcpp_y) _NOEXCEPT             {return ::powf(__lcpp_x, __lcpp_y);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double pow(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::powl(__lcpp_x, __lcpp_y);}
+#      endif
 #    endif
 
 template <class _A1, class _A2>
@@ -1023,8 +1061,10 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       sin(float __lcpp_x) _NOEXCEPT       {return ::sinf(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double sin(long double __lcpp_x) _NOEXCEPT {return ::sinl(__lcpp_x);}
-#endif
+#      endif
+#    endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1035,7 +1075,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       sinh(float __lcpp_x) _NOEXCEPT       {return ::sinhf(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double sinh(long double __lcpp_x) _NOEXCEPT {return ::sinhl(__lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -1047,7 +1089,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       sqrt(float __lcpp_x) _NOEXCEPT       {return ::sqrtf(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double sqrt(long double __lcpp_x) _NOEXCEPT {return ::sqrtl(__lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -1059,7 +1103,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       tan(float __lcpp_x) _NOEXCEPT       {return ::tanf(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double tan(long double __lcpp_x) _NOEXCEPT {return ::tanl(__lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -1071,7 +1117,9 @@
 
 #    if !defined(__sun__)
 inline _LIBCPP_INLINE_VISIBILITY float       tanh(float __lcpp_x) _NOEXCEPT       {return ::tanhf(__lcpp_x);}
+#      ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double tanh(long double __lcpp_x) _NOEXCEPT {return ::tanhl(__lcpp_x);}
+#      endif
 #    endif
 
 template <class _A1>
@@ -1082,7 +1130,9 @@
 // acosh
 
 inline _LIBCPP_INLINE_VISIBILITY float       acosh(float __lcpp_x) _NOEXCEPT       {return ::acoshf(__lcpp_x);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double acosh(long double __lcpp_x) _NOEXCEPT {return ::acoshl(__lcpp_x);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1092,7 +1142,9 @@
 // asinh
 
 inline _LIBCPP_INLINE_VISIBILITY float       asinh(float __lcpp_x) _NOEXCEPT       {return ::asinhf(__lcpp_x);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double asinh(long double __lcpp_x) _NOEXCEPT {return ::asinhl(__lcpp_x);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1102,7 +1154,10 @@
 // atanh
 
 inline _LIBCPP_INLINE_VISIBILITY float       atanh(float __lcpp_x) _NOEXCEPT       {return ::atanhf(__lcpp_x);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double atanh(long double __lcpp_x) _NOEXCEPT {return ::atanhl(__lcpp_x);}
+#endif
+
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1112,7 +1167,9 @@
 // cbrt
 
 inline _LIBCPP_INLINE_VISIBILITY float       cbrt(float __lcpp_x) _NOEXCEPT       {return ::cbrtf(__lcpp_x);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double cbrt(long double __lcpp_x) _NOEXCEPT {return ::cbrtl(__lcpp_x);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1143,16 +1200,18 @@
 #endif
 }
 
-#if __has_builtin(__builtin_copysignl)
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
+#  if __has_builtin(__builtin_copysignl)
 _LIBCPP_CONSTEXPR
-#endif
+#  endif
 inline _LIBCPP_INLINE_VISIBILITY long double __libcpp_copysign(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {
-#if __has_builtin(__builtin_copysignl)
+#  if __has_builtin(__builtin_copysignl)
   return __builtin_copysignl(__lcpp_x, __lcpp_y);
-#else
+#  else
   return ::copysignl(__lcpp_x, __lcpp_y);
-#endif
+#  endif
 }
+#endif // !_LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 
 template <class _A1, class _A2>
 #if __has_builtin(__builtin_copysign)
@@ -1180,9 +1239,11 @@
   return ::__libcpp_copysign(__lcpp_x, __lcpp_y);
 }
 
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double copysign(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {
   return ::__libcpp_copysign(__lcpp_x, __lcpp_y);
 }
+#endif
 
 template <class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1199,7 +1260,9 @@
 // erf
 
 inline _LIBCPP_INLINE_VISIBILITY float       erf(float __lcpp_x) _NOEXCEPT       {return ::erff(__lcpp_x);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double erf(long double __lcpp_x) _NOEXCEPT {return ::erfl(__lcpp_x);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1209,7 +1272,9 @@
 // erfc
 
 inline _LIBCPP_INLINE_VISIBILITY float       erfc(float __lcpp_x) _NOEXCEPT       {return ::erfcf(__lcpp_x);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double erfc(long double __lcpp_x) _NOEXCEPT {return ::erfcl(__lcpp_x);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1219,7 +1284,9 @@
 // exp2
 
 inline _LIBCPP_INLINE_VISIBILITY float       exp2(float __lcpp_x) _NOEXCEPT       {return ::exp2f(__lcpp_x);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double exp2(long double __lcpp_x) _NOEXCEPT {return ::exp2l(__lcpp_x);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1229,7 +1296,9 @@
 // expm1
 
 inline _LIBCPP_INLINE_VISIBILITY float       expm1(float __lcpp_x) _NOEXCEPT       {return ::expm1f(__lcpp_x);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double expm1(long double __lcpp_x) _NOEXCEPT {return ::expm1l(__lcpp_x);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1239,7 +1308,9 @@
 // fdim
 
 inline _LIBCPP_INLINE_VISIBILITY float       fdim(float __lcpp_x, float __lcpp_y) _NOEXCEPT             {return ::fdimf(__lcpp_x, __lcpp_y);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double fdim(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fdiml(__lcpp_x, __lcpp_y);}
+#endif
 
 template <class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1267,14 +1338,16 @@
     return ::fmaf(__lcpp_x, __lcpp_y, __lcpp_z);
 #endif
 }
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double fma(long double __lcpp_x, long double __lcpp_y, long double __lcpp_z) _NOEXCEPT
 {
-#if __has_builtin(__builtin_fmal)
+#  if __has_builtin(__builtin_fmal)
     return __builtin_fmal(__lcpp_x, __lcpp_y, __lcpp_z);
-#else
+#  else
     return ::fmal(__lcpp_x, __lcpp_y, __lcpp_z);
-#endif
+#  endif
 }
+#endif // !_LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 
 template <class _A1, class _A2, class _A3>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1301,7 +1374,9 @@
 // fmax
 
 inline _LIBCPP_INLINE_VISIBILITY float       fmax(float __lcpp_x, float __lcpp_y) _NOEXCEPT             {return ::fmaxf(__lcpp_x, __lcpp_y);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double fmax(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fmaxl(__lcpp_x, __lcpp_y);}
+#endif
 
 template <class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1322,7 +1397,9 @@
 // fmin
 
 inline _LIBCPP_INLINE_VISIBILITY float       fmin(float __lcpp_x, float __lcpp_y) _NOEXCEPT             {return ::fminf(__lcpp_x, __lcpp_y);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double fmin(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::fminl(__lcpp_x, __lcpp_y);}
+#endif
 
 template <class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1343,7 +1420,9 @@
 // hypot
 
 inline _LIBCPP_INLINE_VISIBILITY float       hypot(float __lcpp_x, float __lcpp_y) _NOEXCEPT             {return ::hypotf(__lcpp_x, __lcpp_y);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double hypot(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::hypotl(__lcpp_x, __lcpp_y);}
+#endif
 
 template <class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1364,7 +1443,9 @@
 // ilogb
 
 inline _LIBCPP_INLINE_VISIBILITY int ilogb(float __lcpp_x) _NOEXCEPT       {return ::ilogbf(__lcpp_x);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY int ilogb(long double __lcpp_x) _NOEXCEPT {return ::ilogbl(__lcpp_x);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1374,7 +1455,9 @@
 // lgamma
 
 inline _LIBCPP_INLINE_VISIBILITY float       lgamma(float __lcpp_x) _NOEXCEPT       {return ::lgammaf(__lcpp_x);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double lgamma(long double __lcpp_x) _NOEXCEPT {return ::lgammal(__lcpp_x);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1391,14 +1474,16 @@
     return ::llrintf(__lcpp_x);
 #endif
 }
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long long llrint(long double __lcpp_x) _NOEXCEPT
 {
-#if __has_builtin(__builtin_llrintl)
+#  if __has_builtin(__builtin_llrintl)
     return __builtin_llrintl(__lcpp_x);
-#else
+#  else
     return ::llrintl(__lcpp_x);
-#endif
+#  endif
 }
+#endif // !_LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1422,14 +1507,16 @@
     return ::llroundf(__lcpp_x);
 #endif
 }
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long long llround(long double __lcpp_x) _NOEXCEPT
 {
-#if __has_builtin(__builtin_llroundl)
+#  if __has_builtin(__builtin_llroundl)
     return __builtin_llroundl(__lcpp_x);
-#else
+#  else
     return ::llroundl(__lcpp_x);
-#endif
+#  endif
 }
+#endif // !_LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1446,7 +1533,9 @@
 // log1p
 
 inline _LIBCPP_INLINE_VISIBILITY float       log1p(float __lcpp_x) _NOEXCEPT       {return ::log1pf(__lcpp_x);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double log1p(long double __lcpp_x) _NOEXCEPT {return ::log1pl(__lcpp_x);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1456,7 +1545,9 @@
 // log2
 
 inline _LIBCPP_INLINE_VISIBILITY float       log2(float __lcpp_x) _NOEXCEPT       {return ::log2f(__lcpp_x);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double log2(long double __lcpp_x) _NOEXCEPT {return ::log2l(__lcpp_x);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1466,7 +1557,9 @@
 // logb
 
 inline _LIBCPP_INLINE_VISIBILITY float       logb(float __lcpp_x) _NOEXCEPT       {return ::logbf(__lcpp_x);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double logb(long double __lcpp_x) _NOEXCEPT {return ::logbl(__lcpp_x);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1483,14 +1576,16 @@
     return ::lrintf(__lcpp_x);
 #endif
 }
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long lrint(long double __lcpp_x) _NOEXCEPT
 {
-#if __has_builtin(__builtin_lrintl)
+#  if __has_builtin(__builtin_lrintl)
     return __builtin_lrintl(__lcpp_x);
-#else
+#  else
     return ::lrintl(__lcpp_x);
-#endif
+#  endif
 }
+#endif // !_LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1514,14 +1609,16 @@
     return ::lroundf(__lcpp_x);
 #endif
 }
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long lround(long double __lcpp_x) _NOEXCEPT
 {
-#if __has_builtin(__builtin_lroundl)
+#  if __has_builtin(__builtin_lroundl)
     return __builtin_lroundl(__lcpp_x);
-#else
+#  else
     return ::lroundl(__lcpp_x);
-#endif
+#  endif
 }
+#endif // !_LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1540,7 +1637,9 @@
 // nearbyint
 
 inline _LIBCPP_INLINE_VISIBILITY float       nearbyint(float __lcpp_x) _NOEXCEPT       {return ::nearbyintf(__lcpp_x);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double nearbyint(long double __lcpp_x) _NOEXCEPT {return ::nearbyintl(__lcpp_x);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1550,7 +1649,9 @@
 // nextafter
 
 inline _LIBCPP_INLINE_VISIBILITY float       nextafter(float __lcpp_x, float __lcpp_y) _NOEXCEPT             {return ::nextafterf(__lcpp_x, __lcpp_y);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double nextafter(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nextafterl(__lcpp_x, __lcpp_y);}
+#endif
 
 template <class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1570,6 +1671,7 @@
 
 // nexttoward
 
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY float       nexttoward(float __lcpp_x, long double __lcpp_y) _NOEXCEPT       {return ::nexttowardf(__lcpp_x, __lcpp_y);}
 inline _LIBCPP_INLINE_VISIBILITY long double nexttoward(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttowardl(__lcpp_x, __lcpp_y);}
 
@@ -1577,11 +1679,14 @@
 inline _LIBCPP_INLINE_VISIBILITY
 typename std::enable_if<std::is_integral<_A1>::value, double>::type
 nexttoward(_A1 __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::nexttoward((double)__lcpp_x, __lcpp_y);}
+#endif // !_LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 
 // remainder
 
 inline _LIBCPP_INLINE_VISIBILITY float       remainder(float __lcpp_x, float __lcpp_y) _NOEXCEPT             {return ::remainderf(__lcpp_x, __lcpp_y);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double remainder(long double __lcpp_x, long double __lcpp_y) _NOEXCEPT {return ::remainderl(__lcpp_x, __lcpp_y);}
+#endif
 
 template <class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1602,7 +1707,9 @@
 // remquo
 
 inline _LIBCPP_INLINE_VISIBILITY float       remquo(float __lcpp_x, float __lcpp_y, int* __lcpp_z) _NOEXCEPT             {return ::remquof(__lcpp_x, __lcpp_y, __lcpp_z);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double remquo(long double __lcpp_x, long double __lcpp_y, int* __lcpp_z) _NOEXCEPT {return ::remquol(__lcpp_x, __lcpp_y, __lcpp_z);}
+#endif
 
 template <class _A1, class _A2>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1630,14 +1737,16 @@
     return ::rintf(__lcpp_x);
 #endif
 }
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double rint(long double __lcpp_x) _NOEXCEPT
 {
-#if __has_builtin(__builtin_rintl)
+#  if __has_builtin(__builtin_rintl)
     return __builtin_rintl(__lcpp_x);
-#else
+#  else
     return ::rintl(__lcpp_x);
-#endif
+#  endif
 }
+#endif // !_LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1661,14 +1770,16 @@
     return ::round(__lcpp_x);
 #endif
 }
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double round(long double __lcpp_x) _NOEXCEPT
 {
-#if __has_builtin(__builtin_roundl)
+#  if __has_builtin(__builtin_roundl)
     return __builtin_roundl(__lcpp_x);
-#else
+#  else
     return ::roundl(__lcpp_x);
-#endif
+#  endif
 }
+#endif // !_LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1685,7 +1796,9 @@
 // scalbln
 
 inline _LIBCPP_INLINE_VISIBILITY float       scalbln(float __lcpp_x, long __lcpp_y) _NOEXCEPT       {return ::scalblnf(__lcpp_x, __lcpp_y);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double scalbln(long double __lcpp_x, long __lcpp_y) _NOEXCEPT {return ::scalblnl(__lcpp_x, __lcpp_y);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1695,7 +1808,9 @@
 // scalbn
 
 inline _LIBCPP_INLINE_VISIBILITY float       scalbn(float __lcpp_x, int __lcpp_y) _NOEXCEPT       {return ::scalbnf(__lcpp_x, __lcpp_y);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double scalbn(long double __lcpp_x, int __lcpp_y) _NOEXCEPT {return ::scalbnl(__lcpp_x, __lcpp_y);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1705,7 +1820,9 @@
 // tgamma
 
 inline _LIBCPP_INLINE_VISIBILITY float       tgamma(float __lcpp_x) _NOEXCEPT       {return ::tgammaf(__lcpp_x);}
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double tgamma(long double __lcpp_x) _NOEXCEPT {return ::tgammal(__lcpp_x);}
+#endif
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1722,14 +1839,16 @@
     return ::trunc(__lcpp_x);
 #endif
 }
+#ifndef _LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 inline _LIBCPP_INLINE_VISIBILITY long double trunc(long double __lcpp_x) _NOEXCEPT
 {
-#if __has_builtin(__builtin_truncl)
+#  if __has_builtin(__builtin_truncl)
     return __builtin_truncl(__lcpp_x);
-#else
+#  else
     return ::truncl(__lcpp_x);
-#endif
+#  endif
 }
+#endif // !_LIBCPP_HAS_NO_LONG_DOUBLE_MATH
 
 template <class _A1>
 inline _LIBCPP_INLINE_VISIBILITY
Index: libcxx/test/std/depr/depr.c.headers/math_h.pass.cpp
===================================================================
--- libcxx/test/std/depr/depr.c.headers/math_h.pass.cpp
+++ libcxx/test/std/depr/depr.c.headers/math_h.pass.cpp
@@ -113,8 +113,10 @@
 
   static_assert((std::is_same<decltype(abs((float)0)), float>::value), "");
   static_assert((std::is_same<decltype(abs((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
   static_assert(
       (std::is_same<decltype(abs((long double)0)), long double>::value), "");
+#endif
   static_assert((std::is_same<decltype(abs((int)0)), int>::value), "");
   static_assert((std::is_same<decltype(abs((long)0)), long>::value), "");
   static_assert((std::is_same<decltype(abs((long long)0)), long long>::value),
@@ -148,9 +150,13 @@
     static_assert((std::is_same<decltype(acos((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(acos((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(acos((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(acos((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(acosf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(acosl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(acos(Ambiguous())), Ambiguous>::value), "");
     assert(acos(1) == 0);
 }
@@ -167,9 +173,13 @@
     static_assert((std::is_same<decltype(asin((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(asin((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(asin((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(asin((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(asinf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(asinl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(asin(Ambiguous())), Ambiguous>::value), "");
     assert(asin(0) == 0);
 }
@@ -186,9 +196,13 @@
     static_assert((std::is_same<decltype(atan((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(atan((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(atan((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(atan((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(atanf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(atanl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(atan(Ambiguous())), Ambiguous>::value), "");
     assert(atan(0) == 0);
 }
@@ -198,19 +212,29 @@
     static_assert((std::is_same<decltype(atan2((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(atan2((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(atan2((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(atan2((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(atan2((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(atan2((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(atan2((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(atan2((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(atan2((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(atan2((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(atan2((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(atan2((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(atan2((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(atan2((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(atan2f(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(atan2l(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(atan2((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(atan2(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(atan2(0,1) == 0);
@@ -228,9 +252,13 @@
     static_assert((std::is_same<decltype(ceil((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(ceil((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(ceil((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(ceil((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(ceilf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(ceill(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(ceil(Ambiguous())), Ambiguous>::value), "");
     assert(ceil(0) == 0);
 }
@@ -247,9 +275,13 @@
     static_assert((std::is_same<decltype(cos((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(cos((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(cos((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(cos((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(cosf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(cosl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(cos(Ambiguous())), Ambiguous>::value), "");
     assert(cos(0) == 1);
 }
@@ -266,9 +298,13 @@
     static_assert((std::is_same<decltype(cosh((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(cosh((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(cosh((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(cosh((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(coshf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(coshl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(cosh(Ambiguous())), Ambiguous>::value), "");
     assert(cosh(0) == 1);
 }
@@ -285,9 +321,13 @@
     static_assert((std::is_same<decltype(exp((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(exp((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(exp((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(exp((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(expf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(expl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(exp(Ambiguous())), Ambiguous>::value), "");
     assert(exp(0) == 1);
 }
@@ -304,9 +344,13 @@
     static_assert((std::is_same<decltype(fabs((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(fabs((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(fabs((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fabs((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fabsf(0.0f)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fabsl(0.0L)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fabs(Ambiguous())), Ambiguous>::value), "");
     assert(fabs(-1) == 1);
 }
@@ -323,9 +367,13 @@
     static_assert((std::is_same<decltype(floor((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(floor((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(floor((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(floor((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(floorf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(floorl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(floor(Ambiguous())), Ambiguous>::value), "");
     assert(floor(1) == 1);
 }
@@ -335,19 +383,29 @@
     static_assert((std::is_same<decltype(fmod((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(fmod((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmod((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fmod((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fmod((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmod((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fmod((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fmod((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmod((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmod((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fmod((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fmod((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fmod((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(fmod((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fmodf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fmodl(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fmod((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmod(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(fmod(1.5,1) == .5);
@@ -366,9 +424,13 @@
     static_assert((std::is_same<decltype(frexp((long long)0, &ip)), double>::value), "");
     static_assert((std::is_same<decltype(frexp((unsigned long long)0, &ip)), double>::value), "");
     static_assert((std::is_same<decltype(frexp((double)0, &ip)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(frexp((long double)0, &ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(frexpf(0, &ip)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(frexpl(0, &ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(frexp(Ambiguous(), &ip)), Ambiguous>::value), "");
     assert(frexp(0, &ip) == 0);
 }
@@ -386,9 +448,13 @@
     static_assert((std::is_same<decltype(ldexp((long long)0, ip)), double>::value), "");
     static_assert((std::is_same<decltype(ldexp((unsigned long long)0, ip)), double>::value), "");
     static_assert((std::is_same<decltype(ldexp((double)0, ip)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(ldexp((long double)0, ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(ldexpf(0, ip)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(ldexpl(0, ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(ldexp(Ambiguous(), ip)), Ambiguous>::value), "");
     assert(ldexp(1, ip) == 2);
 }
@@ -405,9 +471,13 @@
     static_assert((std::is_same<decltype(log((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(log((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(log((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(log((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(logf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(logl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(log(Ambiguous())), Ambiguous>::value), "");
     assert(log(1) == 0);
 }
@@ -424,9 +494,13 @@
     static_assert((std::is_same<decltype(log10((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(log10((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(log10((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(log10((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(log10f(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(log10l(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(log10(Ambiguous())), Ambiguous>::value), "");
     assert(log10(1) == 0);
 }
@@ -435,9 +509,13 @@
 {
     static_assert((std::is_same<decltype(modf((float)0, (float*)0)), float>::value), "");
     static_assert((std::is_same<decltype(modf((double)0, (double*)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(modf((long double)0, (long double*)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(modff(0, (float*)0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(modfl(0, (long double*)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(modf(Ambiguous(), (Ambiguous*)0)), Ambiguous>::value), "");
     double i;
     assert(modf(1., &i) == 0);
@@ -448,29 +526,43 @@
     static_assert((std::is_same<decltype(pow((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(pow((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(pow((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(pow((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(pow((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(pow((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(pow((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(pow((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(pow((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(pow((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(pow((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(pow((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(pow((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(pow((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(powf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(powl(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(pow((int)0, (int)0)), double>::value), "");
 //     static_assert((std::is_same<decltype(pow(Value<int>(), (int)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
 //     static_assert((std::is_same<decltype(pow(Value<long double>(), (float)0)), long double>::value), "");
+#endif
 //     static_assert((std::is_same<decltype(pow((float) 0, Value<float>())), float>::value), "");
     static_assert((std::is_same<decltype(pow(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(pow(1,1) == 1);
 //     assert(pow(Value<int,1>(), Value<float,1>())  == 1);
 //     assert(pow(1.0f, Value<double,1>()) == 1);
 //     assert(pow(1.0, Value<int,1>()) == 1);
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
 //     assert(pow(Value<long double,1>(), 1LL) == 1);
+#endif
 }
 
 void test_sin()
@@ -485,9 +577,13 @@
     static_assert((std::is_same<decltype(sin((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(sin((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(sin((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(sin((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(sinf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(sinl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(sin(Ambiguous())), Ambiguous>::value), "");
     assert(sin(0) == 0);
 }
@@ -504,9 +600,13 @@
     static_assert((std::is_same<decltype(sinh((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(sinh((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(sinh((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(sinh((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(sinhf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(sinhl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(sinh(Ambiguous())), Ambiguous>::value), "");
     assert(sinh(0) == 0);
 }
@@ -523,9 +623,13 @@
     static_assert((std::is_same<decltype(sqrt((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(sqrt((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(sqrt((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(sqrt((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(sqrtf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(sqrtl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(sqrt(Ambiguous())), Ambiguous>::value), "");
     assert(sqrt(4) == 2);
 }
@@ -542,9 +646,13 @@
     static_assert((std::is_same<decltype(tan((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(tan((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(tan((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(tan((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(tanf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(tanl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(tan(Ambiguous())), Ambiguous>::value), "");
     assert(tan(0) == 0);
 }
@@ -561,9 +669,13 @@
     static_assert((std::is_same<decltype(tanh((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(tanh((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(tanh((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(tanh((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(tanhf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(tanhl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(tanh(Ambiguous())), Ambiguous>::value), "");
     assert(tanh(0) == 0);
 }
@@ -576,7 +688,9 @@
     static_assert((std::is_same<decltype(signbit((float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(signbit((double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(signbit(0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(signbit((long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(signbit(Ambiguous())), Ambiguous>::value), "");
     assert(signbit(-1.0) == true);
 }
@@ -589,7 +703,9 @@
     static_assert((std::is_same<decltype(fpclassify((float)0)), int>::value), "");
     static_assert((std::is_same<decltype(fpclassify((double)0)), int>::value), "");
     static_assert((std::is_same<decltype(fpclassify(0)), int>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fpclassify((long double)0)), int>::value), "");
+#endif
     static_assert((std::is_same<decltype(fpclassify(Ambiguous())), Ambiguous>::value), "");
     assert(fpclassify(-1.0) == FP_NORMAL);
 }
@@ -602,7 +718,9 @@
     static_assert((std::is_same<decltype(isfinite((float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isfinite((double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isfinite(0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(isfinite((long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isfinite(Ambiguous())), Ambiguous>::value), "");
     assert(isfinite(-1.0) == true);
 }
@@ -615,7 +733,9 @@
     static_assert((std::is_same<decltype(isnormal((float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isnormal((double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isnormal(0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(isnormal((long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isnormal(Ambiguous())), Ambiguous>::value), "");
     assert(isnormal(-1.0) == true);
 }
@@ -627,14 +747,18 @@
 #endif
     static_assert((std::is_same<decltype(isgreater((float)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isgreater((float)0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(isgreater((float)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isgreater((double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isgreater((double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isgreater(0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(isgreater((double)0, (long double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isgreater((long double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isgreater((long double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isgreater((long double)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isgreater(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(isgreater(-1.0, 0.F) == false);
 }
@@ -646,14 +770,18 @@
 #endif
     static_assert((std::is_same<decltype(isgreaterequal((float)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isgreaterequal((float)0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(isgreaterequal((float)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isgreaterequal((double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isgreaterequal((double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isgreaterequal(0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(isgreaterequal((double)0, (long double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isgreaterequal((long double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isgreaterequal((long double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isgreaterequal((long double)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isgreaterequal(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(isgreaterequal(-1.0, 0.F) == false);
 }
@@ -677,7 +805,9 @@
 #endif
 
     static_assert((std::is_same<decltype(isinf(0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(isinf((long double)0)), bool>::value), "");
+#endif
     assert(isinf(-1.0) == false);
 }
 
@@ -688,14 +818,18 @@
 #endif
     static_assert((std::is_same<decltype(isless((float)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isless((float)0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(isless((float)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isless((double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isless((double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isless(0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(isless((double)0, (long double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isless((long double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isless((long double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isless((long double)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isless(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(isless(-1.0, 0.F) == true);
 }
@@ -707,14 +841,18 @@
 #endif
     static_assert((std::is_same<decltype(islessequal((float)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(islessequal((float)0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(islessequal((float)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(islessequal((double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(islessequal((double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(islessequal(0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(islessequal((double)0, (long double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(islessequal((long double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(islessequal((long double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(islessequal((long double)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(islessequal(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(islessequal(-1.0, 0.F) == true);
 }
@@ -726,14 +864,18 @@
 #endif
     static_assert((std::is_same<decltype(islessgreater((float)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(islessgreater((float)0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(islessgreater((float)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(islessgreater((double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(islessgreater((double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(islessgreater(0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(islessgreater((double)0, (long double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(islessgreater((long double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(islessgreater((long double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(islessgreater((long double)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(islessgreater(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(islessgreater(-1.0, 0.F) == true);
 }
@@ -757,7 +899,9 @@
 #endif
 
     static_assert((std::is_same<decltype(isnan(0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(isnan((long double)0)), bool>::value), "");
+#endif
     assert(isnan(-1.0) == false);
 }
 
@@ -768,14 +912,18 @@
 #endif
     static_assert((std::is_same<decltype(isunordered((float)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isunordered((float)0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(isunordered((float)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isunordered((double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isunordered((double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isunordered(0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(isunordered((double)0, (long double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isunordered((long double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isunordered((long double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(isunordered((long double)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isunordered(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(isunordered(-1.0, 0.F) == false);
 }
@@ -792,9 +940,13 @@
     static_assert((std::is_same<decltype(acosh((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(acosh((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(acosh((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(acosh((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(acoshf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(acoshl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(acosh(Ambiguous())), Ambiguous>::value), "");
     assert(acosh(1) == 0);
 }
@@ -811,9 +963,13 @@
     static_assert((std::is_same<decltype(asinh((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(asinh((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(asinh((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(asinh((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(asinhf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(asinhl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(asinh(Ambiguous())), Ambiguous>::value), "");
     assert(asinh(0) == 0);
 }
@@ -830,9 +986,13 @@
     static_assert((std::is_same<decltype(atanh((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(atanh((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(atanh((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(atanh((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(atanhf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(atanhl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(atanh(Ambiguous())), Ambiguous>::value), "");
     assert(atanh(0) == 0);
 }
@@ -854,10 +1014,14 @@
                                 double>::value), "");
     static_assert((std::is_same<decltype(cbrt((double) 0)), double>::value),
                   "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(cbrt((long double) 0)),
                                 long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(cbrtf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(cbrtl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(cbrt(Ambiguous())), Ambiguous>::value),
                   "");
     assert(truncate_fp(cbrt(1)) == 1);
@@ -869,19 +1033,29 @@
     static_assert((std::is_same<decltype(copysign((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(copysign((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(copysign((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(copysign((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(copysign((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(copysign((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(copysign((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(copysign((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(copysign((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(copysign((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(copysign((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(copysign((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(copysign((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(copysign((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(copysignf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(copysignl(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(copysign((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(copysign(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(copysign(1,1) == 1);
@@ -899,9 +1073,13 @@
     static_assert((std::is_same<decltype(erf((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(erf((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(erf((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(erf((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(erff(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(erfl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(erf(Ambiguous())), Ambiguous>::value), "");
     assert(erf(0) == 0);
 }
@@ -918,9 +1096,13 @@
     static_assert((std::is_same<decltype(erfc((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(erfc((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(erfc((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(erfc((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(erfcf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(erfcl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(erfc(Ambiguous())), Ambiguous>::value), "");
     assert(erfc(0) == 1);
 }
@@ -937,9 +1119,13 @@
     static_assert((std::is_same<decltype(exp2((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(exp2((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(exp2((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(exp2((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(exp2f(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(exp2l(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(exp2(Ambiguous())), Ambiguous>::value), "");
     assert(exp2(1) == 2);
 }
@@ -956,9 +1142,13 @@
     static_assert((std::is_same<decltype(expm1((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(expm1((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(expm1((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(expm1((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(expm1f(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(expm1l(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(expm1(Ambiguous())), Ambiguous>::value), "");
     assert(expm1(0) == 0);
 }
@@ -968,19 +1158,29 @@
     static_assert((std::is_same<decltype(fdim((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(fdim((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(fdim((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fdim((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fdim((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(fdim((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fdim((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fdim((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(fdim((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(fdim((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fdim((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fdim((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fdim((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(fdim((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fdimf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fdiml(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fdim((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(fdim(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(fdim(1,0) == 1);
@@ -995,7 +1195,9 @@
     static_assert((std::is_same<decltype(fma((float)0, (long)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(fma((float)0, (float)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(fma((float)0, (float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fma((float)0, (float)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fma((float)0, (float)0, (float)0)), float>::value), "");
 
     static_assert((std::is_same<decltype(fma((bool)0, (double)0, (double)0)), double>::value), "");
@@ -1005,9 +1207,12 @@
     static_assert((std::is_same<decltype(fma((double)0, (long)0, (double)0)), double>::value), "");
     static_assert((std::is_same<decltype(fma((double)0, (double)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(fma((double)0, (double)0, (float)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fma((double)0, (double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fma((double)0, (double)0,  (double)0)), double>::value), "");
 
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fma((bool)0, (long double)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(fma((char)0, (long double)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(fma((unsigned)0, (long double)0, (long double)0)), long double>::value), "");
@@ -1017,9 +1222,12 @@
     static_assert((std::is_same<decltype(fma((long double)0, (long double)0, (float)0)), long double>::value), "");
     static_assert((std::is_same<decltype(fma((double)0, (long double)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(fma((long double)0, (long double)0, (long double)0)), long double>::value), "");
+#endif
 
     static_assert((std::is_same<decltype(fmaf(0,0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fmal(0,0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fma(Ambiguous(), Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(fma(1,1,1) == 2);
 }
@@ -1029,19 +1237,29 @@
     static_assert((std::is_same<decltype(fmax((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(fmax((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmax((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fmax((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fmax((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmax((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fmax((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fmax((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmax((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmax((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fmax((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fmax((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fmax((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(fmax((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fmaxf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fmaxl(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fmax((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmax(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(fmax(1,0) == 1);
@@ -1052,19 +1270,29 @@
     static_assert((std::is_same<decltype(fmin((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(fmin((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmin((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fmin((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fmin((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmin((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fmin((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fmin((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmin((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmin((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fmin((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fmin((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fmin((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(fmin((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fminf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(fminl(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fmin((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmin(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(fmin(1,0) == 0);
@@ -1075,19 +1303,29 @@
     static_assert((std::is_same<decltype(hypot((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(hypot((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(hypot((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(hypot((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(hypot((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(hypot((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(hypot((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(hypot((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(hypot((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(hypot((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(hypot((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(hypot((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(hypot((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(hypot((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(hypotf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(hypotl(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(hypot((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(hypot(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(hypot(3,4) == 5);
@@ -1105,7 +1343,9 @@
     static_assert((std::is_same<decltype(ilogb((long long)0)), int>::value), "");
     static_assert((std::is_same<decltype(ilogb((unsigned long long)0)), int>::value), "");
     static_assert((std::is_same<decltype(ilogb((double)0)), int>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(ilogb((long double)0)), int>::value), "");
+#endif
     static_assert((std::is_same<decltype(ilogbf(0)), int>::value), "");
     static_assert((std::is_same<decltype(ilogbl(0)), int>::value), "");
     static_assert((std::is_same<decltype(ilogb(Ambiguous())), Ambiguous>::value), "");
@@ -1124,9 +1364,13 @@
     static_assert((std::is_same<decltype(lgamma((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(lgamma((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(lgamma((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(lgamma((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(lgammaf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(lgammal(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(lgamma(Ambiguous())), Ambiguous>::value), "");
     assert(lgamma(1) == 0);
 }
@@ -1143,7 +1387,9 @@
     static_assert((std::is_same<decltype(llrint((long long)0)), long long>::value), "");
     static_assert((std::is_same<decltype(llrint((unsigned long long)0)), long long>::value), "");
     static_assert((std::is_same<decltype(llrint((double)0)), long long>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(llrint((long double)0)), long long>::value), "");
+#endif
     static_assert((std::is_same<decltype(llrintf(0)), long long>::value), "");
     static_assert((std::is_same<decltype(llrintl(0)), long long>::value), "");
     static_assert((std::is_same<decltype(llrint(Ambiguous())), Ambiguous>::value), "");
@@ -1162,7 +1408,9 @@
     static_assert((std::is_same<decltype(llround((long long)0)), long long>::value), "");
     static_assert((std::is_same<decltype(llround((unsigned long long)0)), long long>::value), "");
     static_assert((std::is_same<decltype(llround((double)0)), long long>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(llround((long double)0)), long long>::value), "");
+#endif
     static_assert((std::is_same<decltype(llroundf(0)), long long>::value), "");
     static_assert((std::is_same<decltype(llroundl(0)), long long>::value), "");
     static_assert((std::is_same<decltype(llround(Ambiguous())), Ambiguous>::value), "");
@@ -1181,9 +1429,13 @@
     static_assert((std::is_same<decltype(log1p((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(log1p((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(log1p((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(log1p((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(log1pf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(log1pl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(log1p(Ambiguous())), Ambiguous>::value), "");
     assert(log1p(0) == 0);
 }
@@ -1200,9 +1452,13 @@
     static_assert((std::is_same<decltype(log2((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(log2((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(log2((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(log2((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(log2f(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(log2l(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(log2(Ambiguous())), Ambiguous>::value), "");
     assert(log2(1) == 0);
 }
@@ -1219,9 +1475,13 @@
     static_assert((std::is_same<decltype(logb((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(logb((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(logb((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(logb((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(logbf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(logbl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(logb(Ambiguous())), Ambiguous>::value), "");
     assert(logb(1) == 0);
 }
@@ -1238,7 +1498,9 @@
     static_assert((std::is_same<decltype(lrint((long long)0)), long>::value), "");
     static_assert((std::is_same<decltype(lrint((unsigned long long)0)), long>::value), "");
     static_assert((std::is_same<decltype(lrint((double)0)), long>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(lrint((long double)0)), long>::value), "");
+#endif
     static_assert((std::is_same<decltype(lrintf(0)), long>::value), "");
     static_assert((std::is_same<decltype(lrintl(0)), long>::value), "");
     static_assert((std::is_same<decltype(lrint(Ambiguous())), Ambiguous>::value), "");
@@ -1257,7 +1519,9 @@
     static_assert((std::is_same<decltype(lround((long long)0)), long>::value), "");
     static_assert((std::is_same<decltype(lround((unsigned long long)0)), long>::value), "");
     static_assert((std::is_same<decltype(lround((double)0)), long>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(lround((long double)0)), long>::value), "");
+#endif
     static_assert((std::is_same<decltype(lroundf(0)), long>::value), "");
     static_assert((std::is_same<decltype(lroundl(0)), long>::value), "");
     static_assert((std::is_same<decltype(lround(Ambiguous())), Ambiguous>::value), "");
@@ -1268,7 +1532,9 @@
 {
     static_assert((std::is_same<decltype(nan("")), double>::value), "");
     static_assert((std::is_same<decltype(nanf("")), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(nanl("")), long double>::value), "");
+#endif
 }
 
 void test_nearbyint()
@@ -1283,9 +1549,13 @@
     static_assert((std::is_same<decltype(nearbyint((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(nearbyint((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(nearbyint((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(nearbyint((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(nearbyintf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(nearbyintl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(nearbyint(Ambiguous())), Ambiguous>::value), "");
     assert(nearbyint(1) == 1);
 }
@@ -1295,19 +1565,29 @@
     static_assert((std::is_same<decltype(nextafter((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(nextafter((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(nextafter((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(nextafter((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(nextafter((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(nextafter((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(nextafter((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(nextafter((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(nextafter((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(nextafter((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(nextafter((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(nextafter((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(nextafter((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(nextafter((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(nextafterf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(nextafterl(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(nextafter((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(nextafter(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(nextafter(0,1) == hexfloat<double>(0x1, 0, -1074));
@@ -1315,6 +1595,7 @@
 
 void test_nexttoward()
 {
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(nexttoward((float)0, (long double)0)), float>::value), "");
     static_assert((std::is_same<decltype(nexttoward((bool)0, (long double)0)), double>::value), "");
     static_assert((std::is_same<decltype(nexttoward((unsigned short)0, (long double)0)), double>::value), "");
@@ -1328,6 +1609,7 @@
     static_assert((std::is_same<decltype(nexttoward((long double)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(nexttowardf(0, (long double)0)), float>::value), "");
     static_assert((std::is_same<decltype(nexttowardl(0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(nexttoward(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(nexttoward(0, 1) == hexfloat<double>(0x1, 0, -1074));
 }
@@ -1337,19 +1619,29 @@
     static_assert((std::is_same<decltype(remainder((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(remainder((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(remainder((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(remainder((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(remainder((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(remainder((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(remainder((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(remainder((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(remainder((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(remainder((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(remainder((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(remainder((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(remainder((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(remainder((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(remainderf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(remainderl(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(remainder((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(remainder(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(remainder(0.5,1) == 0.5);
@@ -1361,19 +1653,29 @@
     static_assert((std::is_same<decltype(remquo((float)0, (float)0, &ip)), float>::value), "");
     static_assert((std::is_same<decltype(remquo((bool)0, (float)0, &ip)), double>::value), "");
     static_assert((std::is_same<decltype(remquo((unsigned short)0, (double)0, &ip)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(remquo((int)0, (long double)0, &ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(remquo((float)0, (unsigned int)0, &ip)), double>::value), "");
     static_assert((std::is_same<decltype(remquo((double)0, (long)0, &ip)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(remquo((long double)0, (unsigned long)0, &ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(remquo((int)0, (long long)0, &ip)), double>::value), "");
     static_assert((std::is_same<decltype(remquo((int)0, (unsigned long long)0, &ip)), double>::value), "");
     static_assert((std::is_same<decltype(remquo((double)0, (double)0, &ip)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(remquo((long double)0, (long double)0, &ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(remquo((float)0, (double)0, &ip)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(remquo((float)0, (long double)0, &ip)), long double>::value), "");
     static_assert((std::is_same<decltype(remquo((double)0, (long double)0, &ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(remquof(0,0, &ip)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(remquol(0,0, &ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(remquo((int)0, (int)0, &ip)), double>::value), "");
     static_assert((std::is_same<decltype(remquo(Ambiguous(), Ambiguous(), &ip)), Ambiguous>::value), "");
     assert(remquo(0.5,1, &ip) == 0.5);
@@ -1391,9 +1693,13 @@
     static_assert((std::is_same<decltype(rint((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(rint((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(rint((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(rint((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(rintf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(rintl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(rint(Ambiguous())), Ambiguous>::value), "");
     assert(rint(1) == 1);
 }
@@ -1410,9 +1716,13 @@
     static_assert((std::is_same<decltype(round((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(round((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(round((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(round((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(roundf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(roundl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(round(Ambiguous())), Ambiguous>::value), "");
     assert(round(1) == 1);
 }
@@ -1429,9 +1739,13 @@
     static_assert((std::is_same<decltype(scalbln((long long)0, (long)0)), double>::value), "");
     static_assert((std::is_same<decltype(scalbln((unsigned long long)0, (long)0)), double>::value), "");
     static_assert((std::is_same<decltype(scalbln((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(scalbln((long double)0, (long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(scalblnf(0, (long)0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(scalblnl(0, (long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(scalbln(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(scalbln(1, 1) == 2);
 }
@@ -1448,9 +1762,13 @@
     static_assert((std::is_same<decltype(scalbn((long long)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(scalbn((unsigned long long)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(scalbn((double)0, (int)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(scalbn((long double)0, (int)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(scalbnf(0, (int)0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(scalbnl(0, (int)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(scalbn(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(scalbn(1, 1) == 2);
 }
@@ -1467,9 +1785,13 @@
     static_assert((std::is_same<decltype(tgamma((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(tgamma((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(tgamma((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(tgamma((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(tgammaf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(tgammal(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(tgamma(Ambiguous())), Ambiguous>::value), "");
     assert(tgamma(1) == 1);
 }
@@ -1486,9 +1808,13 @@
     static_assert((std::is_same<decltype(trunc((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(trunc((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(trunc((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(trunc((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(truncf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(truncl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(trunc(Ambiguous())), Ambiguous>::value), "");
     assert(trunc(1) == 1);
 }
Index: libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
===================================================================
--- libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
+++ libcxx/test/std/localization/locale.categories/category.numeric/locale.num.get/facet.num.get.members/get_long_double.pass.cpp
@@ -85,6 +85,7 @@
         assert(err == ios.goodbit);
         assert(v == 125e-1);
     }
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     {
         const char str[] = "0x125p-1";
         std::hex(ios);
@@ -97,6 +98,7 @@
         assert(err == ios.goodbit);
         assert(v == hexfloat<long double>(0x125, 0, -1));
     }
+#endif
     {
         const char str[] = "inf";
         std::hex(ios);
Index: libcxx/test/std/numerics/c.math/abs.pass.cpp
===================================================================
--- libcxx/test/std/numerics/c.math/abs.pass.cpp
+++ libcxx/test/std/numerics/c.math/abs.pass.cpp
@@ -68,7 +68,9 @@
     test_abs<std::int32_t, correct_size_int<std::int32_t>::type>();
     test_abs<std::int64_t, correct_size_int<std::int64_t>::type>();
 
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test_abs<long double, long double>();
+#endif
     test_abs<double, double>();
     test_abs<float, float>();
 
Index: libcxx/test/std/numerics/c.math/cmath.pass.cpp
===================================================================
--- libcxx/test/std/numerics/c.math/cmath.pass.cpp
+++ libcxx/test/std/numerics/c.math/cmath.pass.cpp
@@ -118,7 +118,9 @@
 
     static_assert((std::is_same<decltype(std::abs((float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::abs((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::abs((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::abs((int)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::abs((long)0)), long>::value), "");
     static_assert((std::is_same<decltype(std::abs((long long)0)), long long>::value), "");
@@ -153,9 +155,13 @@
     static_assert((std::is_same<decltype(std::acos((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::acos((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::acos((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::acos((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::acosf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::acosl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(acos(Ambiguous())), Ambiguous>::value), "");
     assert(std::acos(1) == 0);
 }
@@ -172,9 +178,13 @@
     static_assert((std::is_same<decltype(std::asin((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::asin((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::asin((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::asin((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::asinf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::asinl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(asin(Ambiguous())), Ambiguous>::value), "");
     assert(std::asin(0) == 0);
 }
@@ -191,9 +201,13 @@
     static_assert((std::is_same<decltype(std::atan((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::atan((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::atan((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::atan((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::atanf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::atanl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(atan(Ambiguous())), Ambiguous>::value), "");
     assert(std::atan(0) == 0);
 }
@@ -203,19 +217,29 @@
     static_assert((std::is_same<decltype(std::atan2((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::atan2((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::atan2((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::atan2((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::atan2((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::atan2((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::atan2((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::atan2((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::atan2((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::atan2((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::atan2((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::atan2((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::atan2((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::atan2((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::atan2f(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::atan2l(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::atan2((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(atan2(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::atan2(0,1) == 0);
@@ -233,9 +257,13 @@
     static_assert((std::is_same<decltype(std::ceil((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::ceil((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::ceil((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::ceil((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::ceilf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::ceill(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(ceil(Ambiguous())), Ambiguous>::value), "");
     assert(std::ceil(0) == 0);
 }
@@ -252,9 +280,13 @@
     static_assert((std::is_same<decltype(std::cos((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::cos((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::cos((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::cos((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::cosf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::cosl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(cos(Ambiguous())), Ambiguous>::value), "");
     assert(std::cos(0) == 1);
 }
@@ -271,9 +303,13 @@
     static_assert((std::is_same<decltype(std::cosh((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::cosh((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::cosh((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::cosh((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::coshf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::coshl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(cosh(Ambiguous())), Ambiguous>::value), "");
     assert(std::cosh(0) == 1);
 }
@@ -290,9 +326,13 @@
     static_assert((std::is_same<decltype(std::exp((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::exp((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::exp((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::exp((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::expf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::expl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(exp(Ambiguous())), Ambiguous>::value), "");
     assert(std::exp(0) == 1);
 }
@@ -309,9 +349,13 @@
     static_assert((std::is_same<decltype(std::fabs((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fabs((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fabs((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fabs((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fabsf(0.0f)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fabsl(0.0L)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fabs(Ambiguous())), Ambiguous>::value), "");
     assert(std::fabs(-1) == 1);
 }
@@ -328,9 +372,13 @@
     static_assert((std::is_same<decltype(std::floor((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::floor((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::floor((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::floor((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::floorf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::floorl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(floor(Ambiguous())), Ambiguous>::value), "");
     assert(std::floor(1) == 1);
 }
@@ -340,19 +388,29 @@
     static_assert((std::is_same<decltype(std::fmod((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::fmod((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fmod((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fmod((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fmod((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fmod((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fmod((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fmod((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fmod((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fmod((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fmod((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fmod((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fmod((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::fmod((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fmodf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fmodl(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fmod((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmod(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::fmod(1.5,1) == .5);
@@ -371,9 +429,13 @@
     static_assert((std::is_same<decltype(std::frexp((long long)0, &ip)), double>::value), "");
     static_assert((std::is_same<decltype(std::frexp((unsigned long long)0, &ip)), double>::value), "");
     static_assert((std::is_same<decltype(std::frexp((double)0, &ip)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::frexp((long double)0, &ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::frexpf(0, &ip)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::frexpl(0, &ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(frexp(Ambiguous(), &ip)), Ambiguous>::value), "");
     assert(std::frexp(0, &ip) == 0);
 }
@@ -391,9 +453,13 @@
     static_assert((std::is_same<decltype(std::ldexp((long long)0, ip)), double>::value), "");
     static_assert((std::is_same<decltype(std::ldexp((unsigned long long)0, ip)), double>::value), "");
     static_assert((std::is_same<decltype(std::ldexp((double)0, ip)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::ldexp((long double)0, ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::ldexpf(0, ip)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::ldexpl(0, ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(ldexp(Ambiguous(), ip)), Ambiguous>::value), "");
     assert(std::ldexp(1, ip) == 2);
 }
@@ -410,9 +476,13 @@
     static_assert((std::is_same<decltype(std::log((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::log((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::log((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::log((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::logf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::logl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(log(Ambiguous())), Ambiguous>::value), "");
     assert(std::log(1) == 0);
 }
@@ -429,9 +499,13 @@
     static_assert((std::is_same<decltype(std::log10((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::log10((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::log10((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::log10((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::log10f(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::log10l(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(log10(Ambiguous())), Ambiguous>::value), "");
     assert(std::log10(1) == 0);
 }
@@ -440,9 +514,13 @@
 {
     static_assert((std::is_same<decltype(std::modf((float)0, (float*)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::modf((double)0, (double*)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::modf((long double)0, (long double*)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::modff(0, (float*)0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::modfl(0, (long double*)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(modf(Ambiguous(), (Ambiguous*)0)), Ambiguous>::value), "");
     double i;
     assert(std::modf(1., &i) == 0);
@@ -453,29 +531,43 @@
     static_assert((std::is_same<decltype(std::pow((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::pow((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::pow((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::pow((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::pow((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::pow((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::pow((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::pow((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::pow((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::pow((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::pow((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::pow((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::pow((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::pow((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::powf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::powl(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::pow((int)0, (int)0)), double>::value), "");
 //     static_assert((std::is_same<decltype(std::pow(Value<int>(), (int)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
 //     static_assert((std::is_same<decltype(std::pow(Value<long double>(), (float)0)), long double>::value), "");
+#endif
 //     static_assert((std::is_same<decltype(std::pow((float) 0, Value<float>())), float>::value), "");
     static_assert((std::is_same<decltype(pow(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::pow(1,1) == 1);
 //     assert(std::pow(Value<int,1>(), Value<float,1>())  == 1);
 //     assert(std::pow(1.0f, Value<double,1>()) == 1);
 //     assert(std::pow(1.0, Value<int,1>()) == 1);
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
 //     assert(std::pow(Value<long double,1>(), 1LL) == 1);
+#endif
 }
 
 void test_sin()
@@ -490,9 +582,13 @@
     static_assert((std::is_same<decltype(std::sin((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::sin((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::sin((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::sin((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::sinf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::sinl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(sin(Ambiguous())), Ambiguous>::value), "");
     assert(std::sin(0) == 0);
 }
@@ -509,9 +605,13 @@
     static_assert((std::is_same<decltype(std::sinh((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::sinh((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::sinh((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::sinh((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::sinhf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::sinhl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(sinh(Ambiguous())), Ambiguous>::value), "");
     assert(std::sinh(0) == 0);
 }
@@ -528,9 +628,13 @@
     static_assert((std::is_same<decltype(std::sqrt((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::sqrt((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::sqrt((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::sqrt((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::sqrtf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::sqrtl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(sqrt(Ambiguous())), Ambiguous>::value), "");
     assert(std::sqrt(4) == 2);
 }
@@ -547,9 +651,13 @@
     static_assert((std::is_same<decltype(std::tan((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::tan((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::tan((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::tan((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::tanf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::tanl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(tan(Ambiguous())), Ambiguous>::value), "");
     assert(std::tan(0) == 0);
 }
@@ -566,9 +674,13 @@
     static_assert((std::is_same<decltype(std::tanh((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::tanh((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::tanh((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::tanh((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::tanhf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::tanhl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(tanh(Ambiguous())), Ambiguous>::value), "");
     assert(std::tanh(0) == 0);
 }
@@ -581,7 +693,9 @@
     static_assert((std::is_same<decltype(std::signbit((float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::signbit((double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::signbit(0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::signbit((long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(signbit(Ambiguous())), Ambiguous>::value), "");
     assert(std::signbit(-1.0) == true);
     assert(std::signbit(0u) == false);
@@ -601,7 +715,9 @@
     static_assert((std::is_same<decltype(std::fpclassify((float)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::fpclassify((double)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::fpclassify(0)), int>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fpclassify((long double)0)), int>::value), "");
+#endif
     static_assert((std::is_same<decltype(fpclassify(Ambiguous())), Ambiguous>::value), "");
     assert(std::fpclassify(-1.0) == FP_NORMAL);
     assert(std::fpclassify(0) == FP_ZERO);
@@ -619,7 +735,9 @@
     static_assert((std::is_same<decltype(std::isfinite((float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isfinite((double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isfinite(0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::isfinite((long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isfinite(Ambiguous())), Ambiguous>::value), "");
     assert(std::isfinite(-1.0) == true);
     assert(std::isfinite(0) == true);
@@ -637,7 +755,9 @@
     static_assert((std::is_same<decltype(std::isnormal((float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isnormal((double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isnormal(0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::isnormal((long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isnormal(Ambiguous())), Ambiguous>::value), "");
     assert(std::isnormal(-1.0) == true);
     assert(std::isnormal(0) == false);
@@ -654,14 +774,18 @@
 #endif
     static_assert((std::is_same<decltype(std::isgreater((float)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isgreater((float)0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::isgreater((float)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::isgreater((double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isgreater((double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isgreater(0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::isgreater((double)0, (long double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isgreater((long double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isgreater((long double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isgreater((long double)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isgreater(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::isgreater(-1.0, 0.F) == false);
 }
@@ -673,14 +797,18 @@
 #endif
     static_assert((std::is_same<decltype(std::isgreaterequal((float)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isgreaterequal((float)0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::isgreaterequal((float)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::isgreaterequal((double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isgreaterequal((double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isgreaterequal(0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::isgreaterequal((double)0, (long double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isgreaterequal((long double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isgreaterequal((long double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isgreaterequal((long double)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isgreaterequal(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::isgreaterequal(-1.0, 0.F) == false);
 }
@@ -705,7 +833,9 @@
 #endif
 
     static_assert((std::is_same<decltype(std::isinf(0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::isinf((long double)0)), bool>::value), "");
+#endif
     assert(std::isinf(-1.0) == false);
     assert(std::isinf(0) == false);
     assert(std::isinf(1) == false);
@@ -721,14 +851,18 @@
 #endif
     static_assert((std::is_same<decltype(std::isless((float)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isless((float)0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::isless((float)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::isless((double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isless((double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isless(0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::isless((double)0, (long double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isless((long double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isless((long double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isless((long double)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isless(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::isless(-1.0, 0.F) == true);
 }
@@ -740,14 +874,18 @@
 #endif
     static_assert((std::is_same<decltype(std::islessequal((float)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::islessequal((float)0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::islessequal((float)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::islessequal((double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::islessequal((double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::islessequal(0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::islessequal((double)0, (long double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::islessequal((long double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::islessequal((long double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::islessequal((long double)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(islessequal(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::islessequal(-1.0, 0.F) == true);
 }
@@ -759,14 +897,18 @@
 #endif
     static_assert((std::is_same<decltype(std::islessgreater((float)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::islessgreater((float)0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::islessgreater((float)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::islessgreater((double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::islessgreater((double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::islessgreater(0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::islessgreater((double)0, (long double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::islessgreater((long double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::islessgreater((long double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::islessgreater((long double)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(islessgreater(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::islessgreater(-1.0, 0.F) == true);
 }
@@ -791,7 +933,9 @@
 #endif
 
     static_assert((std::is_same<decltype(std::isnan(0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::isnan((long double)0)), bool>::value), "");
+#endif
     assert(std::isnan(-1.0) == false);
     assert(std::isnan(0) == false);
     assert(std::isnan(1) == false);
@@ -807,14 +951,18 @@
 #endif
     static_assert((std::is_same<decltype(std::isunordered((float)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isunordered((float)0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::isunordered((float)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::isunordered((double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isunordered((double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isunordered(0, (double)0)), bool>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::isunordered((double)0, (long double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isunordered((long double)0, (float)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isunordered((long double)0, (double)0)), bool>::value), "");
     static_assert((std::is_same<decltype(std::isunordered((long double)0, (long double)0)), bool>::value), "");
+#endif
     static_assert((std::is_same<decltype(isunordered(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::isunordered(-1.0, 0.F) == false);
 }
@@ -831,9 +979,13 @@
     static_assert((std::is_same<decltype(std::acosh((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::acosh((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::acosh((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::acosh((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::acoshf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::acoshl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(acosh(Ambiguous())), Ambiguous>::value), "");
     assert(std::acosh(1) == 0);
 }
@@ -850,9 +1002,13 @@
     static_assert((std::is_same<decltype(std::asinh((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::asinh((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::asinh((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::asinh((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::asinhf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::asinhl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(asinh(Ambiguous())), Ambiguous>::value), "");
     assert(std::asinh(0) == 0);
 }
@@ -869,9 +1025,13 @@
     static_assert((std::is_same<decltype(std::atanh((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::atanh((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::atanh((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::atanh((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::atanhf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::atanhl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(atanh(Ambiguous())), Ambiguous>::value), "");
     assert(std::atanh(0) == 0);
 }
@@ -888,9 +1048,13 @@
     static_assert((std::is_same<decltype(std::cbrt((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::cbrt((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::cbrt((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::cbrt((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::cbrtf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::cbrtl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(cbrt(Ambiguous())), Ambiguous>::value), "");
     assert(truncate_fp(std::cbrt(1)) == 1);
 }
@@ -930,9 +1094,13 @@
     static_assert((std::is_same<decltype(std::erf((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::erf((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::erf((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::erf((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::erff(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::erfl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(erf(Ambiguous())), Ambiguous>::value), "");
     assert(std::erf(0) == 0);
 }
@@ -949,9 +1117,13 @@
     static_assert((std::is_same<decltype(std::erfc((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::erfc((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::erfc((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::erfc((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::erfcf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::erfcl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(erfc(Ambiguous())), Ambiguous>::value), "");
     assert(std::erfc(0) == 1);
 }
@@ -968,9 +1140,13 @@
     static_assert((std::is_same<decltype(std::exp2((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::exp2((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::exp2((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::exp2((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::exp2f(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::exp2l(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(exp2(Ambiguous())), Ambiguous>::value), "");
     assert(std::exp2(1) == 2);
 }
@@ -987,9 +1163,13 @@
     static_assert((std::is_same<decltype(std::expm1((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::expm1((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::expm1((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::expm1((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::expm1f(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::expm1l(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(expm1(Ambiguous())), Ambiguous>::value), "");
     assert(std::expm1(0) == 0);
 }
@@ -999,19 +1179,29 @@
     static_assert((std::is_same<decltype(std::fdim((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::fdim((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fdim((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fdim((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fdim((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fdim((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fdim((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fdim((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fdim((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fdim((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fdim((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fdim((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fdim((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::fdim((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fdimf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fdiml(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fdim((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(fdim(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::fdim(1,0) == 1);
@@ -1026,7 +1216,9 @@
     static_assert((std::is_same<decltype(std::fma((float)0, (long)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fma((float)0, (float)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fma((float)0, (float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fma((float)0, (float)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fma((float)0, (float)0, (float)0)), float>::value), "");
 
     static_assert((std::is_same<decltype(std::fma((bool)0, (double)0, (double)0)), double>::value), "");
@@ -1036,9 +1228,12 @@
     static_assert((std::is_same<decltype(std::fma((double)0, (long)0, (double)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fma((double)0, (double)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fma((double)0, (double)0, (float)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fma((double)0, (double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fma((double)0, (double)0,  (double)0)), double>::value), "");
 
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fma((bool)0, (long double)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::fma((char)0, (long double)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::fma((unsigned)0, (long double)0, (long double)0)), long double>::value), "");
@@ -1048,9 +1243,12 @@
     static_assert((std::is_same<decltype(std::fma((long double)0, (long double)0, (float)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::fma((double)0, (long double)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::fma((long double)0, (long double)0, (long double)0)), long double>::value), "");
+#endif
 
     static_assert((std::is_same<decltype(std::fmaf(0,0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fmal(0,0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(fma(Ambiguous(), Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::fma(1,1,1) == 2);
 }
@@ -1060,19 +1258,29 @@
     static_assert((std::is_same<decltype(std::fmax((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::fmax((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fmax((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fmax((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fmax((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fmax((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fmax((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fmax((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fmax((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fmax((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fmax((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fmax((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fmax((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::fmax((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fmaxf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fmaxl(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fmax((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmax(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::fmax(1,0) == 1);
@@ -1083,19 +1291,29 @@
     static_assert((std::is_same<decltype(std::fmin((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::fmin((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fmin((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fmin((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fmin((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fmin((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fmin((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fmin((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fmin((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::fmin((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fmin((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fmin((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fmin((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::fmin((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fminf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::fminl(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::fmin((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(fmin(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::fmin(1,0) == 0);
@@ -1106,19 +1324,29 @@
     static_assert((std::is_same<decltype(std::hypot((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::hypot((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::hypot((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::hypot((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::hypot((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::hypot((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::hypot((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::hypot((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::hypot((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::hypotf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::hypotl(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::hypot((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(hypot(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::hypot(3,4) == 5);
@@ -1127,16 +1355,24 @@
     static_assert((std::is_same<decltype(std::hypot((float)0, (float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::hypot((float)0, (int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::hypot((float)0, (double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::hypot((float)0, (long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::hypot((float)0, (int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::hypot((float)0, (long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::hypot((float)0, (float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::hypot((float)0, (float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::hypot((float)0, (double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::hypot((int)0, (int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(hypot(Ambiguous(), Ambiguous(), Ambiguous())), Ambiguous>::value), "");
 
@@ -1157,7 +1393,9 @@
     static_assert((std::is_same<decltype(std::ilogb((long long)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::ilogb((unsigned long long)0)), int>::value), "");
     static_assert((std::is_same<decltype(std::ilogb((double)0)), int>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::ilogb((long double)0)), int>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::ilogbf(0)), int>::value), "");
     static_assert((std::is_same<decltype(std::ilogbl(0)), int>::value), "");
     static_assert((std::is_same<decltype(ilogb(Ambiguous())), Ambiguous>::value), "");
@@ -1172,16 +1410,24 @@
     static_assert((std::is_same<decltype(std::lerp((float)0, (float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::lerp((float)0, (bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::lerp((float)0, (unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::lerp((float)0, (int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::lerp((float)0, (double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::lerp((float)0, (long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::lerp((float)0, (int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::lerp((float)0, (int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::lerp((float)0, (double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::lerp((float)0, (long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::lerp((float)0, (float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::lerp((float)0, (float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::lerp((float)0, (double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::lerp((int)0, (int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(lerp(Ambiguous(), Ambiguous(), Ambiguous())), Ambiguous>::value), "");
 
@@ -1206,9 +1452,13 @@
     static_assert((std::is_same<decltype(std::lgamma((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::lgamma((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::lgamma((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::lgamma((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::lgammaf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::lgammal(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(lgamma(Ambiguous())), Ambiguous>::value), "");
     assert(std::lgamma(1) == 0);
 }
@@ -1225,7 +1475,9 @@
     static_assert((std::is_same<decltype(std::llrint((long long)0)), long long>::value), "");
     static_assert((std::is_same<decltype(std::llrint((unsigned long long)0)), long long>::value), "");
     static_assert((std::is_same<decltype(std::llrint((double)0)), long long>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::llrint((long double)0)), long long>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::llrintf(0)), long long>::value), "");
     static_assert((std::is_same<decltype(std::llrintl(0)), long long>::value), "");
     static_assert((std::is_same<decltype(llrint(Ambiguous())), Ambiguous>::value), "");
@@ -1244,7 +1496,9 @@
     static_assert((std::is_same<decltype(std::llround((long long)0)), long long>::value), "");
     static_assert((std::is_same<decltype(std::llround((unsigned long long)0)), long long>::value), "");
     static_assert((std::is_same<decltype(std::llround((double)0)), long long>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::llround((long double)0)), long long>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::llroundf(0)), long long>::value), "");
     static_assert((std::is_same<decltype(std::llroundl(0)), long long>::value), "");
     static_assert((std::is_same<decltype(llround(Ambiguous())), Ambiguous>::value), "");
@@ -1263,9 +1517,13 @@
     static_assert((std::is_same<decltype(std::log1p((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::log1p((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::log1p((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::log1p((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::log1pf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::log1pl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(log1p(Ambiguous())), Ambiguous>::value), "");
     assert(std::log1p(0) == 0);
 }
@@ -1282,9 +1540,13 @@
     static_assert((std::is_same<decltype(std::log2((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::log2((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::log2((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::log2((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::log2f(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::log2l(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(log2(Ambiguous())), Ambiguous>::value), "");
     assert(std::log2(1) == 0);
 }
@@ -1301,9 +1563,13 @@
     static_assert((std::is_same<decltype(std::logb((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::logb((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::logb((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::logb((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::logbf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::logbl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(logb(Ambiguous())), Ambiguous>::value), "");
     assert(std::logb(1) == 0);
 }
@@ -1320,7 +1586,9 @@
     static_assert((std::is_same<decltype(std::lrint((long long)0)), long>::value), "");
     static_assert((std::is_same<decltype(std::lrint((unsigned long long)0)), long>::value), "");
     static_assert((std::is_same<decltype(std::lrint((double)0)), long>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::lrint((long double)0)), long>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::lrintf(0)), long>::value), "");
     static_assert((std::is_same<decltype(std::lrintl(0)), long>::value), "");
     static_assert((std::is_same<decltype(lrint(Ambiguous())), Ambiguous>::value), "");
@@ -1339,7 +1607,9 @@
     static_assert((std::is_same<decltype(std::lround((long long)0)), long>::value), "");
     static_assert((std::is_same<decltype(std::lround((unsigned long long)0)), long>::value), "");
     static_assert((std::is_same<decltype(std::lround((double)0)), long>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::lround((long double)0)), long>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::lroundf(0)), long>::value), "");
     static_assert((std::is_same<decltype(std::lroundl(0)), long>::value), "");
     static_assert((std::is_same<decltype(lround(Ambiguous())), Ambiguous>::value), "");
@@ -1350,7 +1620,9 @@
 {
     static_assert((std::is_same<decltype(std::nan("")), double>::value), "");
     static_assert((std::is_same<decltype(std::nanf("")), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::nanl("")), long double>::value), "");
+#endif
 }
 
 void test_nearbyint()
@@ -1365,9 +1637,13 @@
     static_assert((std::is_same<decltype(std::nearbyint((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::nearbyint((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::nearbyint((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::nearbyint((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::nearbyintf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::nearbyintl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(nearbyint(Ambiguous())), Ambiguous>::value), "");
     assert(std::nearbyint(1) == 1);
 }
@@ -1377,19 +1653,29 @@
     static_assert((std::is_same<decltype(std::nextafter((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::nextafter((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::nextafter((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::nextafter((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::nextafter((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::nextafter((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::nextafter((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::nextafter((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::nextafter((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::nextafter((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::nextafter((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::nextafter((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::nextafter((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::nextafter((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::nextafterf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::nextafterl(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::nextafter((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(nextafter(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::nextafter(0,1) == hexfloat<double>(0x1, 0, -1074));
@@ -1397,6 +1683,7 @@
 
 void test_nexttoward()
 {
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::nexttoward((float)0, (long double)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::nexttoward((bool)0, (long double)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::nexttoward((unsigned short)0, (long double)0)), double>::value), "");
@@ -1410,6 +1697,7 @@
     static_assert((std::is_same<decltype(std::nexttoward((long double)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::nexttowardf(0, (long double)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::nexttowardl(0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(nexttoward(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::nexttoward(0, 1) == hexfloat<double>(0x1, 0, -1074));
 }
@@ -1419,19 +1707,29 @@
     static_assert((std::is_same<decltype(std::remainder((float)0, (float)0)), float>::value), "");
     static_assert((std::is_same<decltype(std::remainder((bool)0, (float)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::remainder((unsigned short)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::remainder((int)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::remainder((float)0, (unsigned int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::remainder((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::remainder((long double)0, (unsigned long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::remainder((int)0, (long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::remainder((int)0, (unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::remainder((double)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::remainder((long double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::remainder((float)0, (double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::remainder((float)0, (long double)0)), long double>::value), "");
     static_assert((std::is_same<decltype(std::remainder((double)0, (long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::remainderf(0,0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::remainderl(0,0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::remainder((int)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(remainder(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::remainder(0.5,1) == 0.5);
@@ -1443,19 +1741,29 @@
     static_assert((std::is_same<decltype(std::remquo((float)0, (float)0, &ip)), float>::value), "");
     static_assert((std::is_same<decltype(std::remquo((bool)0, (float)0, &ip)), double>::value), "");
     static_assert((std::is_same<decltype(std::remquo((unsigned short)0, (double)0, &ip)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::remquo((int)0, (long double)0, &ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::remquo((float)0, (unsigned int)0, &ip)), double>::value), "");
     static_assert((std::is_same<decltype(std::remquo((double)0, (long)0, &ip)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::remquo((long double)0, (unsigned long)0, &ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::remquo((int)0, (long long)0, &ip)), double>::value), "");
     static_assert((std::is_same<decltype(std::remquo((int)0, (unsigned long long)0, &ip)), double>::value), "");
     static_assert((std::is_same<decltype(std::remquo((double)0, (double)0, &ip)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::remquo((long double)0, (long double)0, &ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::remquo((float)0, (double)0, &ip)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::remquo((float)0, (long double)0, &ip)), long double>::value), "");
     static_assert((std::is_same<decltype(std::remquo((double)0, (long double)0, &ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::remquof(0,0, &ip)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::remquol(0,0, &ip)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::remquo((int)0, (int)0, &ip)), double>::value), "");
     static_assert((std::is_same<decltype(remquo(Ambiguous(), Ambiguous(), &ip)), Ambiguous>::value), "");
     assert(std::remquo(0.5,1, &ip) == 0.5);
@@ -1473,9 +1781,13 @@
     static_assert((std::is_same<decltype(std::rint((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::rint((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::rint((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::rint((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::rintf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::rintl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(rint(Ambiguous())), Ambiguous>::value), "");
     assert(std::rint(1) == 1);
 }
@@ -1492,9 +1804,13 @@
     static_assert((std::is_same<decltype(std::round((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::round((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::round((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::round((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::roundf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::roundl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(round(Ambiguous())), Ambiguous>::value), "");
     assert(std::round(1) == 1);
 }
@@ -1511,9 +1827,13 @@
     static_assert((std::is_same<decltype(std::scalbln((long long)0, (long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::scalbln((unsigned long long)0, (long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::scalbln((double)0, (long)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::scalbln((long double)0, (long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::scalblnf(0, (long)0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::scalblnl(0, (long)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(scalbln(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::scalbln(1, 1) == 2);
 }
@@ -1530,9 +1850,13 @@
     static_assert((std::is_same<decltype(std::scalbn((long long)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::scalbn((unsigned long long)0, (int)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::scalbn((double)0, (int)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::scalbn((long double)0, (int)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::scalbnf(0, (int)0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::scalbnl(0, (int)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(scalbn(Ambiguous(), Ambiguous())), Ambiguous>::value), "");
     assert(std::scalbn(1, 1) == 2);
 }
@@ -1549,9 +1873,13 @@
     static_assert((std::is_same<decltype(std::tgamma((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::tgamma((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::tgamma((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::tgamma((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::tgammaf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::tgammal(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(tgamma(Ambiguous())), Ambiguous>::value), "");
     assert(std::tgamma(1) == 1);
 }
@@ -1568,9 +1896,13 @@
     static_assert((std::is_same<decltype(std::trunc((long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::trunc((unsigned long long)0)), double>::value), "");
     static_assert((std::is_same<decltype(std::trunc((double)0)), double>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::trunc((long double)0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(std::truncf(0)), float>::value), "");
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     static_assert((std::is_same<decltype(std::truncl(0)), long double>::value), "");
+#endif
     static_assert((std::is_same<decltype(trunc(Ambiguous())), Ambiguous>::value), "");
     assert(std::trunc(1) == 1);
 }
Index: libcxx/test/std/numerics/complex.number/cmplx.over/arg.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/cmplx.over/arg.pass.cpp
+++ libcxx/test/std/numerics/complex.number/cmplx.over/arg.pass.cpp
@@ -48,7 +48,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test<int>();
     test<unsigned>();
     test<long long>();
Index: libcxx/test/std/numerics/complex.number/cmplx.over/pow.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/cmplx.over/pow.pass.cpp
+++ libcxx/test/std/numerics/complex.number/cmplx.over/pow.pass.cpp
@@ -83,24 +83,34 @@
 {
     test<int, float>();
     test<int, double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<int, long double>();
+#endif
 
     test<unsigned, float>();
     test<unsigned, double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<unsigned, long double>();
+#endif
 
     test<long long, float>();
     test<long long, double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long long, long double>();
+#endif
 
     test<float, double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<float, long double>();
+#endif
 
     test<double, float>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<double, long double>();
 
     test<long double, float>();
     test<long double, double>();
+#endif
 
   return 0;
 }
Index: libcxx/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.member.ops/divide_equal_complex.pass.cpp
@@ -50,7 +50,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
 
   return 0;
 }
Index: libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.ops/complex_divide_complex.pass.cpp
@@ -154,7 +154,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.ops/scalar_divide_complex.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.ops/scalar_divide_complex.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.ops/scalar_divide_complex.pass.cpp
@@ -38,7 +38,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
 
   return 0;
 }
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/acos.pass.cpp
@@ -134,7 +134,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/acosh.pass.cpp
@@ -145,7 +145,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/asin.pass.cpp
@@ -113,7 +113,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/asinh.pass.cpp
@@ -122,7 +122,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/atan.pass.cpp
@@ -62,7 +62,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/atanh.pass.cpp
@@ -126,7 +126,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/cos.pass.cpp
@@ -61,7 +61,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/cosh.pass.cpp
@@ -111,7 +111,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/exp.pass.cpp
@@ -113,7 +113,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
     return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/log.pass.cpp
@@ -126,7 +126,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/log10.pass.cpp
@@ -60,7 +60,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_complex.pass.cpp
@@ -65,7 +65,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_complex_scalar.pass.cpp
@@ -63,7 +63,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/pow_scalar_complex.pass.cpp
@@ -63,7 +63,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/sin.pass.cpp
@@ -62,7 +62,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/sinh.pass.cpp
@@ -112,7 +112,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/sqrt.pass.cpp
@@ -104,7 +104,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/tan.pass.cpp
@@ -63,7 +63,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.transcendentals/tanh.pass.cpp
@@ -94,7 +94,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.value.ops/abs.pass.cpp
@@ -58,7 +58,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.value.ops/arg.pass.cpp
@@ -130,7 +130,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
===================================================================
--- libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
+++ libcxx/test/std/numerics/complex.number/complex.value.ops/polar.pass.cpp
@@ -107,7 +107,9 @@
 {
     test<float>();
     test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     test<long double>();
+#endif
     test_edges();
 
   return 0;
Index: libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.float.pass.cpp
===================================================================
--- libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.float.pass.cpp
+++ libcxx/test/std/numerics/numeric.ops/numeric.ops.midpoint/midpoint.float.pass.cpp
@@ -128,7 +128,9 @@
 {
     fp_test<float>();
     fp_test<double>();
+#ifndef TEST_HAS_NO_LONG_DOUBLE_MATH
     fp_test<long double>();
+#endif
 
     return 0;
 }
Index: libcxx/test/support/test_macros.h
===================================================================
--- libcxx/test/support/test_macros.h
+++ libcxx/test/support/test_macros.h
@@ -361,6 +361,10 @@
 #   define TEST_HAS_NO_WIDE_CHARACTERS
 #endif
 
+#if defined(_LIBCPP_HAS_NO_LONG_DOUBLE_MATH)
+#   define TEST_HAS_NO_LONG_DOUBLE_MATH
+#endif
+
 #if defined(_LIBCPP_HAS_NO_UNICODE)
 #   define TEST_HAS_NO_UNICODE
 #elif defined(_MSVC_EXECUTION_CHARACTER_SET) && _MSVC_EXECUTION_CHARACTER_SET != 65001
Index: libcxx/utils/ci/buildkite-pipeline.yml
===================================================================
--- libcxx/utils/ci/buildkite-pipeline.yml
+++ libcxx/utils/ci/buildkite-pipeline.yml
@@ -607,6 +607,20 @@
             limit: 2
       timeout_in_minutes: 120
 
+    - label: "No long double math"
+      command: "libcxx/utils/ci/run-buildbot generic-no-long-double-math"
+      artifact_paths:
+        - "**/test-results.xml"
+        - "**/*.abilist"
+      agents:
+        queue: "libcxx-builders"
+        os: "linux"
+      retry:
+        automatic:
+          - exit_status: -1  # Agent was lost
+            limit: 2
+      timeout_in_minutes: 120
+
     - label: "No experimental features"
       command: "libcxx/utils/ci/run-buildbot generic-no-experimental"
       artifact_paths:
Index: libcxx/utils/ci/run-buildbot
===================================================================
--- libcxx/utils/ci/run-buildbot
+++ libcxx/utils/ci/run-buildbot
@@ -347,6 +347,11 @@
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-wide-characters.cmake"
     check-runtimes
 ;;
+generic-no-long-double-math)
+    clean
+    generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-long-double-math.cmake"
+    check-runtimes
+;;
 generic-no-experimental)
     clean
     generate-cmake -C "${MONOREPO_ROOT}/libcxx/cmake/caches/Generic-no-experimental.cmake"
Index: libcxx/utils/libcxx/test/features.py
===================================================================
--- libcxx/utils/libcxx/test/features.py
+++ libcxx/utils/libcxx/test/features.py
@@ -207,6 +207,7 @@
   '_LIBCPP_HAS_NO_RANDOM_DEVICE': 'no-random-device',
   '_LIBCPP_HAS_NO_LOCALIZATION': 'no-localization',
   '_LIBCPP_HAS_NO_WIDE_CHARACTERS': 'no-wide-characters',
+  '_LIBCPP_HAS_NO_LONG_DOUBLE_MATH': 'no-long-double-math',
   '_LIBCPP_HAS_NO_UNICODE': 'libcpp-has-no-unicode',
   '_LIBCPP_ENABLE_DEBUG_MODE': 'libcpp-has-debug-mode',
 }
Index: llvm/utils/gn/secondary/libcxx/include/BUILD.gn
===================================================================
--- llvm/utils/gn/secondary/libcxx/include/BUILD.gn
+++ llvm/utils/gn/secondary/libcxx/include/BUILD.gn
@@ -35,6 +35,7 @@
       "_LIBCPP_HAS_NO_RANDOM_DEVICE=",
       "_LIBCPP_HAS_NO_LOCALIZATION=",
       "_LIBCPP_HAS_NO_WIDE_CHARACTERS=",
+      "_LIBCPP_HAS_NO_LONG_DOUBLE_MATH=",
       "_LIBCPP_ABI_DEFINES=",
       "_LIBCPP_ENABLE_ASSERTIONS_DEFAULT=",
       "_LIBCPP_ENABLE_DEBUG_MODE=",