diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index 27e1673c51de7..0e13b0bfd593f 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -56,6 +56,7 @@
 
 use crate::ffi::va_list::{VaArgSafe, VaList};
 use crate::marker::{ConstParamTy, Destruct, DiscriminantKind, PointeeSized, Tuple};
+use crate::num::libm;
 use crate::{mem, ptr};
 
 mod bounds;
@@ -1020,30 +1021,42 @@ pub unsafe fn unaligned_volatile_store<T>(dst: *mut T, val: T);
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::sqrt`](../../std/primitive.f16.html#method.sqrt)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn sqrtf16(x: f16) -> f16;
+pub fn sqrtf16(x: f16) -> f16 {
+    libm::sqrtf16(x)
+}
 /// Returns the square root of an `f32`
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::sqrt`](../../std/primitive.f32.html#method.sqrt)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn sqrtf32(x: f32) -> f32;
+pub fn sqrtf32(x: f32) -> f32 {
+    libm::sqrtf(x)
+}
 /// Returns the square root of an `f64`
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::sqrt`](../../std/primitive.f64.html#method.sqrt)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn sqrtf64(x: f64) -> f64;
+pub fn sqrtf64(x: f64) -> f64 {
+    libm::sqrt(x)
+}
 /// Returns the square root of an `f128`
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::sqrt`](../../std/primitive.f128.html#method.sqrt)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn sqrtf128(x: f128) -> f128;
+pub fn sqrtf128(x: f128) -> f128 {
+    libm::sqrtf128(x)
+}
 
 /// Raises an `f16` to an integer power.
 ///
@@ -1078,233 +1091,329 @@ pub fn powif128(a: f128, x: i32) -> f128;
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::sin`](../../std/primitive.f16.html#method.sin)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn sinf16(x: f16) -> f16;
+pub fn sinf16(x: f16) -> f16 {
+    libm::likely_available::sinf(x as f32) as f16
+}
 /// Returns the sine of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::sin`](../../std/primitive.f32.html#method.sin)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn sinf32(x: f32) -> f32;
+pub fn sinf32(x: f32) -> f32 {
+    libm::likely_available::sinf(x)
+}
 /// Returns the sine of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::sin`](../../std/primitive.f64.html#method.sin)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn sinf64(x: f64) -> f64;
+pub fn sinf64(x: f64) -> f64 {
+    libm::likely_available::sin(x)
+}
 /// Returns the sine of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::sin`](../../std/primitive.f128.html#method.sin)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn sinf128(x: f128) -> f128;
+pub fn sinf128(x: f128) -> f128 {
+    libm::maybe_available::sinf128(x)
+}
 
 /// Returns the cosine of an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::cos`](../../std/primitive.f16.html#method.cos)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn cosf16(x: f16) -> f16;
+pub fn cosf16(x: f16) -> f16 {
+    libm::likely_available::cosf(x as f32) as f16
+}
 /// Returns the cosine of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::cos`](../../std/primitive.f32.html#method.cos)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn cosf32(x: f32) -> f32;
+pub fn cosf32(x: f32) -> f32 {
+    libm::likely_available::cosf(x)
+}
 /// Returns the cosine of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::cos`](../../std/primitive.f64.html#method.cos)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn cosf64(x: f64) -> f64;
+pub fn cosf64(x: f64) -> f64 {
+    libm::likely_available::cos(x)
+}
 /// Returns the cosine of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::cos`](../../std/primitive.f128.html#method.cos)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn cosf128(x: f128) -> f128;
+pub fn cosf128(x: f128) -> f128 {
+    libm::maybe_available::cosf128(x)
+}
 
 /// Raises an `f16` to an `f16` power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::powf`](../../std/primitive.f16.html#method.powf)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn powf16(a: f16, x: f16) -> f16;
+pub fn powf16(a: f16, x: f16) -> f16 {
+    libm::likely_available::powf(a as f32, x as f32) as f16
+}
 /// Raises an `f32` to an `f32` power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::powf`](../../std/primitive.f32.html#method.powf)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn powf32(a: f32, x: f32) -> f32;
+pub fn powf32(a: f32, x: f32) -> f32 {
+    libm::likely_available::powf(a, x)
+}
 /// Raises an `f64` to an `f64` power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::powf`](../../std/primitive.f64.html#method.powf)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn powf64(a: f64, x: f64) -> f64;
+pub fn powf64(a: f64, x: f64) -> f64 {
+    libm::likely_available::pow(a, x)
+}
 /// Raises an `f128` to an `f128` power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::powf`](../../std/primitive.f128.html#method.powf)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn powf128(a: f128, x: f128) -> f128;
+pub fn powf128(a: f128, x: f128) -> f128 {
+    libm::maybe_available::powf128(a, x)
+}
 
 /// Returns the exponential of an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::exp`](../../std/primitive.f16.html#method.exp)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn expf16(x: f16) -> f16;
+pub fn expf16(x: f16) -> f16 {
+    libm::likely_available::expf(x as f32) as f16
+}
 /// Returns the exponential of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::exp`](../../std/primitive.f32.html#method.exp)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn expf32(x: f32) -> f32;
+pub fn expf32(x: f32) -> f32 {
+    libm::likely_available::expf(x)
+}
 /// Returns the exponential of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::exp`](../../std/primitive.f64.html#method.exp)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn expf64(x: f64) -> f64;
+pub fn expf64(x: f64) -> f64 {
+    libm::likely_available::exp(x)
+}
 /// Returns the exponential of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::exp`](../../std/primitive.f128.html#method.exp)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn expf128(x: f128) -> f128;
+pub fn expf128(x: f128) -> f128 {
+    libm::maybe_available::expf128(x)
+}
 
 /// Returns 2 raised to the power of an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::exp2`](../../std/primitive.f16.html#method.exp2)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn exp2f16(x: f16) -> f16;
+pub fn exp2f16(x: f16) -> f16 {
+    libm::likely_available::exp2f(x as f32) as f16
+}
 /// Returns 2 raised to the power of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::exp2`](../../std/primitive.f32.html#method.exp2)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn exp2f32(x: f32) -> f32;
+pub fn exp2f32(x: f32) -> f32 {
+    libm::likely_available::exp2f(x)
+}
 /// Returns 2 raised to the power of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::exp2`](../../std/primitive.f64.html#method.exp2)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn exp2f64(x: f64) -> f64;
+pub fn exp2f64(x: f64) -> f64 {
+    libm::likely_available::exp2(x)
+}
 /// Returns 2 raised to the power of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::exp2`](../../std/primitive.f128.html#method.exp2)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn exp2f128(x: f128) -> f128;
+pub fn exp2f128(x: f128) -> f128 {
+    libm::maybe_available::exp2f128(x)
+}
 
 /// Returns the natural logarithm of an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::ln`](../../std/primitive.f16.html#method.ln)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn logf16(x: f16) -> f16;
+pub fn logf16(x: f16) -> f16 {
+    libm::likely_available::logf(x as f32) as f16
+}
 /// Returns the natural logarithm of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::ln`](../../std/primitive.f32.html#method.ln)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn logf32(x: f32) -> f32;
+pub fn logf32(x: f32) -> f32 {
+    libm::likely_available::logf(x)
+}
 /// Returns the natural logarithm of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::ln`](../../std/primitive.f64.html#method.ln)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn logf64(x: f64) -> f64;
+pub fn logf64(x: f64) -> f64 {
+    libm::likely_available::log(x)
+}
 /// Returns the natural logarithm of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::ln`](../../std/primitive.f128.html#method.ln)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn logf128(x: f128) -> f128;
+pub fn logf128(x: f128) -> f128 {
+    libm::maybe_available::logf128(x)
+}
 
 /// Returns the base 10 logarithm of an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::log10`](../../std/primitive.f16.html#method.log10)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn log10f16(x: f16) -> f16;
+pub fn log10f16(x: f16) -> f16 {
+    libm::likely_available::log10f(x as f32) as f16
+}
 /// Returns the base 10 logarithm of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::log10`](../../std/primitive.f32.html#method.log10)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn log10f32(x: f32) -> f32;
+pub fn log10f32(x: f32) -> f32 {
+    libm::likely_available::log10f(x)
+}
 /// Returns the base 10 logarithm of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::log10`](../../std/primitive.f64.html#method.log10)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn log10f64(x: f64) -> f64;
+pub fn log10f64(x: f64) -> f64 {
+    libm::likely_available::log10(x)
+}
 /// Returns the base 10 logarithm of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::log10`](../../std/primitive.f128.html#method.log10)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn log10f128(x: f128) -> f128;
+pub fn log10f128(x: f128) -> f128 {
+    libm::maybe_available::log10f128(x)
+}
 
 /// Returns the base 2 logarithm of an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::log2`](../../std/primitive.f16.html#method.log2)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn log2f16(x: f16) -> f16;
+pub fn log2f16(x: f16) -> f16 {
+    libm::likely_available::log2f(x as f32) as f16
+}
 /// Returns the base 2 logarithm of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::log2`](../../std/primitive.f32.html#method.log2)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn log2f32(x: f32) -> f32;
+pub fn log2f32(x: f32) -> f32 {
+    libm::likely_available::log2f(x)
+}
 /// Returns the base 2 logarithm of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::log2`](../../std/primitive.f64.html#method.log2)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn log2f64(x: f64) -> f64;
+pub fn log2f64(x: f64) -> f64 {
+    libm::likely_available::log2(x)
+}
 /// Returns the base 2 logarithm of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::log2`](../../std/primitive.f128.html#method.log2)
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub fn log2f128(x: f128) -> f128;
+pub fn log2f128(x: f128) -> f128 {
+    libm::maybe_available::log2f128(x)
+}
 
 /// Returns `a * b + c` for `f16` values.
 ///
@@ -1349,9 +1458,12 @@ pub const fn fmaf128(a: f128, b: f128, c: f128) -> f128;
 /// and add instructions. It is unspecified whether or not a fused operation
 /// is selected, and that may depend on optimization level and context, for
 /// example.
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const fn fmuladdf16(a: f16, b: f16, c: f16) -> f16;
+pub const fn fmuladdf16(a: f16, b: f16, c: f16) -> f16 {
+    fmaf16(a, b, c)
+}
 /// Returns `a * b + c` for `f32` values, non-deterministically executing
 /// either a fused multiply-add or two operations with rounding of the
 /// intermediate result.
@@ -1362,9 +1474,12 @@ pub const fn fmuladdf16(a: f16, b: f16, c: f16) -> f16;
 /// and add instructions. It is unspecified whether or not a fused operation
 /// is selected, and that may depend on optimization level and context, for
 /// example.
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const fn fmuladdf32(a: f32, b: f32, c: f32) -> f32;
+pub const fn fmuladdf32(a: f32, b: f32, c: f32) -> f32 {
+    fmaf32(a, b, c)
+}
 /// Returns `a * b + c` for `f64` values, non-deterministically executing
 /// either a fused multiply-add or two operations with rounding of the
 /// intermediate result.
@@ -1375,9 +1490,12 @@ pub const fn fmuladdf32(a: f32, b: f32, c: f32) -> f32;
 /// and add instructions. It is unspecified whether or not a fused operation
 /// is selected, and that may depend on optimization level and context, for
 /// example.
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const fn fmuladdf64(a: f64, b: f64, c: f64) -> f64;
+pub const fn fmuladdf64(a: f64, b: f64, c: f64) -> f64 {
+    fmaf64(a, b, c)
+}
 /// Returns `a * b + c` for `f128` values, non-deterministically executing
 /// either a fused multiply-add or two operations with rounding of the
 /// intermediate result.
@@ -1388,9 +1506,12 @@ pub const fn fmuladdf64(a: f64, b: f64, c: f64) -> f64;
 /// and add instructions. It is unspecified whether or not a fused operation
 /// is selected, and that may depend on optimization level and context, for
 /// example.
+#[inline]
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub const fn fmuladdf128(a: f128, b: f128, c: f128) -> f128;
+pub const fn fmuladdf128(a: f128, b: f128, c: f128) -> f128 {
+    fmaf128(a, b, c)
+}
 
 /// Returns the largest integer less than or equal to an `f16`.
 ///
diff --git a/library/core/src/num/libm.rs b/library/core/src/num/libm.rs
index aeabb08723095..c67adc337c1cb 100644
--- a/library/core/src/num/libm.rs
+++ b/library/core/src/num/libm.rs
@@ -1,11 +1,157 @@
 //! Bindings to math functions provided by the system `libm` or by the `libm` crate, exposed
 //! via `compiler-builtins`.
+//!
+//! The functions in the root of this module are "guaranteed" to be available; see the
+//! `full_availability` module in compiler-builtins for details.
 
 // SAFETY: These symbols have standard interfaces in C and are defined by `libm`, or are
 // provided by `compiler-builtins` on unsupported platforms.
+#[allow(dead_code)] // This list reflects what is available rather than what is consumed.
 unsafe extern "C" {
-    pub(crate) safe fn cbrt(n: f64) -> f64;
+    pub(crate) safe fn cbrt(x: f64) -> f64;
     pub(crate) safe fn cbrtf(n: f32) -> f32;
+    pub(crate) safe fn ceil(x: f64) -> f64;
+    pub(crate) safe fn ceilf(x: f32) -> f32;
+    pub(crate) safe fn ceilf128(x: f128) -> f128;
+    pub(crate) safe fn ceilf16(x: f16) -> f16;
+    pub(crate) safe fn copysign(x: f64, y: f64) -> f64;
+    pub(crate) safe fn copysignf(x: f32, y: f32) -> f32;
+    pub(crate) safe fn copysignf128(x: f128, y: f128) -> f128;
+    pub(crate) safe fn copysignf16(x: f16, y: f16) -> f16;
+    pub(crate) safe fn fabs(x: f64) -> f64;
+    pub(crate) safe fn fabsf(x: f32) -> f32;
+    pub(crate) safe fn fabsf128(x: f128) -> f128;
+    pub(crate) safe fn fabsf16(x: f16) -> f16;
     pub(crate) safe fn fdim(a: f64, b: f64) -> f64;
     pub(crate) safe fn fdimf(a: f32, b: f32) -> f32;
+    pub(crate) safe fn fdimf128(x: f128, y: f128) -> f128;
+    pub(crate) safe fn fdimf16(x: f16, y: f16) -> f16;
+    pub(crate) safe fn floor(x: f64) -> f64;
+    pub(crate) safe fn floorf(x: f32) -> f32;
+    pub(crate) safe fn floorf128(x: f128) -> f128;
+    pub(crate) safe fn floorf16(x: f16) -> f16;
+    pub(crate) safe fn fma(x: f64, y: f64, z: f64) -> f64;
+    pub(crate) safe fn fmaf(x: f32, y: f32, z: f32) -> f32;
+    pub(crate) safe fn fmaf128(x: f128, y: f128, z: f128) -> f128;
+    pub(crate) safe fn fmax(x: f64, y: f64) -> f64;
+    pub(crate) safe fn fmaxf(x: f32, y: f32) -> f32;
+    pub(crate) safe fn fmaxf128(x: f128, y: f128) -> f128;
+    pub(crate) safe fn fmaxf16(x: f16, y: f16) -> f16;
+    pub(crate) safe fn fmaximum(x: f64, y: f64) -> f64;
+    pub(crate) safe fn fmaximumf(x: f32, y: f32) -> f32;
+    pub(crate) safe fn fmaximumf128(x: f128, y: f128) -> f128;
+    pub(crate) safe fn fmaximumf16(x: f16, y: f16) -> f16;
+    pub(crate) safe fn fmin(x: f64, y: f64) -> f64;
+    pub(crate) safe fn fminf(x: f32, y: f32) -> f32;
+    pub(crate) safe fn fminf128(x: f128, y: f128) -> f128;
+    pub(crate) safe fn fminf16(x: f16, y: f16) -> f16;
+    pub(crate) safe fn fminimum(x: f64, y: f64) -> f64;
+    pub(crate) safe fn fminimumf(x: f32, y: f32) -> f32;
+    pub(crate) safe fn fminimumf128(x: f128, y: f128) -> f128;
+    pub(crate) safe fn fminimumf16(x: f16, y: f16) -> f16;
+    pub(crate) safe fn fmod(x: f64, y: f64) -> f64;
+    pub(crate) safe fn fmodf(x: f32, y: f32) -> f32;
+    pub(crate) safe fn fmodf128(x: f128, y: f128) -> f128;
+    pub(crate) safe fn fmodf16(x: f16, y: f16) -> f16;
+    pub(crate) safe fn rint(x: f64) -> f64;
+    pub(crate) safe fn rintf(x: f32) -> f32;
+    pub(crate) safe fn rintf128(x: f128) -> f128;
+    pub(crate) safe fn rintf16(x: f16) -> f16;
+    pub(crate) safe fn round(x: f64) -> f64;
+    pub(crate) safe fn roundeven(x: f64) -> f64;
+    pub(crate) safe fn roundevenf(x: f32) -> f32;
+    pub(crate) safe fn roundevenf128(x: f128) -> f128;
+    pub(crate) safe fn roundevenf16(x: f16) -> f16;
+    pub(crate) safe fn roundf(x: f32) -> f32;
+    pub(crate) safe fn roundf128(x: f128) -> f128;
+    pub(crate) safe fn roundf16(x: f16) -> f16;
+    pub(crate) safe fn sqrt(x: f64) -> f64;
+    pub(crate) safe fn sqrtf(x: f32) -> f32;
+    pub(crate) safe fn sqrtf128(x: f128) -> f128;
+    pub(crate) safe fn sqrtf16(x: f16) -> f16;
+    pub(crate) safe fn trunc(x: f64) -> f64;
+    pub(crate) safe fn truncf(x: f32) -> f32;
+    pub(crate) safe fn truncf128(x: f128) -> f128;
+    pub(crate) safe fn truncf16(x: f16) -> f16;
+}
+
+/// These symbols will be available when `std` is available, and on many no-std platforms. However,
+/// since this isn't a guarantee, we cannot rely on them for stable implementations.
+pub(crate) mod likely_available {
+    #[allow(dead_code)]
+    unsafe extern "C" {
+        pub(crate) safe fn acos(x: f64) -> f64;
+        pub(crate) safe fn acosf(n: f32) -> f32;
+        pub(crate) safe fn asin(x: f64) -> f64;
+        pub(crate) safe fn asinf(n: f32) -> f32;
+        pub(crate) safe fn atan(x: f64) -> f64;
+        pub(crate) safe fn atan2(x: f64, y: f64) -> f64;
+        pub(crate) safe fn atan2f(a: f32, b: f32) -> f32;
+        pub(crate) safe fn atanf(n: f32) -> f32;
+        pub(crate) safe fn cos(x: f64) -> f64;
+        pub(crate) safe fn cosf(x: f32) -> f32;
+        pub(crate) safe fn cosh(x: f64) -> f64;
+        pub(crate) safe fn coshf(n: f32) -> f32;
+        pub(crate) safe fn erf(x: f64) -> f64;
+        pub(crate) safe fn erfc(x: f64) -> f64;
+        pub(crate) safe fn erfcf(x: f32) -> f32;
+        pub(crate) safe fn erff(x: f32) -> f32;
+        pub(crate) safe fn exp(x: f64) -> f64;
+        pub(crate) safe fn exp2(x: f64) -> f64;
+        pub(crate) safe fn exp2f(x: f32) -> f32;
+        pub(crate) safe fn expf(x: f32) -> f32;
+        pub(crate) safe fn expm1(x: f64) -> f64;
+        pub(crate) safe fn expm1f(n: f32) -> f32;
+        pub(crate) safe fn hypot(x: f64, y: f64) -> f64;
+        pub(crate) safe fn hypotf(x: f32, y: f32) -> f32;
+        pub(crate) safe fn ldexp(f: f64, n: i32) -> f64;
+        pub(crate) safe fn ldexpf(f: f32, n: i32) -> f32;
+        pub(crate) safe fn log(x: f64) -> f64;
+        pub(crate) safe fn log10(x: f64) -> f64;
+        pub(crate) safe fn log10f(x: f32) -> f32;
+        pub(crate) safe fn log1p(x: f64) -> f64;
+        pub(crate) safe fn log1pf(n: f32) -> f32;
+        pub(crate) safe fn log2(x: f64) -> f64;
+        pub(crate) safe fn log2f(x: f32) -> f32;
+        pub(crate) safe fn logf(x: f32) -> f32;
+        pub(crate) safe fn pow(x: f64, y: f64) -> f64;
+        pub(crate) safe fn powf(x: f32, y: f32) -> f32;
+        pub(crate) safe fn sin(x: f64) -> f64;
+        pub(crate) safe fn sinf(x: f32) -> f32;
+        pub(crate) safe fn sinh(x: f64) -> f64;
+        pub(crate) safe fn sinhf(n: f32) -> f32;
+        pub(crate) safe fn tan(x: f64) -> f64;
+        pub(crate) safe fn tanf(n: f32) -> f32;
+        pub(crate) safe fn tanh(x: f64) -> f64;
+        pub(crate) safe fn tanhf(n: f32) -> f32;
+        pub(crate) safe fn tgamma(x: f64) -> f64;
+        pub(crate) safe fn tgammaf(x: f32) -> f32;
+    }
+}
+
+/// These symbols exist on some platforms but do not have a compiler-builtins fallback.
+pub(crate) mod maybe_available {
+    #[allow(dead_code)]
+    unsafe extern "C" {
+        pub(crate) safe fn acosf128(x: f128) -> f128;
+        pub(crate) safe fn asinf128(x: f128) -> f128;
+        pub(crate) safe fn atanf128(x: f128) -> f128;
+        pub(crate) safe fn cbrtf128(x: f128) -> f128;
+        pub(crate) safe fn cosf128(x: f128) -> f128;
+        pub(crate) safe fn erff128(x: f128) -> f128;
+        pub(crate) safe fn expf128(x: f128) -> f128;
+        pub(crate) safe fn exp2f128(x: f128) -> f128;
+        pub(crate) safe fn expm1f128(x: f128) -> f128;
+        pub(crate) safe fn hypotf128(x: f128, y: f128) -> f128;
+        pub(crate) safe fn ldexpf128(f: f128, n: i32) -> f128;
+        pub(crate) safe fn log10f128(x: f128) -> f128;
+        pub(crate) safe fn log1pf128(x: f128) -> f128;
+        pub(crate) safe fn log2f128(x: f128) -> f128;
+        pub(crate) safe fn logf128(x: f128) -> f128;
+        pub(crate) safe fn powf128(x: f128, y: f128) -> f128;
+        pub(crate) safe fn sinf128(x: f128) -> f128;
+        pub(crate) safe fn tanf128(x: f128) -> f128;
+        pub(crate) safe fn tanhf128(x: f128) -> f128;
+        pub(crate) safe fn tgammaf128(x: f128) -> f128;
+    }
 }