diff --git a/lib/c/math.zig b/lib/c/math.zig
index 18ba8d9e755e4f74a6bc50d3cd178ffb2d1ed686..5eff669a9755975cc7423a203c15ecc6d5a199c6 100644
--- a/lib/c/math.zig
+++ b/lib/c/math.zig
@@ -116,13 +116,9 @@ fn atanf(x: f32) callconv(.c) f32 {
 }
 
 fn atanl(x: c_longdouble) callconv(.c) c_longdouble {
-    return switch (@typeInfo(@TypeOf(x)).float.bits) {
-        16 => math.atan(@as(f16, @floatCast(x))),
-        32 => math.atan(@as(f32, @floatCast(x))),
-        64 => math.atan(@as(f64, @floatCast(x))),
-        80 => math.atan(@as(f80, @floatCast(x))),
-        128 => math.atan(@as(f128, @floatCast(x))),
-        else => unreachable,
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.atan(x),
+        else => math.atan(x),
     };
 }
 
@@ -143,7 +139,10 @@ fn copysignf(x: f32, y: f32) callconv(.c) f32 {
 }
 
 fn copysignl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
-    return math.copysign(x, y);
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.copysign(x, y),
+        else => math.copysign(x, y),
+    };
 }
 
 fn cosh(x: f64) callconv(.c) f64 {
@@ -183,15 +182,18 @@ fn fdimf(x: f32, y: f32) callconv(.c) f32 {
 }
 
 fn fdiml(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
-    return fdimGeneric(c_longdouble, x, y);
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.fdim(x, y),
+        else => fdimGeneric(c_longdouble, x, y),
+    };
 }
 
 fn finite(x: f64) callconv(.c) c_int {
-    return if (math.isFinite(x)) 1 else 0;
+    return @intFromBool(math.isFinite(x));
 }
 
 fn finitef(x: f32) callconv(.c) c_int {
-    return if (math.isFinite(x)) 1 else 0;
+    return @intFromBool(math.isFinite(x));
 }
 
 fn frexpGeneric(comptime T: type, x: T, e: *c_int) T {
@@ -222,7 +224,10 @@ fn frexpf(x: f32, e: *c_int) callconv(.c) f32 {
 }
 
 fn frexpl(x: c_longdouble, e: *c_int) callconv(.c) c_longdouble {
-    return frexpGeneric(c_longdouble, x, e);
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.frexp(x, e),
+        else => frexpGeneric(c_longdouble, x, e),
+    };
 }
 
 fn hypot(x: f64, y: f64) callconv(.c) f64 {
@@ -234,19 +239,22 @@ fn hypotf(x: f32, y: f32) callconv(.c) f32 {
 }
 
 fn hypotl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
-    return math.hypot(x, y);
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.hypot(x, y),
+        else => math.hypot(x, y),
+    };
 }
 
 fn isnan(x: f64) callconv(.c) c_int {
-    return if (math.isNan(x)) 1 else 0;
+    return @intFromBool(math.isNan(x));
 }
 
 fn isnanf(x: f32) callconv(.c) c_int {
-    return if (math.isNan(x)) 1 else 0;
+    return @intFromBool(math.isNan(x));
 }
 
 fn isnanl(x: c_longdouble) callconv(.c) c_int {
-    return if (math.isNan(x)) 1 else 0;
+    return @intFromBool(math.isNan(x));
 }
 
 fn lrint(x: f64) callconv(.c) c_long {
@@ -290,7 +298,10 @@ fn modff(x: f32, iptr: *f32) callconv(.c) f32 {
 }
 
 fn modfl(x: c_longdouble, iptr: *c_longdouble) callconv(.c) c_longdouble {
-    return modfGeneric(c_longdouble, x, iptr);
+    return switch (@typeInfo(c_longdouble).float.bits) {
+        64 => std.c.modf(x, iptr),
+        else => modfGeneric(c_longdouble, x, iptr),
+    };
 }
 
 fn testModf(comptime T: type) !void {
diff --git a/lib/compiler_rt/cos.zig b/lib/compiler_rt/cos.zig
index 3620e31835b20461f80a096c4ccc7a59365fd812..0bc02e32945fd33abd5a2c5b473398fe179c8ae2 100644
--- a/lib/compiler_rt/cos.zig
+++ b/lib/compiler_rt/cos.zig
@@ -173,8 +173,6 @@ pub fn cosq(x: f128) callconv(.c) f128 {
 
 pub fn cosl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return cosh(x),
-        32 => return cosf(x),
         64 => return cos(x),
         80 => return cosx(x),
         128 => return cosq(x),
diff --git a/lib/compiler_rt/exp.zig b/lib/compiler_rt/exp.zig
index 3b0e593af0d3ccbed89b9e2e620134c6023405c9..ce2eadb7f1edfe49ca51562a8b3ec4432f2017eb 100644
--- a/lib/compiler_rt/exp.zig
+++ b/lib/compiler_rt/exp.zig
@@ -198,8 +198,6 @@ const expq = @import("exp_f128.zig").exp;
 
 pub fn expl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __exph(x),
-        32 => return expf(x),
         64 => return exp(x),
         80 => return __expx(x),
         128 => return expq(x),
diff --git a/lib/compiler_rt/exp2.zig b/lib/compiler_rt/exp2.zig
index 94f19bef2c919569b982ed5aea8e3ce1b58db14b..abcef881073619a860997766283c950cc702a3e6 100644
--- a/lib/compiler_rt/exp2.zig
+++ b/lib/compiler_rt/exp2.zig
@@ -165,8 +165,6 @@ pub const exp2q = @import("exp_f128.zig").exp2;
 
 pub fn exp2l(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __exp2h(x),
-        32 => return exp2f(x),
         64 => return exp2(x),
         80 => return __exp2x(x),
         128 => return exp2q(x),
diff --git a/lib/compiler_rt/fabs.zig b/lib/compiler_rt/fabs.zig
index 8fcf36262a40ed89c2e3ae0be958eaadabfb2c91..3e2104da6af1f8263678f06127f1ee0eb9201136 100644
--- a/lib/compiler_rt/fabs.zig
+++ b/lib/compiler_rt/fabs.zig
@@ -38,8 +38,6 @@ pub fn fabsq(a: f128) callconv(.c) f128 {
 
 pub fn fabsl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __fabsh(x),
-        32 => return fabsf(x),
         64 => return fabs(x),
         80 => return __fabsx(x),
         128 => return fabsq(x),
diff --git a/lib/compiler_rt/fma.zig b/lib/compiler_rt/fma.zig
index 10926e9bde05d36d8cdf16661542df9821621e0c..61732585db2ece3fb84c3029293cab41662781d2 100644
--- a/lib/compiler_rt/fma.zig
+++ b/lib/compiler_rt/fma.zig
@@ -151,8 +151,6 @@ pub fn fmaq(x: f128, y: f128, z: f128) callconv(.c) f128 {
 
 pub fn fmal(x: c_longdouble, y: c_longdouble, z: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __fmah(x, y, z),
-        32 => return fmaf(x, y, z),
         64 => return fma(x, y, z),
         80 => return __fmax(x, y, z),
         128 => return fmaq(x, y, z),
diff --git a/lib/compiler_rt/fmax.zig b/lib/compiler_rt/fmax.zig
index 606888d2d4f63a88a6a7de945239ddaca43f483d..0afdf9ee2be581c9296eac6d308f7f8fd7ecae35 100644
--- a/lib/compiler_rt/fmax.zig
+++ b/lib/compiler_rt/fmax.zig
@@ -39,8 +39,6 @@ pub fn fmaxq(x: f128, y: f128) callconv(.c) f128 {
 
 pub fn fmaxl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __fmaxh(x, y),
-        32 => return fmaxf(x, y),
         64 => return fmax(x, y),
         80 => return __fmaxx(x, y),
         128 => return fmaxq(x, y),
diff --git a/lib/compiler_rt/fmin.zig b/lib/compiler_rt/fmin.zig
index bea1779476c89f2e4d174f5d5f381f4ac802dde6..60b58cef3a6793efd5a53c24b380ea2178243bc9 100644
--- a/lib/compiler_rt/fmin.zig
+++ b/lib/compiler_rt/fmin.zig
@@ -39,8 +39,6 @@ pub fn fminq(x: f128, y: f128) callconv(.c) f128 {
 
 pub fn fminl(x: c_longdouble, y: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __fminh(x, y),
-        32 => return fminf(x, y),
         64 => return fmin(x, y),
         80 => return __fminx(x, y),
         128 => return fminq(x, y),
diff --git a/lib/compiler_rt/fmod.zig b/lib/compiler_rt/fmod.zig
index c2108abf3394d67d575ec124e23d61f19c5a5482..0279206f51b7977ff98c7007dfdf524320da3680 100644
--- a/lib/compiler_rt/fmod.zig
+++ b/lib/compiler_rt/fmod.zig
@@ -251,8 +251,6 @@ pub fn fmodq(a: f128, b: f128) callconv(.c) f128 {
 
 pub fn fmodl(a: c_longdouble, b: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __fmodh(a, b),
-        32 => return fmodf(a, b),
         64 => return fmod(a, b),
         80 => return __fmodx(a, b),
         128 => return fmodq(a, b),
diff --git a/lib/compiler_rt/log.zig b/lib/compiler_rt/log.zig
index 926018f03d71a30ecd88052cbe3d456afb99926d..fb578c75e9244b885999cd8486520a76d7b259e0 100644
--- a/lib/compiler_rt/log.zig
+++ b/lib/compiler_rt/log.zig
@@ -443,8 +443,6 @@ pub fn logq(a: f128) callconv(.c) f128 {
 
 pub fn logl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __logh(x),
-        32 => return logf(x),
         64 => return log(x),
         80 => return __logx(x),
         128 => return logq(x),
diff --git a/lib/compiler_rt/log10.zig b/lib/compiler_rt/log10.zig
index ec4edac61860c7285879d13f0c1df4685774f370..6a3c46981555bca4b6f59ff431f3b69300a0467e 100644
--- a/lib/compiler_rt/log10.zig
+++ b/lib/compiler_rt/log10.zig
@@ -177,8 +177,6 @@ pub fn log10q(a: f128) callconv(.c) f128 {
 
 pub fn log10l(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __log10h(x),
-        32 => return log10f(x),
         64 => return log10(x),
         80 => return __log10x(x),
         128 => return log10q(x),
diff --git a/lib/compiler_rt/log2.zig b/lib/compiler_rt/log2.zig
index ad17df7f653dbff49570203f79307049926dae74..d675fb172d159f3b5c658cba8696969f7abb48b1 100644
--- a/lib/compiler_rt/log2.zig
+++ b/lib/compiler_rt/log2.zig
@@ -170,8 +170,6 @@ pub fn log2q(a: f128) callconv(.c) f128 {
 
 pub fn log2l(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __log2h(x),
-        32 => return log2f(x),
         64 => return log2(x),
         80 => return __log2x(x),
         128 => return log2q(x),
diff --git a/lib/compiler_rt/round.zig b/lib/compiler_rt/round.zig
index 8087fd6e1529fdc42012074257e12e5017de8dae..590b957922efdbf33ac4fea2728390daad82ee38 100644
--- a/lib/compiler_rt/round.zig
+++ b/lib/compiler_rt/round.zig
@@ -142,8 +142,6 @@ pub fn roundq(x_: f128) callconv(.c) f128 {
 
 pub fn roundl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __roundh(x),
-        32 => return roundf(x),
         64 => return round(x),
         80 => return __roundx(x),
         128 => return roundq(x),
diff --git a/lib/compiler_rt/sin.zig b/lib/compiler_rt/sin.zig
index 3f1509383bacbef90c8f81debc5a6eaeedbfdf7d..b3e46672eecc6276b5a24cdcec50f6a7f8c97018 100644
--- a/lib/compiler_rt/sin.zig
+++ b/lib/compiler_rt/sin.zig
@@ -189,8 +189,6 @@ pub fn sinq(x: f128) callconv(.c) f128 {
 
 pub fn sinl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return sinh(x),
-        32 => return sinf(x),
         64 => return sin(x),
         80 => return sinx(x),
         128 => return sinq(x),
diff --git a/lib/compiler_rt/sincos.zig b/lib/compiler_rt/sincos.zig
index 7208325c2b86f65dd6736437572eea3c09235ff3..1ec9b81ac0c6b0611afe57c7b4176f257a3e3469 100644
--- a/lib/compiler_rt/sincos.zig
+++ b/lib/compiler_rt/sincos.zig
@@ -292,8 +292,6 @@ pub fn sincosq(x: f128, r_sin: *f128, r_cos: *f128) callconv(.c) void {
 
 pub fn sincosl(x: c_longdouble, r_sin: *c_longdouble, r_cos: *c_longdouble) callconv(.c) void {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return sincosh(x, r_sin, r_cos),
-        32 => return sincosf(x, r_sin, r_cos),
         64 => return sincos(x, r_sin, r_cos),
         80 => return sincosx(x, r_sin, r_cos),
         128 => return sincosq(x, r_sin, r_cos),
diff --git a/lib/compiler_rt/sqrt.zig b/lib/compiler_rt/sqrt.zig
index e765414fb0f418ea9f6d1d71e03c4fa73ff36ca9..be2f58a12fd25213f2a1ebe7f8e150db18f92078 100644
--- a/lib/compiler_rt/sqrt.zig
+++ b/lib/compiler_rt/sqrt.zig
@@ -481,8 +481,6 @@ fn _Qp_sqrt(c: *f128, a: *f128) callconv(.c) void {
 
 pub fn sqrtl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __sqrth(x),
-        32 => return sqrtf(x),
         64 => return sqrt(x),
         80 => return __sqrtx(x),
         128 => return sqrtq(x),
diff --git a/lib/compiler_rt/tan.zig b/lib/compiler_rt/tan.zig
index 378491aad6d25de04a4cbeb15747eb20e118b25b..b9d996d8b94d2fc05cebdb213038be0c38a0e235 100644
--- a/lib/compiler_rt/tan.zig
+++ b/lib/compiler_rt/tan.zig
@@ -164,8 +164,6 @@ pub fn tanq(x: f128) callconv(.c) f128 {
 
 pub fn tanl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return tanh(x),
-        32 => return tanf(x),
         64 => return tan(x),
         80 => return tanx(x),
         128 => return tanq(x),
diff --git a/lib/compiler_rt/trunc.zig b/lib/compiler_rt/trunc.zig
index b7846307034b667b5ae631d470689da9a3eb9b98..aa2eb560dfd8035f14aa07c8e51c5c117daad042 100644
--- a/lib/compiler_rt/trunc.zig
+++ b/lib/compiler_rt/trunc.zig
@@ -99,8 +99,6 @@ pub fn truncq(x: f128) callconv(.c) f128 {
 
 pub fn truncl(x: c_longdouble) callconv(.c) c_longdouble {
     switch (@typeInfo(c_longdouble).float.bits) {
-        16 => return __trunch(x),
-        32 => return truncf(x),
         64 => return trunc(x),
         80 => return __truncx(x),
         128 => return truncq(x),
diff --git a/lib/std/Target.zig b/lib/std/Target.zig
index bfd5f2cbba4ece95498a5de0939bc34c6d1fc0a6..2b06ba33f476059917d6d0818d55b71d190ac374 100644
--- a/lib/std/Target.zig
+++ b/lib/std/Target.zig
@@ -3082,8 +3082,6 @@ pub fn cTypeByteSize(t: *const Target, c_type: CType) u16 {
         => @divExact(cTypeBitSize(t, c_type), 8),
 
         .longdouble => switch (cTypeBitSize(t, c_type)) {
-            16 => 2,
-            32 => 4,
             64 => 8,
             80 => @intCast(std.mem.alignForward(usize, 10, cTypeAlignment(t, .longdouble))),
             128 => 16,
diff --git a/lib/std/c.zig b/lib/std/c.zig
index f0b03917855a2261fad5352220329c6904f922dc..4e1bc6594339b4597058afbac119ae96c1218acb 100644
--- a/lib/std/c.zig
+++ b/lib/std/c.zig
@@ -11102,6 +11102,14 @@ pub const ioctl = switch (native_os) {
     else => private.ioctl,
 };
 
+// Math
+pub extern "c" fn atan(x: f64) callconv(.c) f64;
+pub extern "c" fn copysign(x: f64, y: f64) callconv(.c) f64;
+pub extern "c" fn fdim(x: f64, y: f64) callconv(.c) f64;
+pub extern "c" fn frexp(x: f64, e: *c_int) callconv(.c) f64;
+pub extern "c" fn hypot(x: f64, y: f64) callconv(.c) f64;
+pub extern "c" fn modf(x: f64, iptr: *f64) callconv(.c) f64;
+
 // OS-specific bits. These are protected from being used on the wrong OS by
 // comptime assertions inside each OS-specific file.
 
diff --git a/src/codegen/aarch64/Select.zig b/src/codegen/aarch64/Select.zig
index 2bfb3c4a552c2d453a7612ea07ada56eae490308..4c45bb966766d02d79f067c005bef3d046b3e8a7 100644
--- a/src/codegen/aarch64/Select.zig
+++ b/src/codegen/aarch64/Select.zig
@@ -12381,8 +12381,6 @@ pub const CallAbiIterator = struct {
                 .f128 => .quad,
                 .c_longdouble => switch (zcu.getTarget().cTypeBitSize(.longdouble)) {
                     else => unreachable,
-                    16 => .half,
-                    32 => .single,
                     64 => .double,
                     80 => null,
                     128 => .quad,
diff --git a/test/behavior/cast.zig b/test/behavior/cast.zig
index fcc6d7c6b992b7a120cee9104577107571ffb23c..63e6fa1b86cce326cf77dd1e6610d1980dced95b 100644
--- a/test/behavior/cast.zig
+++ b/test/behavior/cast.zig
@@ -1838,8 +1838,6 @@ test "coerce between pointers of compatible differently-named floats" {
     }
 
     const F = switch (@typeInfo(c_longdouble).float.bits) {
-        16 => f16,
-        32 => f32,
         64 => f64,
         80 => f80,
         128 => f128,