Add the ldexp family of functions, proxy to std.math.ldexp

Addresses ziglang#23358

Author: James Cox-Morton

lib/compiler_rt.zig

@@ -224,6 +224,7 @@ comptime {
     _ = @import("compiler_rt/fmax.zig");
     _ = @import("compiler_rt/fmin.zig");
     _ = @import("compiler_rt/fmod.zig");
+    _ = @import("compiler_rt/ldexp.zig");
     _ = @import("compiler_rt/log.zig");
     _ = @import("compiler_rt/log10.zig");
     _ = @import("compiler_rt/log2.zig");

lib/compiler_rt/ldexp.zig

@@ -0,0 +1,70 @@
+const std = @import("std");
+const expect = std.testing.expect;
+const math = std.math;
+const common = @import("common.zig");
+
+comptime {
+    @export(&ldexp, .{ .name = "ldexp", .linkage = common.linkage, .visibility = common.visibility });
+    @export(&ldexpf, .{ .name = "ldexpf", .linkage = common.linkage, .visibility = common.visibility });
+    @export(&ldexpl, .{ .name = "ldexpl", .linkage = common.linkage, .visibility = common.visibility });
+}
+
+pub fn ldexp(x: f64, n: i32) callconv(.c) f64 {
+    return math.ldexp(x, n);
+}
+
+test "ldexp" {
+    // Ported from libc-test
+    // https://repo.or.cz/libc-test.git/blob/HEAD:/src/math/sanity/ldexp.h
+    try expect(ldexp(-0x1.02239f3c6a8f1p+3, -2) == -0x1.02239f3c6a8f1p+1);
+}
+
+test "ldexp.special" {
+    // Ported from libc-test
+    // https://repo.or.cz/libc-test.git/blob/HEAD:/src/math/special/ldexp.h
+    try expect(math.isNan(ldexp(math.nan(f64), 0)));
+    try expect(math.isPositiveInf(ldexp(math.inf(f64), 0)));
+}
+
+pub fn ldexpf(x: f32, n: i32) callconv(.c) f32 {
+    return math.ldexp(x, n);
+}
+
+test "ldexpf" {
+    // Ported from libc-test
+    // https://repo.or.cz/libc-test.git/blob/HEAD:/src/math/sanity/ldexpf.h
+    try expect(ldexpf(-0x1.0223ap+3, -2) == -0x1.0223ap+1);
+}
+
+test "ldexpf.special" {
+    // Ported from libc-test
+    // https://repo.or.cz/libc-test.git/blob/HEAD:/src/math/special/ldexpf.h
+    try expect(math.isNan(ldexpf(math.nan(f32), 0)));
+    try expect(math.isPositiveInf(ldexpf(math.inf(f32), 0)));
+}
+
+pub fn ldexpl(x: c_longdouble, n: i32) callconv(.c) c_longdouble {
+    switch (@typeInfo(c_longdouble).float.bits) {
+        16 => return math.ldexp(@as(f16, x), n),
+        32 => return math.ldexp(@as(f32, x), n),
+        64 => return math.ldexp(@as(f64, x), n),
+        80 => return math.ldexp(@as(f80, x), n),
+        128 => return math.ldexp(@as(f128, x), n),
+        else => @compileError("unreachable"),
+    }
+}
+
+test "ldexpl" {
+    // Ported from libc-test
+    // https://repo.or.cz/libc-test.git/blob/HEAD:/src/math/sanity/ldexpl.h
+    const x: c_longdouble = -0x1.02239f3c6a8f13dep+3;
+    const expected: c_longdouble = -0x1.02239f3c6a8f13dep+1;
+    try expect(ldexpl(x, -2) == expected);
+}
+
+test "ldexpl.special" {
+    // Ported from libc-test
+    // https://repo.or.cz/libc-test.git/blob/HEAD:/src/math/special/ldexpl.h
+    try expect(math.isNan(ldexpl(math.nan(c_longdouble), 0)));
+    try expect(math.isPositiveInf(ldexpl(math.inf(c_longdouble), 0)));
+}

test/link/build.zig.zon

@@ -54,6 +54,9 @@
         .wasm_type = .{
             .path = "wasm/type",
         },
+        .wasm_ldexp = .{
+            .path = "wasm/ldexp",
+        },
     },
     .paths = .{
         "build.zig",

test/link/wasm/ldexp/build.zig

@@ -0,0 +1,34 @@
+const std = @import("std");
+
+pub fn build(b: *std.Build) void {
+    const test_step = b.step("test", "Test it");
+    b.default_step = test_step;
+
+    // Ensure ldexp symbols are available in Release modes
+    // Regression test for https://github.com/ziglang/zig/issues/23358
+    add(b, test_step, .ReleaseSafe);
+    add(b, test_step, .ReleaseFast);
+    add(b, test_step, .ReleaseSmall);
+    // Also verify Debug still works
+    add(b, test_step, .Debug);
+}
+
+fn add(b: *std.Build, test_step: *std.Build.Step, optimize: std.builtin.OptimizeMode) void {
+    const exe = b.addExecutable(.{
+        .name = "ldexp_test",
+        .root_module = b.createModule(.{
+            .root_source_file = b.path("lib.zig"),
+            .target = b.resolveTargetQuery(.{ .cpu_arch = .wasm32, .os_tag = .freestanding }),
+            .optimize = optimize,
+        }),
+    });
+
+    exe.entry = .disabled;
+    exe.rdynamic = true;
+
+    exe.root_module.export_symbol_names = &.{ "use_double", "use_float", "use_long" };
+
+    b.installArtifact(exe);
+
+    test_step.dependOn(&exe.step);
+}

test/link/wasm/ldexp/lib.zig

@@ -0,0 +1,16 @@
+// Test that LLVM's exp2 optimization requiring ldexp symbols works correctly.
+// In Release modes, LLVM's LibCallSimplifier converts exp2 calls to ldexp
+// when the input is an integer converted to float.
+// See https://github.com/ziglang/zig/issues/23358
+
+export fn use_double(f: i32) f64 {
+    return @exp2(@as(f64, @floatFromInt(f)));
+}
+
+export fn use_float(f: i32) f32 {
+    return @exp2(@as(f32, @floatFromInt(f)));
+}
+
+export fn use_long(f: i32) f128 {
+    return @exp2(@as(f128, @floatFromInt(f)));
+}