From 9c20449cc5be5da0458556e143980b40d51e8776 Mon Sep 17 00:00:00 2001
From: Robin Voetter <robin@voetter.nl>
Date: Sat, 14 Oct 2023 12:52:31 +0200
Subject: [PATCH] wasm: lower min/max for floats to compiler_rt

The min and max builtins in Zig have some intricate behavior
related to floats, that is not replicated with the min and max
wasm instructions or using simple select operations. By lowering
these instructions to compiler_rt, handling around NaNs is done
correctly.

See also https://github.com/WebAssembly/design/issues/214
---
 src/arch/wasm/CodeGen.zig         | 28 +++++++++++++++++++++-------
 test/behavior/maximum_minimum.zig |  6 ++++++
 2 files changed, 27 insertions(+), 7 deletions(-)

diff --git a/src/arch/wasm/CodeGen.zig b/src/arch/wasm/CodeGen.zig
index ebcccd781d72edd1e531806c18c7f8343060c818..3eac273164e17c8481e11a96926a655415ea139c 100644
--- a/src/arch/wasm/CodeGen.zig
+++ b/src/arch/wasm/CodeGen.zig
@@ -6253,8 +6253,10 @@ fn airMulWithOverflow(func: *CodeGen, inst: Air.Inst.Index) InnerError!void {
     func.finishAir(inst, result_ptr, &.{ extra.lhs, extra.rhs });
 }
 
-fn airMaxMin(func: *CodeGen, inst: Air.Inst.Index, op: enum { max, min }) InnerError!void {
+fn airMaxMin(func: *CodeGen, inst: Air.Inst.Index, op: Op) InnerError!void {
+    assert(op == .max or op == .min);
     const mod = func.bin_file.base.options.module.?;
+    const target = mod.getTarget();
     const bin_op = func.air.instructions.items(.data)[inst].bin_op;
 
     const ty = func.typeOfIndex(inst);
@@ -6269,13 +6271,25 @@ fn airMaxMin(func: *CodeGen, inst: Air.Inst.Index, op: enum { max, min }) InnerE
     const lhs = try func.resolveInst(bin_op.lhs);
     const rhs = try func.resolveInst(bin_op.rhs);
 
-    // operands to select from
-    try func.lowerToStack(lhs);
-    try func.lowerToStack(rhs);
-    _ = try func.cmp(lhs, rhs, ty, if (op == .max) .gt else .lt);
+    if (ty.zigTypeTag(mod) == .Float) {
+        var fn_name_buf: [64]u8 = undefined;
+        const float_bits = ty.floatBits(target);
+        const fn_name = std.fmt.bufPrint(&fn_name_buf, "{s}f{s}{s}", .{
+            target_util.libcFloatPrefix(float_bits),
+            @tagName(op),
+            target_util.libcFloatSuffix(float_bits),
+        }) catch unreachable;
+        const result = try func.callIntrinsic(fn_name, &.{ ty.ip_index, ty.ip_index }, ty, &.{ lhs, rhs });
+        try func.lowerToStack(result);
+    } else {
+        // operands to select from
+        try func.lowerToStack(lhs);
+        try func.lowerToStack(rhs);
+        _ = try func.cmp(lhs, rhs, ty, if (op == .max) .gt else .lt);
 
-    // based on the result from comparison, return operand 0 or 1.
-    try func.addTag(.select);
+        // based on the result from comparison, return operand 0 or 1.
+        try func.addTag(.select);
+    }
 
     // store result in local
     const result_ty = if (isByRef(ty, mod)) Type.u32 else ty;
diff --git a/test/behavior/maximum_minimum.zig b/test/behavior/maximum_minimum.zig
index 0b9ca8c63666b14f7ce8e4bc1a7a81592d6c71f0..ecc32a33f6a6df0967e29272549813cc29c7b066 100644
--- a/test/behavior/maximum_minimum.zig
+++ b/test/behavior/maximum_minimum.zig
@@ -123,6 +123,12 @@ test "@min/max for floats" {
             try expectEqual(x, @min(y, x));
             try expectEqual(y, @max(x, y));
             try expectEqual(y, @max(y, x));
+
+            if (T != comptime_float) {
+                var nan: T = std.math.nan(T);
+                try expectEqual(y, @max(nan, y));
+                try expectEqual(y, @max(y, nan));
+            }
         }
     };
 
-- 
2.54.0