diff --git a/lib/compiler_rt/extendxftf2.zig b/lib/compiler_rt/extendxftf2.zig index 55324be2b4..8809dbcc80 100644 --- a/lib/compiler_rt/extendxftf2.zig +++ b/lib/compiler_rt/extendxftf2.zig @@ -15,8 +15,6 @@ fn __extendxftf2(a: f80) callconv(.C) f128 { const dst_bits = @bitSizeOf(f128); - const dst_min_normal = @as(u128, 1) << dst_sig_bits; - // Break a into a sign and representation of the absolute value var a_rep = std.math.F80.fromFloat(a); const sign = a_rep.exp & 0x8000; @@ -36,12 +34,7 @@ fn __extendxftf2(a: f80) callconv(.C) f128 { abs_result |= @as(u128, a_rep.exp) << dst_sig_bits; } else { // a is denormal - // renormalize the significand and clear the leading bit and integer part, - // then insert the correct adjusted exponent in the destination type. - const scale: u32 = @clz(a_rep.fraction); - abs_result = @as(u128, a_rep.fraction) << @intCast(dst_sig_bits - src_sig_bits + scale + 1); - abs_result ^= dst_min_normal; - abs_result |= @as(u128, scale + 1) << dst_sig_bits; + abs_result = @as(u128, a_rep.fraction) << (dst_sig_bits - src_sig_bits); } // Apply the signbit to (dst_t)abs(a). diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig index 3a185acfc1..16e73c161a 100644 --- a/src/arch/x86_64/CodeGen.zig +++ b/src/arch/x86_64/CodeGen.zig @@ -1421,7 +1421,7 @@ fn asmCmovccRegisterRegister(self: *CodeGen, cc: Condition, reg1: Register, reg2 }, .data = .{ .rr = .{ .fixes = switch (cc) { - else => .fromCondition(cc), + else => .fromCond(cc), .z_and_np, .nz_or_p => ._, }, .r1 = reg1, @@ -1449,7 +1449,7 @@ fn asmCmovccRegisterMemory(self: *CodeGen, cc: Condition, reg: Register, m: Memo }, .data = .{ .rx = .{ .fixes = switch (cc) { - else => .fromCondition(cc), + else => .fromCond(cc), .z_and_np => unreachable, .nz_or_p => ._, }, @@ -1476,7 +1476,7 @@ fn asmSetccRegister(self: *CodeGen, cc: Condition, reg: Register) !void { }, .data = switch (cc) { else => .{ .r = .{ - .fixes = .fromCondition(cc), + .fixes = .fromCond(cc), .r1 = reg, } }, .z_and_np, .nz_or_p => .{ .rr = .{ @@ -1501,7 +1501,7 @@ fn asmSetccMemory(self: *CodeGen, cc: Condition, m: Memory) !void { }, .data = switch (cc) { else => .{ .x = .{ - .fixes = .fromCondition(cc), + .fixes = .fromCond(cc), .payload = payload, } }, .z_and_np, .nz_or_p => .{ .rx = .{ @@ -1536,7 +1536,7 @@ fn asmJccReloc(self: *CodeGen, cc: Condition, target: Mir.Inst.Index) !Mir.Inst. }, .data = .{ .inst = .{ .fixes = switch (cc) { - else => .fromCondition(cc), + else => .fromCond(cc), .z_and_np, .nz_or_p => ._, }, .inst = target, @@ -2224,7 +2224,7 @@ fn gen(self: *CodeGen) InnerError!void { else => |cc| return self.fail("{s} does not support var args", .{@tagName(cc)}), }; - try self.asmPseudo(.pseudo_dbg_prologue_end_none); + if (self.debug_output != .none) try self.asmPseudo(.pseudo_dbg_prologue_end_none); try self.genBody(self.air.getMainBody()); @@ -2235,7 +2235,7 @@ fn gen(self: *CodeGen) InnerError!void { break :epilogue_relocs self.epilogue_relocs.items[0..epilogue_relocs_last_index]; } else self.epilogue_relocs.items) |epilogue_reloc| self.performReloc(epilogue_reloc); - try self.asmPseudo(.pseudo_dbg_epilogue_begin_none); + if (self.debug_output != .none) try self.asmPseudo(.pseudo_dbg_epilogue_begin_none); const backpatch_stack_dealloc = try self.asmPlaceholder(); const backpatch_pop_callee_preserved_regs = try self.asmPlaceholder(); try self.asmRegister(.{ ._, .pop }, .rbp); @@ -2354,15 +2354,15 @@ fn gen(self: *CodeGen) InnerError!void { }); } } else { - try self.asmPseudo(.pseudo_dbg_prologue_end_none); + if (self.debug_output != .none) try self.asmPseudo(.pseudo_dbg_prologue_end_none); try self.genBody(self.air.getMainBody()); - try self.asmPseudo(.pseudo_dbg_epilogue_begin_none); + if (self.debug_output != .none) try self.asmPseudo(.pseudo_dbg_epilogue_begin_none); } // Drop them off at the rbrace. - _ = try self.addInst(.{ + if (self.debug_output != .none) _ = try self.addInst(.{ .tag = .pseudo, - .ops = .pseudo_dbg_line_stmt_line_column, + .ops = .pseudo_dbg_line_line_column, .data = .{ .line_column = .{ .line = self.end_di_line, .column = self.end_di_column, @@ -2387,13 +2387,13 @@ fn checkInvariantsAfterAirInst(self: *CodeGen) void { } fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { - try self.asmPseudo(.pseudo_dbg_enter_block_none); + if (self.debug_output != .none) try self.asmPseudo(.pseudo_dbg_enter_block_none); try self.genBody(body); - try self.asmPseudo(.pseudo_dbg_leave_block_none); + if (self.debug_output != .none) try self.asmPseudo(.pseudo_dbg_leave_block_none); } fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { - @setEvalBranchQuota(3_400); + @setEvalBranchQuota(3_600); const pt = cg.pt; const zcu = pt.zcu; const ip = &zcu.intern_pool; @@ -2543,7 +2543,20 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .reduce_optimized => try cg.airReduce(inst), .int_from_float_optimized => try cg.airIntFromFloat(inst), - .arg => try cg.airDbgArg(inst), + .arg => if (cg.debug_output != .none) { + // skip zero-bit arguments as they don't have a corresponding arg instruction + var arg_index = cg.arg_index; + while (cg.args[arg_index] == .none) arg_index += 1; + cg.arg_index = arg_index + 1; + + const name = air_datas[@intFromEnum(inst)].arg.name; + if (name != .none) try cg.genLocalDebugInfo(inst, cg.getResolvedInstValue(inst).short); + if (cg.liveness.isUnused(inst)) try cg.processDeath(inst); + + for (cg.args[arg_index + 1 ..]) |arg| { + if (arg != .none) break; + } else try cg.airDbgVarArgs(); + }, .ptr_add => |air_tag| if (use_old) try cg.airPtrArithmetic(inst, air_tag) else { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; @@ -2794,7 +2807,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .max => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else fallback: { const bin_op = air_datas[@intFromEnum(inst)].bin_op; - if (cg.typeOf(bin_op.lhs).scalarType(zcu).isRuntimeFloat()) break :fallback try cg.airBinOp(inst, air_tag); + const ty = cg.typeOf(bin_op.lhs); + if (ty.isVector(zcu) and cg.floatBits(ty.childType(zcu)) != null) break :fallback try cg.airBinOp(inst, air_tag); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -5359,6 +5373,409 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ }, .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, } }, + }, .{ + .required_features = .{ .f16c, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .word, .is = .word } }, + .{ .scalar_float = .{ .of = .word, .is = .word } }, + }, + .patterns = &.{ + .{ .src = .{ .to_sse, .to_sse } }, + }, + .extra_temps = .{ + .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, + .{ .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, + .each = .{ .once = &.{ + .{ ._, .v_ps, .cvtph2, .dst0x, .src0x, ._, ._ }, + .{ ._, .v_ps, .cvtph2, .tmp0x, .src1x, ._, ._ }, + .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, + .{ ._, .v_ss, .max, .dst0x, .tmp0x, .dst0x, ._ }, + .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, + .{ ._, .v_, .cvtps2ph, .dst0x, .dst0x, .rm(.{}), ._ }, + } }, + }, .{ + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .word, .is = .word } }, + .{ .scalar_float = .{ .of = .word, .is = .word } }, + }, + .patterns = &.{ + .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fmaxh" } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .dst_temps = .{.{ .ref = .src0 }}, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .dword, .is = .dword } }, + .{ .scalar_float = .{ .of = .dword, .is = .dword } }, + }, + .patterns = &.{ + .{ .src = .{ .to_sse, .to_sse } }, + }, + .extra_temps = .{ + .{ .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, + .each = .{ .once = &.{ + .{ ._, .v_ss, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, + .{ ._, .v_ss, .max, .dst0x, .src1x, .src0x, ._ }, + .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, + } }, + }, .{ + .required_features = .{ .sse4_1, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .dword, .is = .dword } }, + .{ .scalar_float = .{ .of = .dword, .is = .dword } }, + }, + .patterns = &.{ + .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, + }, + .dst_temps = .{.{ .rc = .sse }}, + .each = .{ .once = &.{ + .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, + .{ ._, ._ss, .max, .dst0x, .src0x, ._, ._ }, + .{ ._, ._ss, .cmp, .src0x, .src0x, .vp(.unord), ._ }, + .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, + } }, + }, .{ + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .dword, .is = .dword } }, + .{ .scalar_float = .{ .of = .dword, .is = .dword } }, + }, + .patterns = &.{ + .{ .src = .{ .to_mut_sse, .to_sse } }, + }, + .extra_temps = .{ + .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .ref = .src0 }}, + .each = .{ .once = &.{ + .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, + .{ ._, ._ss, .max, .tmp0x, .src0x, ._, ._ }, + .{ ._, ._ss, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, + .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, + .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, + .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + }, + .patterns = &.{ + .{ .src = .{ .to_sse, .to_sse } }, + }, + .extra_temps = .{ + .{ .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, + .each = .{ .once = &.{ + .{ ._, .v_sd, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, + .{ ._, .v_sd, .max, .dst0x, .src1x, .src0x, ._ }, + .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, + } }, + }, .{ + .required_features = .{ .sse4_1, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + }, + .patterns = &.{ + .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, + }, + .dst_temps = .{.{ .rc = .sse }}, + .each = .{ .once = &.{ + .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, + .{ ._, ._sd, .max, .dst0x, .src0x, ._, ._ }, + .{ ._, ._sd, .cmp, .src0x, .src0x, .vp(.unord), ._ }, + .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ }, + } }, + }, .{ + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + }, + .patterns = &.{ + .{ .src = .{ .to_mut_sse, .to_sse } }, + }, + .extra_temps = .{ + .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .ref = .src0 }}, + .each = .{ .once = &.{ + .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, + .{ ._, ._sd, .max, .tmp0x, .src0x, ._, ._ }, + .{ ._, ._sd, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, + .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, + .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, + .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + }, + .patterns = &.{ + .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmax" } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .dst_temps = .{.{ .ref = .src0 }}, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + } }, + }, .{ + .required_features = .{ .x87, .cmov, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + }, + .patterns = &.{ + .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, + .{ .src = .{ .mem, .to_x87 } }, + .{ .src = .{ .to_x87, .to_x87 } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .ucomi, .tmp0t, .tmp0t, ._, ._ }, + .{ ._, .f_u, .cmov, .tmp0t, .src1t, ._, ._ }, + .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, + .{ ._, .f_, .ucomi, .tmp0t, .src1t, ._, ._ }, + .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, + .{ ._, .f_nb, .cmov, .tmp0t, .src1t, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sahf, .x87, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + }, + .patterns = &.{ + .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, + .{ .src = .{ .mem, .to_x87 } }, + .{ .src = .{ .to_x87, .to_x87 } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u8, .kind = .{ .reg = .ah } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .ucom, .tmp0t, ._, ._, ._ }, + .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .sahf, ._, ._, ._, ._ }, + .{ ._, ._p, .j, .@"0f", ._, ._, ._ }, + .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, + .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, + .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, + .{ ._, ._, .sahf, ._, ._, ._, ._ }, + .{ ._, ._b, .j, .@"1f", ._, ._, ._ }, + .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_features = .{ .@"64bit", .x87, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + }, + .patterns = &.{ + .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, + .{ .src = .{ .mem, .to_x87 } }, + .{ .src = .{ .to_x87, .to_x87 } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u8, .kind = .{ .reg = .ah } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .xam, ._, ._, ._, ._ }, + .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .@"test", .tmp1b, .si(0b0_1_000_100), ._, ._ }, + .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, + .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, + .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, + .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, + .{ ._, ._, .@"test", .tmp1b, .si(0b0_0_000_001), ._, ._ }, + .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, + .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + }, + .patterns = &.{ + .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, + .{ .src = .{ .mem, .to_x87 } }, + .{ .src = .{ .to_x87, .to_x87 } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u8, .kind = .{ .reg = .ah } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .ucom, .tmp0t, ._, ._, ._ }, + .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .sahf, ._, ._, ._, ._ }, + .{ ._, ._p, .j, .@"0f", ._, ._, ._ }, + .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, + .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, + .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, .f_, .xch, .src1t, ._, ._, ._ }, + .{ ._, ._, .sahf, ._, ._, ._, ._ }, + .{ ._, ._b, .j, .@"1f", ._, ._, ._ }, + .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .xword } }, + .{ .scalar_float = .{ .of = .xword, .is = .xword } }, + }, + .patterns = &.{ + .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmaxq" } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .dst_temps = .{.{ .ref = .src0 }}, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + } }, } }) catch |err| switch (err) { error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ @tagName(air_tag), @@ -5372,7 +5789,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .min => |air_tag| if (use_old) try cg.airBinOp(inst, air_tag) else fallback: { const bin_op = air_datas[@intFromEnum(inst)].bin_op; - if (cg.typeOf(bin_op.lhs).scalarType(zcu).isRuntimeFloat()) break :fallback try cg.airBinOp(inst, air_tag); + const ty = cg.typeOf(bin_op.lhs); + if (ty.isVector(zcu) and cg.floatBits(ty.childType(zcu)) != null) break :fallback try cg.airBinOp(inst, air_tag); var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); var res: [1]Temp = undefined; cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ @@ -7943,6 +8361,401 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .@"test", .tmp0p, .tmp0p, ._, ._ }, .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, } }, + }, .{ + .required_features = .{ .f16c, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .word, .is = .word } }, + .{ .scalar_float = .{ .of = .word, .is = .word } }, + }, + .patterns = &.{ + .{ .src = .{ .to_sse, .to_sse } }, + }, + .extra_temps = .{ + .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, + .{ .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, + .each = .{ .once = &.{ + .{ ._, .v_ps, .cvtph2, .dst0x, .src0x, ._, ._ }, + .{ ._, .v_ps, .cvtph2, .tmp0x, .src1x, ._, ._ }, + .{ ._, .v_ss, .cmp, .tmp1x, .dst0x, .dst0x, .vp(.unord) }, + .{ ._, .v_ss, .min, .dst0x, .tmp0x, .dst0x, ._ }, + .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp0x, .tmp1x }, + .{ ._, .v_, .cvtps2ph, .dst0x, .dst0x, .rm(.{}), ._ }, + } }, + }, .{ + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .word, .is = .word } }, + .{ .scalar_float = .{ .of = .word, .is = .word } }, + }, + .patterns = &.{ + .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__fminh" } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .dst_temps = .{.{ .ref = .src0 }}, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .dword, .is = .dword } }, + .{ .scalar_float = .{ .of = .dword, .is = .dword } }, + }, + .patterns = &.{ + .{ .src = .{ .to_sse, .to_sse } }, + }, + .extra_temps = .{ + .{ .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, + .each = .{ .once = &.{ + .{ ._, .v_ss, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, + .{ ._, .v_ss, .min, .dst0x, .src1x, .src0x, ._ }, + .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, + } }, + }, .{ + .required_features = .{ .sse4_1, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .dword, .is = .dword } }, + .{ .scalar_float = .{ .of = .dword, .is = .dword } }, + }, + .patterns = &.{ + .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, + }, + .dst_temps = .{.{ .rc = .sse }}, + .each = .{ .once = &.{ + .{ ._, ._ps, .mova, .dst0x, .src1x, ._, ._ }, + .{ ._, ._ss, .min, .dst0x, .src0x, ._, ._ }, + .{ ._, ._ss, .cmp, .src0x, .src0x, .vp(.unord), ._ }, + .{ ._, ._ps, .blendv, .dst0x, .src1x, .src0x, ._ }, + } }, + }, .{ + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .dword, .is = .dword } }, + .{ .scalar_float = .{ .of = .dword, .is = .dword } }, + }, + .patterns = &.{ + .{ .src = .{ .to_mut_sse, .to_sse } }, + }, + .extra_temps = .{ + .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .ref = .src0 }}, + .each = .{ .once = &.{ + .{ ._, ._ps, .mova, .tmp0x, .src1x, ._, ._ }, + .{ ._, ._ss, .min, .tmp0x, .src0x, ._, ._ }, + .{ ._, ._ss, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, + .{ ._, ._ps, .@"and", .tmp0x, .dst0x, ._, ._ }, + .{ ._, ._ps, .andn, .dst0x, .src1x, ._, ._ }, + .{ ._, ._ps, .@"or", .dst0x, .tmp0x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .avx, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + }, + .patterns = &.{ + .{ .src = .{ .to_sse, .to_sse } }, + }, + .extra_temps = .{ + .{ .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .mut_rc = .{ .ref = .src0, .rc = .sse } }}, + .each = .{ .once = &.{ + .{ ._, .v_sd, .cmp, .tmp0x, .src0x, .src0x, .vp(.unord) }, + .{ ._, .v_sd, .min, .dst0x, .src1x, .src0x, ._ }, + .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .src1x, .tmp0x }, + } }, + }, .{ + .required_features = .{ .sse4_1, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + }, + .patterns = &.{ + .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse } }, + }, + .dst_temps = .{.{ .rc = .sse }}, + .each = .{ .once = &.{ + .{ ._, ._pd, .mova, .dst0x, .src1x, ._, ._ }, + .{ ._, ._sd, .min, .dst0x, .src0x, ._, ._ }, + .{ ._, ._sd, .cmp, .src0x, .src0x, .vp(.unord), ._ }, + .{ ._, ._pd, .blendv, .dst0x, .src1x, .src0x, ._ }, + } }, + }, .{ + .required_features = .{ .sse2, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + }, + .patterns = &.{ + .{ .src = .{ .to_mut_sse, .to_sse } }, + }, + .extra_temps = .{ + .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .ref = .src0 }}, + .each = .{ .once = &.{ + .{ ._, ._pd, .mova, .tmp0x, .src1x, ._, ._ }, + .{ ._, ._sd, .min, .tmp0x, .src0x, ._, ._ }, + .{ ._, ._sd, .cmp, .dst0x, .src0x, .vp(.ord), ._ }, + .{ ._, ._pd, .@"and", .tmp0x, .dst0x, ._, ._ }, + .{ ._, ._pd, .andn, .dst0x, .src1x, ._, ._ }, + .{ ._, ._pd, .@"or", .dst0x, .tmp0x, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + .{ .scalar_float = .{ .of = .qword, .is = .qword } }, + }, + .patterns = &.{ + .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fmin" } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .dst_temps = .{.{ .ref = .src0 }}, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + } }, + }, .{ + .required_features = .{ .x87, .cmov, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + }, + .patterns = &.{ + .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, + .{ .src = .{ .mem, .to_x87 } }, + .{ .src = .{ .to_x87, .to_x87 } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .ucomi, .tmp0t, .tmp0t, ._, ._ }, + .{ ._, .f_u, .cmov, .tmp0t, .src1t, ._, ._ }, + .{ ._, .f_, .ucomi, .tmp0t, .src1t, ._, ._ }, + .{ ._, .f_nb, .cmov, .tmp0t, .src1t, ._, ._ }, + .{ ._, .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sahf, .x87, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + }, + .patterns = &.{ + .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, + .{ .src = .{ .mem, .to_x87 } }, + .{ .src = .{ .to_x87, .to_x87 } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u8, .kind = .{ .reg = .ah } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .ucom, .tmp0t, ._, ._, ._ }, + .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .sahf, ._, ._, ._, ._ }, + .{ ._, ._p, .j, .@"0f", ._, ._, ._ }, + .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, + .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .sahf, ._, ._, ._, ._ }, + .{ ._, ._b, .j, .@"1f", ._, ._, ._ }, + .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_features = .{ .@"64bit", .x87, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + }, + .patterns = &.{ + .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, + .{ .src = .{ .mem, .to_x87 } }, + .{ .src = .{ .to_x87, .to_x87 } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u8, .kind = .{ .reg = .ah } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .xam, ._, ._, ._, ._ }, + .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .@"test", .tmp1b, .si(0b0_1_000_100), ._, ._ }, + .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, + .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, + .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .@"test", .tmp1b, .si(0b0_0_000_001), ._, ._ }, + .{ ._, ._nz, .j, .@"1f", ._, ._, ._ }, + .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_features = .{ .x87, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + .{ .scalar_float = .{ .of = .xword, .is = .tbyte } }, + }, + .patterns = &.{ + .{ .src = .{ .to_x87, .mem }, .commute = .{ 0, 1 } }, + .{ .src = .{ .mem, .to_x87 } }, + .{ .src = .{ .to_x87, .to_x87 } }, + }, + .extra_temps = .{ + .{ .type = .f80, .kind = .{ .reg = .st7 } }, + .{ .type = .u8, .kind = .{ .reg = .ah } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .dst_temps = .{.{ .mut_rc = .{ .ref = .src1, .rc = .x87 } }}, + .clobbers = .{ .eflags = true }, + .each = .{ .once = &.{ + .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, + .{ ._, .f_, .ucom, .tmp0t, ._, ._, ._ }, + .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .sahf, ._, ._, ._, ._ }, + .{ ._, ._p, .j, .@"0f", ._, ._, ._ }, + .{ ._, .f_, .ucom, .src1t, ._, ._, ._ }, + .{ ._, .fn_sw, .st, .tmp1w, ._, ._, ._ }, + .{ ._, ._, .sahf, ._, ._, ._, ._ }, + .{ ._, ._b, .j, .@"1f", ._, ._, ._ }, + .{ .@"0:", .f_p, .st, .tmp0t, ._, ._, ._ }, + .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, + .{ .@"1:", .f_p, .st, .dst0t, ._, ._, ._ }, + } }, + }, .{ + .required_features = .{ .sse, null, null, null }, + .src_constraints = .{ + .{ .scalar_float = .{ .of = .xword, .is = .xword } }, + .{ .scalar_float = .{ .of = .xword, .is = .xword } }, + }, + .patterns = &.{ + .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 } } }, + }, + .call_frame = .{ .alignment = .@"16" }, + .extra_temps = .{ + .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "fminq" } } }, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + .unused, + }, + .clobbers = .{ .eflags = true, .caller_preserved = .ccc }, + .dst_temps = .{.{ .ref = .src0 }}, + .each = .{ .once = &.{ + .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, + } }, } }) catch |err| switch (err) { error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ @tagName(air_tag), @@ -8591,7 +9404,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .dst_temps = .{.{ .rc = .sse }}, .each = .{ .once = &.{ - .{ ._, .v_pd, .cmp, .dst0y, .dst0y, .dst0y, .ui(0b01111) }, + .{ ._, .v_pd, .cmp, .dst0y, .dst0y, .dst0y, .vp(.true) }, .{ ._, .v_pd, .xor, .dst0y, .dst0y, .src0y, ._ }, } }, }, .{ @@ -8693,7 +9506,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0p, .sia(16, .src0, .sub_size), ._, ._ }, - .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .ui(0b01111) }, + .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.true) }, .{ .@"0:", .v_pd, .xor, .tmp2y, .tmp1y, .memiad(.src0y, .tmp0, .add_size, -16), ._ }, .{ ._, .v_pd, .movu, .memiad(.dst0y, .tmp0, .add_size, -16), .tmp2y, ._, ._ }, .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, @@ -8722,7 +9535,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, - .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .ui(0b01111) }, + .{ ._, .v_pd, .cmp, .tmp1y, .tmp1y, .tmp1y, .vp(.true) }, .{ .@"0:", .v_pd, .xor, .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_size), ._ }, .{ ._, .v_pd, .movu, .memia(.dst0y, .tmp0, .add_size), .tmp2y, ._, ._ }, .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, @@ -9406,7 +10219,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { }, .dst_temps = .{.{ .rc = .sse }}, .each = .{ .once = &.{ - .{ ._, .v_pd, .cmp, .dst0y, .dst0y, .dst0y, .ui(0b01111) }, + .{ ._, .v_pd, .cmp, .dst0y, .dst0y, .dst0y, .vp(.true) }, .{ ._, .v_pd, .xor, .dst0y, .dst0y, .src0y, ._ }, } }, }, .{ @@ -9493,12 +10306,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { try res[0].finish(inst, &.{ty_op.operand}, &ops, cg); }, - .block => if (use_old) try cg.airBlock(inst) else { + .block => { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const extra = cg.air.extraData(Air.Block, ty_pl.payload); - try cg.asmPseudo(.pseudo_dbg_enter_block_none); + if (cg.debug_output != .none) try cg.asmPseudo(.pseudo_dbg_enter_block_none); try cg.lowerBlock(inst, @ptrCast(cg.air.extra[extra.end..][0..extra.data.body_len])); - try cg.asmPseudo(.pseudo_dbg_leave_block_none); + if (cg.debug_output != .none) try cg.asmPseudo(.pseudo_dbg_leave_block_none); }, .loop => if (use_old) try cg.airLoop(inst) else { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; @@ -13852,7 +14665,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, .{ .@"0:", ._, .mov, .tmp2b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, .{ ._, ._, .cmp, .tmp2b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, @@ -13884,7 +14697,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, .{ .@"0:", ._, .mov, .tmp2w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, .{ ._, ._, .cmp, .tmp2w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, @@ -13916,7 +14729,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, .{ ._, ._, .cmp, .tmp2d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, @@ -13949,7 +14762,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .xor, .tmp1b, .tmp1b, ._, ._ }, .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, .{ ._, ._, .cmp, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, @@ -13988,7 +14801,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .sub, .tmp2d, .si(1), ._, ._ }, .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp2b, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .dst0b, .tmp2b, ._, ._ }, .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, @@ -14021,7 +14834,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, .{ ._, ._, .mov, .tmp3b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, .{ ._, ._, .cmp, .tmp3b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, @@ -14054,7 +14867,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, .{ ._, ._, .mov, .tmp3w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, .{ ._, ._, .cmp, .tmp3w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, @@ -14087,7 +14900,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, .{ ._, ._, .cmp, .tmp3d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, @@ -14121,7 +14934,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, .{ ._, ._, .mov, .tmp3q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, .{ ._, ._, .cmp, .tmp3q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, @@ -14161,7 +14974,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp2d, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp2d, ._, ._ }, .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, @@ -14195,7 +15008,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, .{ ._, ._, .mov, .tmp3b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, .{ ._, ._, .cmp, .tmp3b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, @@ -14228,7 +15041,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, .{ ._, ._, .mov, .tmp3w, .memia(.src0w, .tmp0, .add_size), ._, ._ }, .{ ._, ._, .cmp, .tmp3w, .memia(.src1w, .tmp0, .add_size), ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, @@ -14262,7 +15075,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, .{ ._, ._, .mov, .tmp3d, .memia(.src0d, .tmp0, .add_size), ._, ._ }, .{ ._, ._, .cmp, .tmp3d, .memia(.src1d, .tmp0, .add_size), ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, @@ -14296,7 +15109,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ }, .{ ._, ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_size), ._, ._ }, .{ ._, ._, .cmp, .tmp2q, .memia(.src1q, .tmp0, .add_size), ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, @@ -14337,7 +15150,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._b, .j, .@"1b", ._, ._, ._ }, .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, .{ ._, ._, .@"test", .tmp3p, .tmp3p, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp2b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp2b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp2q, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .dst0q, .tmp2q, ._, ._ }, .{ ._, ._, .add, .tmp1b, .si(1), ._, ._ }, @@ -14369,7 +15182,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .@"0:", ._, .xor, .tmp3d, .tmp3d, ._, ._ }, .{ ._, ._, .mov, .tmp4b, .memia(.src0b, .tmp0, .add_size), ._, ._ }, .{ ._, ._, .cmp, .tmp4b, .memia(.src1b, .tmp0, .add_size), ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, .{ ._, ._l, .sh, .tmp3p, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .tmp2p, .tmp3p, ._, ._ }, .{ ._, ._, .add, .tmp1d, .si(1), ._, ._ }, @@ -14397,7 +15210,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .to_sse } }, }, .extra_temps = .{ - .{ .kind = .{ .rc = .sse } }, + .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, .unused, .unused, .unused, @@ -14415,10 +15228,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .each = .{ .once = &.{ .{ ._, .v_ps, .cvtph2, .dst0x, .src0x, ._, ._ }, .{ ._, .v_ps, .cvtph2, .tmp0x, .src1x, ._, ._ }, - .{ ._, .v_ss, .cmp, .dst0x, .dst0x, .tmp0x, .ui(switch (cc) { + .{ ._, .v_ss, .cmp, .dst0x, .dst0x, .tmp0x, .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, } }, }, .{ @@ -14452,10 +15265,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .each = .{ .once = &.{ .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ }, .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ }, - .{ ._, .v_ps, .cmp, .dst0x, .dst0x, .tmp0x, .ui(switch (cc) { + .{ ._, .v_ps, .cmp, .dst0x, .dst0x, .tmp0x, .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, } }, }, .{ @@ -14489,10 +15302,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .each = .{ .once = &.{ .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ }, .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ }, - .{ ._, .v_ps, .cmp, .dst0y, .dst0y, .tmp0y, .ui(switch (cc) { + .{ ._, .v_ps, .cmp, .dst0y, .dst0y, .tmp0y, .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, } }, }, .{ @@ -14512,10 +15325,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .info = .{ .kind = .all, .scalar = .dword }, } }}, .each = .{ .once = &.{ - .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1x, .ui(switch (cc) { + .{ ._, .v_ss, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, } }, }, .{ @@ -14534,10 +15347,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .info = .{ .kind = .all, .scalar = .dword }, } }}, .each = .{ .once = &.{ - .{ ._, ._ss, .cmp, .dst0x, .src1x, .ui(switch (cc) { + .{ ._, ._ss, .cmp, .dst0x, .src1x, .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }), ._ }, } }, }, .{ @@ -14557,10 +15370,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .info = .{ .kind = .all, .scalar = .dword }, } }}, .each = .{ .once = &.{ - .{ ._, .v_ps, .cmp, .dst0x, .src0x, .src1x, .ui(switch (cc) { + .{ ._, .v_ps, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, } }, }, .{ @@ -14579,10 +15392,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .info = .{ .kind = .all, .scalar = .dword }, } }}, .each = .{ .once = &.{ - .{ ._, ._ps, .cmp, .dst0x, .src1x, .ui(switch (cc) { + .{ ._, ._ps, .cmp, .dst0x, .src1x, .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }), ._ }, } }, }, .{ @@ -14602,10 +15415,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .info = .{ .kind = .all, .scalar = .dword }, } }}, .each = .{ .once = &.{ - .{ ._, .v_ps, .cmp, .dst0y, .src0y, .src1y, .ui(switch (cc) { + .{ ._, .v_ps, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, } }, }, .{ @@ -14625,10 +15438,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .info = .{ .kind = .all, .scalar = .qword }, } }}, .each = .{ .once = &.{ - .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1x, .ui(switch (cc) { + .{ ._, .v_sd, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, } }, }, .{ @@ -14647,10 +15460,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .info = .{ .kind = .all, .scalar = .qword }, } }}, .each = .{ .once = &.{ - .{ ._, ._sd, .cmp, .dst0x, .src1x, .ui(switch (cc) { + .{ ._, ._sd, .cmp, .dst0x, .src1x, .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }), ._ }, } }, }, .{ @@ -14670,10 +15483,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .info = .{ .kind = .all, .scalar = .qword }, } }}, .each = .{ .once = &.{ - .{ ._, .v_pd, .cmp, .dst0x, .src0x, .src1x, .ui(switch (cc) { + .{ ._, .v_pd, .cmp, .dst0x, .src0x, .src1x, .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, } }, }, .{ @@ -14692,10 +15505,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .info = .{ .kind = .all, .scalar = .qword }, } }}, .each = .{ .once = &.{ - .{ ._, ._pd, .cmp, .dst0x, .src1x, .ui(switch (cc) { + .{ ._, ._pd, .cmp, .dst0x, .src1x, .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }), ._ }, } }, }, .{ @@ -14715,10 +15528,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .info = .{ .kind = .all, .scalar = .qword }, } }}, .each = .{ .once = &.{ - .{ ._, .v_pd, .cmp, .dst0y, .src0y, .src1y, .ui(switch (cc) { + .{ ._, .v_pd, .cmp, .dst0y, .src0y, .src1y, .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, } }, }, .{ @@ -14748,10 +15561,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, .{ .@"0:", .v_ps, .cvtph2, .tmp2y, .memia(.src0x, .tmp0, .add_size), ._, ._ }, .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src1x, .tmp0, .add_size), ._, ._ }, - .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .tmp3y, .ui(switch (cc) { + .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .tmp3y, .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, .{ ._, .v_ps, .movmsk, .tmp4d, .tmp2y, ._, ._ }, .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp4b, ._, ._ }, @@ -14786,10 +15599,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, .{ .@"0:", .v_ps, .cvtph2, .tmp2y, .memia(.src0x, .tmp0, .add_size), ._, ._ }, .{ ._, .v_ps, .cvtph2, .tmp3y, .memia(.src1x, .tmp0, .add_size), ._, ._ }, - .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .tmp3y, .ui(switch (cc) { + .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .tmp3y, .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, .{ ._, .v_ps, .movmsk, .tmp4d, .tmp2y, ._, ._ }, .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp4b, ._, ._ }, @@ -14834,7 +15647,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp6b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, @@ -14879,7 +15692,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp6b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, @@ -14925,7 +15738,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp6b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, @@ -14971,7 +15784,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp6b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, @@ -15019,7 +15832,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp6b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, @@ -15067,7 +15880,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp3d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, .{ ._, ._, .@"test", .tmp4d, .tmp4d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp6b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp6b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, .{ ._, ._l, .sh, .tmp6d, .tmp5b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp6d, ._, ._ }, @@ -15111,7 +15924,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, @@ -15166,7 +15979,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, @@ -15222,7 +16035,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, @@ -15278,7 +16091,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, @@ -15336,7 +16149,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, @@ -15394,7 +16207,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp6d, .tmp0d, ._, ._ }, .{ ._, ._l, .sh, .tmp7q, .tmp6b, ._, ._ }, .{ ._, ._, .@"or", .tmp1q, .tmp7q, ._, ._ }, @@ -15439,10 +16252,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, .{ .@"0:", .v_ps, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, - .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .ui(switch (cc) { + .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, .{ ._, .v_ps, .movmsk, .tmp3d, .tmp2y, ._, ._ }, .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp3b, ._, ._ }, @@ -15476,10 +16289,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, .{ .@"0:", .v_ps, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, - .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .ui(switch (cc) { + .{ ._, .v_ps, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, .{ ._, .v_ps, .movmsk, .tmp3d, .tmp2y, ._, ._ }, .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp3b, ._, ._ }, @@ -15514,15 +16327,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, .{ ._, ._ps, .mova, .tmp3x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ }, - .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .ui(switch (cc) { + .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }), ._ }, - .{ ._, ._ps, .cmp, .tmp3x, .memiad(.src1x, .tmp0, .add_size, 16), .ui(switch (cc) { + .{ ._, ._ps, .cmp, .tmp3x, .memiad(.src1x, .tmp0, .add_size, 16), .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }), ._ }, .{ ._, .p_w, .ackssd, .tmp2x, .tmp3x, ._, ._ }, .{ ._, .p_b, .ackssw, .tmp2x, .tmp2x, ._, ._ }, @@ -15558,17 +16371,17 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ }, .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, .{ .@"0:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, - .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .ui(switch (cc) { + .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }), ._ }, .{ ._, ._ps, .movmsk, .tmp3d, .tmp2x, ._, ._ }, .{ ._, ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, 16), ._, ._ }, - .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, 16), .ui(switch (cc) { + .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, 16), .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }), ._ }, .{ ._, ._ps, .movmsk, .tmp4d, .tmp2x, ._, ._ }, .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ }, @@ -15605,10 +16418,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, .{ ._, ._mp, .j, .@"1f", ._, ._, ._ }, .{ .@"0:", ._ps, .mova, .tmp2x, .memiad(.src0x, .tmp0, .add_size, -16), ._, ._ }, - .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, -16), .ui(switch (cc) { + .{ ._, ._ps, .cmp, .tmp2x, .memiad(.src1x, .tmp0, .add_size, -16), .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }), ._ }, .{ ._, ._ps, .movmsk, .tmp4d, .tmp2x, ._, ._ }, .{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ }, @@ -15616,10 +16429,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .lea(.byte, .tmp1), .tmp3b, ._, ._ }, .{ ._, ._, .lea, .tmp1p, .lead(.none, .tmp1, 1), ._, ._ }, .{ .@"1:", ._ps, .mova, .tmp2x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, - .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .ui(switch (cc) { + .{ ._, ._ps, .cmp, .tmp2x, .memia(.src1x, .tmp0, .add_size), .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }), ._ }, .{ ._, ._ps, .movmsk, .tmp3d, .tmp2x, ._, ._ }, .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, @@ -15653,15 +16466,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, .{ .@"0:", .v_pd, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, .{ ._, .v_pd, .mova, .tmp3y, .memiad(.src0y, .tmp0, .add_size, 32), ._, ._ }, - .{ ._, .v_pd, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .ui(switch (cc) { + .{ ._, .v_pd, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, - .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memiad(.src1y, .tmp0, .add_size, 32), .ui(switch (cc) { + .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memiad(.src1y, .tmp0, .add_size, 32), .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, .{ ._, .v_pd, .movmsk, .tmp4d, .tmp2y, ._, ._ }, .{ ._, .v_pd, .movmsk, .tmp5d, .tmp3y, ._, ._ }, @@ -15699,15 +16512,15 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .lea, .tmp1p, .mem(.dst0), ._, ._ }, .{ .@"0:", .v_pd, .mova, .tmp2y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, .{ ._, .v_pd, .mova, .tmp3y, .memiad(.src0y, .tmp0, .add_size, 32), ._, ._ }, - .{ ._, .v_pd, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .ui(switch (cc) { + .{ ._, .v_pd, .cmp, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, - .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memiad(.src1y, .tmp0, .add_size, 32), .ui(switch (cc) { + .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memiad(.src1y, .tmp0, .add_size, 32), .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, .{ ._, .v_pd, .movmsk, .tmp4d, .tmp2y, ._, ._ }, .{ ._, .v_pd, .movmsk, .tmp5d, .tmp3y, ._, ._ }, @@ -15745,10 +16558,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, .{ .@"0:", .v_pd, .mova, .tmp3y, .memia(.src0y, .tmp0, .add_size), ._, ._ }, - .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), .ui(switch (cc) { + .{ ._, .v_pd, .cmp, .tmp3y, .tmp3y, .memia(.src1y, .tmp0, .add_size), .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }) }, .{ ._, .v_pd, .movmsk, .tmp4d, .tmp3y, ._, ._ }, .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, @@ -15795,10 +16608,10 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, .{ .@"0:", ._pd, .mova, .tmp3x, .memia(.src0x, .tmp0, .add_size), ._, ._ }, - .{ ._, ._pd, .cmp, .tmp3x, .memia(.src1x, .tmp0, .add_size), .ui(switch (cc) { + .{ ._, ._pd, .cmp, .tmp3x, .memia(.src1x, .tmp0, .add_size), .vp(switch (cc) { else => unreachable, - .e => 0b00000, - .ne => 0b00100, + .e => .eq, + .ne => .neq, }), ._ }, .{ ._, ._pd, .movmsk, .tmp4d, .tmp3x, ._, ._ }, .{ ._, ._l, .ro, .tmp4b, .tmp1b, ._, ._ }, @@ -15850,7 +16663,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_, .ld, .memia(.src0q, .tmp0, .add_size), ._, ._, ._ }, .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ }, .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, .{ ._, switch (cc) { else => unreachable, .e => ._np, @@ -15910,7 +16723,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_, .ld, .memia(.src0q, .tmp0, .add_size), ._, ._, ._ }, .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ }, .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, .{ ._, switch (cc) { else => unreachable, .e => ._np, @@ -15971,7 +16784,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .fn_sw, .st, .tmp6w, ._, ._, ._ }, .{ ._, ._, .xor, .tmp6b, .si(0b0_1_000_000), ._, ._ }, .{ ._, ._, .@"test", .tmp6b, .si(0b0_1_000_100), ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, @@ -16021,7 +16834,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ }, .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, .{ ._, switch (cc) { else => unreachable, .e => ._np, @@ -16081,7 +16894,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .f_, .ld, .memia(.src0t, .tmp0, .add_size), ._, ._, ._ }, .{ ._, .f_p, .ucomi, .tmp5t, .tmp6t, ._, ._ }, .{ ._, .f_p, .st, .tmp6t, ._, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, .{ ._, switch (cc) { else => unreachable, .e => ._np, @@ -16142,7 +16955,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, .fn_sw, .st, .tmp6w, ._, ._, ._ }, .{ ._, ._, .xor, .tmp6b, .si(0b0_1_000_000), ._, ._ }, .{ ._, ._, .@"test", .tmp6b, .si(0b0_1_000_100), ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp3b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp3b, ._, ._, ._ }, .{ ._, ._l, .ro, .tmp3b, .tmp1b, ._, ._ }, .{ ._, ._, .@"or", .tmp2b, .tmp3b, ._, ._ }, .{ ._, ._c, .in, .tmp1d, ._, ._, ._ }, @@ -16197,7 +17010,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, @@ -16242,7 +17055,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, @@ -16287,7 +17100,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, @@ -16332,7 +17145,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, @@ -16377,7 +17190,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, @@ -16422,7 +17235,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp4d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, .{ ._, ._, .@"test", .tmp5d, .tmp5d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp7b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp7b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp6d, .tmp1d, ._, ._ }, .{ ._, ._l, .sh, .tmp7d, .tmp6b, ._, ._ }, .{ ._, ._, .@"or", .dst0d, .tmp7d, ._, ._ }, @@ -16466,7 +17279,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp8b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, @@ -16521,7 +17334,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp8b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, @@ -16576,7 +17389,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp8b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, @@ -16631,7 +17444,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp8b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, @@ -16686,7 +17499,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp8b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, @@ -16741,7 +17554,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp5d, ._, ._, ._ }, .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, .{ ._, ._, .@"test", .tmp6d, .tmp6d, ._, ._ }, - .{ ._, .fromCondition(cc), .set, .tmp8b, ._, ._, ._ }, + .{ ._, .fromCond(cc), .set, .tmp8b, ._, ._, ._ }, .{ ._, ._, .mov, .tmp7d, .tmp1d, ._, ._ }, .{ ._, ._l, .sh, .tmp8q, .tmp7b, ._, ._ }, .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, @@ -18419,7 +19232,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .mov, .tmp1p, .memia(.src0p, .tmp0, .add_size), ._, ._ }, .{ ._, ._, .sbb, .tmp1p, .memia(.src1p, .tmp0, .add_size), ._, ._ }, .{ ._, ._c, .set, .tmp1b, ._, ._, ._ }, - .{ ._, .fromCondition(switch (cc) { + .{ ._, .fromCond(switch (cc) { else => unreachable, .l, .ge, .b, .ae => cc, .le, .g, .be, .a => cc.commute(), @@ -18979,8 +19792,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ .src = .{ .to_sse, .to_sse } }, }, .extra_temps = .{ - .{ .kind = .{ .rc = .sse } }, - .{ .kind = .{ .rc = .sse } }, + .{ .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } }, + .{ .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } }, .unused, .unused, .unused, @@ -18996,9 +19809,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { } }}, .clobbers = .{ .eflags = true }, .each = .{ .once = &.{ - .{ ._, .vp_, .unpcklwd, .tmp0x, .src0x, .src1x, ._ }, - .{ ._, .v_ps, .cvtph2, .tmp0x, .tmp0x, ._, ._ }, - .{ ._, .v_, .movshdup, .tmp1x, .tmp0x, ._, ._ }, + .{ ._, .v_ps, .cvtph2, .tmp0x, .src0x, ._, ._ }, + .{ ._, .v_ps, .cvtph2, .tmp1x, .src1x, ._, ._ }, .{ ._, .v_ss, .ucomi, .tmp0x, .tmp1x, ._, ._ }, } }, }, .{ @@ -19197,35 +20009,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .{ ._, ._, .call, .tmp0d, ._, ._, ._ }, .{ ._, ._, .@"test", .tmp1d, .tmp1d, ._, ._ }, } }, - }, .{ - .required_features = .{ .x87, .cmov, null, null }, - .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, - .patterns = &.{ - .{ .src = .{ .mem, .mem } }, - }, - .extra_temps = .{ - .{ .type = .f80, .kind = .{ .reg = .st6 } }, - .{ .type = .f80, .kind = .{ .reg = .st7 } }, - .unused, - .unused, - .unused, - .unused, - .unused, - .unused, - .unused, - }, - .dst_temps = .{.{ .cc = switch (cc) { - else => unreachable, - .e => .z_and_np, - .ne => .nz_or_p, - } }}, - .clobbers = .{ .eflags = true }, - .each = .{ .once = &.{ - .{ ._, .f_, .ld, .src1t, ._, ._, ._ }, - .{ ._, .f_, .ld, .src0t, ._, ._, ._ }, - .{ ._, .f_p, .ucomi, .tmp0t, .tmp1t, ._, ._ }, - .{ ._, .f_p, .st, .tmp1t, ._, ._, ._ }, - } }, }, .{ .required_features = .{ .x87, .cmov, null, null }, .src_constraints = .{ .{ .float = .tbyte }, .{ .float = .tbyte } }, @@ -19479,46 +20262,59 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { .switch_dispatch => try cg.airSwitchDispatch(inst), .@"try", .try_cold => try cg.airTry(inst), .try_ptr, .try_ptr_cold => try cg.airTryPtr(inst), - .dbg_stmt => if (use_old) try cg.airDbgStmt(inst) else { + .dbg_stmt => if (cg.debug_output != .none) { const dbg_stmt = air_datas[@intFromEnum(inst)].dbg_stmt; _ = try cg.addInst(.{ .tag = .pseudo, - .ops = .pseudo_dbg_line_line_column, + .ops = .pseudo_dbg_line_stmt_line_column, .data = .{ .line_column = .{ .line = dbg_stmt.line, .column = dbg_stmt.column, } }, }); }, - .dbg_empty_stmt => if (use_old) try cg.airDbgEmptyStmt() else { + .dbg_empty_stmt => if (cg.debug_output != .none) { if (cg.mir_instructions.len > 0) { const prev_mir_op = &cg.mir_instructions.items(.ops)[cg.mir_instructions.len - 1]; - if (prev_mir_op.* == .pseudo_dbg_line_stmt_line_column) - prev_mir_op.* = .pseudo_dbg_line_line_column; + if (prev_mir_op.* == .pseudo_dbg_line_line_column) + prev_mir_op.* = .pseudo_dbg_line_stmt_line_column; } try cg.asmOpOnly(.{ ._, .nop }); }, - .dbg_inline_block => if (use_old) try cg.airDbgInlineBlock(inst) else { + .dbg_inline_block => { const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; const extra = cg.air.extraData(Air.DbgInlineBlock, ty_pl.payload); const old_inline_func = cg.inline_func; defer cg.inline_func = old_inline_func; cg.inline_func = extra.data.func; - _ = try cg.addInst(.{ + if (cg.debug_output != .none) _ = try cg.addInst(.{ .tag = .pseudo, .ops = .pseudo_dbg_enter_inline_func, .data = .{ .func = extra.data.func }, }); try cg.lowerBlock(inst, @ptrCast(cg.air.extra[extra.end..][0..extra.data.body_len])); - _ = try cg.addInst(.{ + if (cg.debug_output != .none) _ = try cg.addInst(.{ .tag = .pseudo, .ops = .pseudo_dbg_leave_inline_func, .data = .{ .func = old_inline_func }, }); }, - .dbg_var_ptr, .dbg_var_val, .dbg_arg_inline => if (use_old) try cg.airDbgVar(inst) else { + .dbg_var_ptr, .dbg_var_val, .dbg_arg_inline => if (use_old) try cg.airDbgVar(inst) else if (cg.debug_output != .none) { const pl_op = air_datas[@intFromEnum(inst)].pl_op; var ops = try cg.tempsFromOperands(inst, .{pl_op.operand}); + var mcv = ops[0].tracking(cg).short; + switch (mcv) { + else => {}, + .eflags => |cc| switch (cc) { + else => {}, + // These values would self destruct. Maybe we make them use their + // turing complete dwarf expression interpreters for once? + .z_and_np, .nz_or_p => { + try cg.spillEflagsIfOccupied(); + mcv = ops[0].tracking(cg).short; + }, + }, + } try cg.genLocalDebugInfo(inst, ops[0].tracking(cg).short); try ops[0].die(cg); }, @@ -20725,7 +21521,7 @@ fn airFptrunc(self: *CodeGen, inst: Air.Inst.Index) !void { .{ .v_, .cvtps2ph }, dst_reg, mat_src_reg.to128(), - .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), + bits.RoundMode.imm(.{}), ); }, else => unreachable, @@ -24896,26 +25692,7 @@ fn airFloatSign(self: *CodeGen, inst: Air.Inst.Index, tag: Air.Inst.Tag) !void { return self.floatSign(inst, tag, un_op, ty); } -const RoundMode = packed struct(u5) { - mode: enum(u4) { - /// Round to nearest (even) - nearest = 0b0_00, - /// Round down (toward -∞) - down = 0b0_01, - /// Round up (toward +∞) - up = 0b0_10, - /// Round toward zero (truncate) - zero = 0b0_11, - /// Use current rounding mode of MXCSR.RC - mxcsr = 0b1_00, - }, - precision: enum(u1) { - normal = 0b0, - inexact = 0b1, - } = .normal, -}; - -fn airRound(self: *CodeGen, inst: Air.Inst.Index, mode: RoundMode) !void { +fn airRound(self: *CodeGen, inst: Air.Inst.Index, mode: bits.RoundMode) !void { const un_op = self.air.instructions.items(.data)[@intFromEnum(inst)].un_op; const ty = self.typeOf(un_op); @@ -24972,7 +25749,7 @@ fn getRoundTag(self: *CodeGen, ty: Type) ?Mir.Inst.FixedTag { } else null; } -fn genRoundLibcall(self: *CodeGen, ty: Type, src_mcv: MCValue, mode: RoundMode) !MCValue { +fn genRoundLibcall(self: *CodeGen, ty: Type, src_mcv: MCValue, mode: bits.RoundMode) !MCValue { const pt = self.pt; const zcu = pt.zcu; if (self.getRoundTag(ty)) |_| return .none; @@ -24997,7 +25774,7 @@ fn genRoundLibcall(self: *CodeGen, ty: Type, src_mcv: MCValue, mode: RoundMode) } }, &.{ty}, &.{src_mcv}, .{}); } -fn genRound(self: *CodeGen, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: RoundMode) !void { +fn genRound(self: *CodeGen, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: bits.RoundMode) !void { const pt = self.pt; const mir_tag = self.getRoundTag(ty) orelse { const result = try self.genRoundLibcall(ty, src_mcv, mode); @@ -25011,7 +25788,7 @@ fn genRound(self: *CodeGen, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: dst_alias, dst_alias, try src_mcv.mem(self, .{ .size = .fromSize(abi_size) }), - .u(@as(u5, @bitCast(mode))), + mode.imm(), ) else try self.asmRegisterRegisterRegisterImmediate( mir_tag, dst_alias, @@ -25020,13 +25797,13 @@ fn genRound(self: *CodeGen, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: src_mcv.getReg().? else try self.copyToTmpRegister(ty, src_mcv), abi_size), - .u(@as(u5, @bitCast(mode))), + mode.imm(), ), else => if (src_mcv.isBase()) try self.asmRegisterMemoryImmediate( mir_tag, dst_alias, try src_mcv.mem(self, .{ .size = .fromSize(abi_size) }), - .u(@as(u5, @bitCast(mode))), + mode.imm(), ) else try self.asmRegisterRegisterImmediate( mir_tag, dst_alias, @@ -25034,7 +25811,7 @@ fn genRound(self: *CodeGen, ty: Type, dst_reg: Register, src_mcv: MCValue, mode: src_mcv.getReg().? else try self.copyToTmpRegister(ty, src_mcv), abi_size), - .u(@as(u5, @bitCast(mode))), + mode.imm(), ), } } @@ -25294,7 +26071,7 @@ fn airSqrt(self: *CodeGen, inst: Air.Inst.Index) !void { .{ .v_, .cvtps2ph }, dst_reg, dst_reg, - .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), + bits.RoundMode.imm(.{}), ); break :result dst_mcv; }, @@ -25324,7 +26101,7 @@ fn airSqrt(self: *CodeGen, inst: Air.Inst.Index) !void { .{ .v_, .cvtps2ph }, dst_reg, dst_reg, - .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), + bits.RoundMode.imm(.{}), ); break :result dst_mcv; }, @@ -25349,7 +26126,7 @@ fn airSqrt(self: *CodeGen, inst: Air.Inst.Index) !void { .{ .v_, .cvtps2ph }, dst_reg, wide_reg, - .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), + bits.RoundMode.imm(.{}), ); break :result dst_mcv; }, @@ -27613,7 +28390,7 @@ fn genBinOp( .{ .v_, .cvtps2ph }, dst_reg, dst_reg, - .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), + bits.RoundMode.imm(.{}), ); break :adjusted .{ .register = dst_reg }; }, @@ -28086,14 +28863,14 @@ fn genBinOp( dst_reg, dst_reg, dst_reg, - .u(@as(u5, @bitCast(RoundMode{ + bits.RoundMode.imm(.{ .mode = switch (air_tag) { .div_trunc => .zero, .div_floor => .down, else => unreachable, }, .precision = .inexact, - }))), + }), ), else => {}, } @@ -28101,7 +28878,7 @@ fn genBinOp( .{ .v_, .cvtps2ph }, dst_reg, dst_reg, - .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), + bits.RoundMode.imm(.{}), ); return dst_mcv; }, @@ -28529,7 +29306,7 @@ fn genBinOp( .{ .v_, .cvtps2ph }, dst_reg, dst_reg, - .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), + bits.RoundMode.imm(.{}), ); return dst_mcv; }, @@ -28581,7 +29358,7 @@ fn genBinOp( .{ .v_, .cvtps2ph }, dst_reg, dst_reg, - .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), + bits.RoundMode.imm(.{}), ); return dst_mcv; }, @@ -28624,7 +29401,7 @@ fn genBinOp( .{ .v_, .cvtps2ph }, dst_reg, dst_reg, - .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), + bits.RoundMode.imm(.{}), ); return dst_mcv; }, @@ -28667,7 +29444,7 @@ fn genBinOp( .{ .v_, .cvtps2ph }, dst_reg, dst_reg.to256(), - .u(@as(u5, @bitCast(RoundMode{ .mode = .mxcsr }))), + bits.RoundMode.imm(.{}), ); return dst_mcv; }, @@ -28932,7 +29709,7 @@ fn genBinOp( mask_reg, rhs_copy_reg, rhs_copy_reg, - .u(3), // unord + bits.VexFloatPredicate.imm(.unord), ); try self.asmRegisterRegisterRegisterRegister( @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) { @@ -28999,7 +29776,7 @@ fn genBinOp( }), mask_reg, mask_reg, - .u(if (has_blend) 3 else 7), // unord, ord + bits.SseFloatPredicate.imm(if (has_blend) .unord else .ord), ); if (has_blend) try self.asmRegisterRegisterRegister( @as(?Mir.Inst.FixedTag, switch (lhs_ty.zigTypeTag(zcu)) { @@ -29836,24 +30613,10 @@ fn airArg(self: *CodeGen, inst: Air.Inst.Index) !void { return self.finishAir(inst, result, .{ .none, .none, .none }); } -fn airDbgArg(self: *CodeGen, inst: Air.Inst.Index) !void { - // skip zero-bit arguments as they don't have a corresponding arg instruction - var arg_index = self.arg_index; - while (self.args[arg_index] == .none) arg_index += 1; - self.arg_index = arg_index + 1; - - if (self.debug_output != .none) { - const name = self.air.instructions.items(.data)[@intFromEnum(inst)].arg.name; - if (name != .none) try self.genLocalDebugInfo(inst, self.getResolvedInstValue(inst).short); - if (self.liveness.isUnused(inst)) try self.processDeath(inst); - } - for (self.args[self.arg_index..]) |arg| { - if (arg != .none) break; - } else try self.airDbgVarArgs(); -} - fn airDbgVarArgs(self: *CodeGen) !void { - if (self.pt.zcu.typeToFunc(self.fn_type).?.is_var_args) try self.asmPseudo(.pseudo_dbg_var_args_none); + if (self.debug_output == .none) return; + if (!self.pt.zcu.typeToFunc(self.fn_type).?.is_var_args) return; + try self.asmPseudo(.pseudo_dbg_var_args_none); } fn genLocalDebugInfo( @@ -30909,44 +31672,6 @@ fn genTry( return result; } -fn airDbgStmt(self: *CodeGen, inst: Air.Inst.Index) !void { - const dbg_stmt = self.air.instructions.items(.data)[@intFromEnum(inst)].dbg_stmt; - _ = try self.addInst(.{ - .tag = .pseudo, - .ops = .pseudo_dbg_line_stmt_line_column, - .data = .{ .line_column = .{ - .line = dbg_stmt.line, - .column = dbg_stmt.column, - } }, - }); -} - -fn airDbgEmptyStmt(self: *CodeGen) !void { - if (self.mir_instructions.len > 0 and - self.mir_instructions.items(.ops)[self.mir_instructions.len - 1] == .pseudo_dbg_line_stmt_line_column) - self.mir_instructions.items(.ops)[self.mir_instructions.len - 1] = .pseudo_dbg_line_line_column; - try self.asmOpOnly(.{ ._, .nop }); -} - -fn airDbgInlineBlock(self: *CodeGen, inst: Air.Inst.Index) !void { - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; - const extra = self.air.extraData(Air.DbgInlineBlock, ty_pl.payload); - const old_inline_func = self.inline_func; - defer self.inline_func = old_inline_func; - self.inline_func = extra.data.func; - _ = try self.addInst(.{ - .tag = .pseudo, - .ops = .pseudo_dbg_enter_inline_func, - .data = .{ .func = extra.data.func }, - }); - try self.lowerBlock(inst, @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len])); - _ = try self.addInst(.{ - .tag = .pseudo, - .ops = .pseudo_dbg_leave_inline_func, - .data = .{ .func = old_inline_func }, - }); -} - fn airDbgVar(self: *CodeGen, inst: Air.Inst.Index) !void { const pl_op = self.air.instructions.items(.data)[@intFromEnum(inst)].pl_op; try self.genLocalDebugInfo(inst, try self.resolveInst(pl_op.operand)); @@ -31392,14 +32117,6 @@ fn airLoop(self: *CodeGen, inst: Air.Inst.Index) !void { try self.genBodyBlock(body); } -fn airBlock(self: *CodeGen, inst: Air.Inst.Index) !void { - const ty_pl = self.air.instructions.items(.data)[@intFromEnum(inst)].ty_pl; - const extra = self.air.extraData(Air.Block, ty_pl.payload); - try self.asmPseudo(.pseudo_dbg_enter_block_none); - try self.lowerBlock(inst, @ptrCast(self.air.extra[extra.end..][0..extra.data.body_len])); - try self.asmPseudo(.pseudo_dbg_leave_block_none); -} - fn lowerBlock(self: *CodeGen, inst: Air.Inst.Index, body: []const Air.Inst.Index) !void { // A block is a setup to be able to jump to the end. const inst_tracking_i = self.inst_tracking.count(); @@ -39918,46 +40635,46 @@ const Select = struct { inline .rc_mask, .mut_rc_mask, .ref_mask => |mask| temp.asMask(mask.info, s.cg), } } + + fn pass(kind: Kind) u2 { + return switch (kind) { + .unused => 0, + .reg => 1, + else => 2, + }; + } }; - fn pass(spec: TempSpec) u2 { - return switch (spec.kind) { - .unused => 0, - .reg => 1, - else => 2, - }; - } - - fn create(spec: TempSpec, s: *Select) !Temp { + fn create(spec: TempSpec, s: *Select) !struct { Temp, bool } { const cg = s.cg; return switch (spec.kind) { .unused => unreachable, - .any => try cg.tempAlloc(spec.type), - .cc => |cc| try cg.tempInit(spec.type, .{ .eflags = cc }), - .ref => |ref| ref.deref(s), - .reg => |reg| try cg.tempInit(spec.type, .{ .register = reg }), - .rc => |rc| try cg.tempAllocReg(spec.type, regSetForRegClass(rc)), + .any => .{ try cg.tempAlloc(spec.type), true }, + .cc => |cc| .{ try cg.tempInit(spec.type, .{ .eflags = cc }), true }, + .ref => |ref| .{ ref.deref(s), false }, + .reg => |reg| .{ try cg.tempInit(spec.type, .{ .register = reg }), true }, + .rc => |rc| .{ try cg.tempAllocReg(spec.type, regSetForRegClass(rc)), true }, .mut_rc => |ref_rc| { const temp = ref_rc.ref.deref(s); if (temp.isMut(cg)) switch (temp.tracking(cg).short) { - .register => |reg| if (reg.class() == ref_rc.rc) return temp, - .register_offset => |reg_off| if (reg_off.off == 0 and reg_off.reg.class() == ref_rc.rc) return temp, + .register => |reg| if (reg.class() == ref_rc.rc) return .{ temp, false }, + .register_offset => |reg_off| if (reg_off.off == 0 and reg_off.reg.class() == ref_rc.rc) return .{ temp, false }, else => {}, }; - return try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc.rc)); + return .{ try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc.rc)), true }; }, - .ref_mask => |ref_mask| ref_mask.ref.deref(s), - .rc_mask => |rc_mask| try cg.tempAllocReg(spec.type, regSetForRegClass(rc_mask.rc)), + .ref_mask => |ref_mask| .{ ref_mask.ref.deref(s), false }, + .rc_mask => |rc_mask| .{ try cg.tempAllocReg(spec.type, regSetForRegClass(rc_mask.rc)), true }, .mut_rc_mask => |ref_rc_mask| { const temp = ref_rc_mask.ref.deref(s); if (temp.isMut(cg)) switch (temp.tracking(cg).short) { - .register => |reg| if (reg.class() == ref_rc_mask.rc) return temp, - .register_offset => |reg_off| if (reg_off.off == 0 and reg_off.reg.class() == ref_rc_mask.rc) return temp, + .register => |reg| if (reg.class() == ref_rc_mask.rc) return .{ temp, false }, + .register_offset => |reg_off| if (reg_off.off == 0 and reg_off.reg.class() == ref_rc_mask.rc) return .{ temp, false }, else => {}, }; - return try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc_mask.rc)); + return .{ try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc_mask.rc)), true }; }, - .mem => try cg.tempAllocMem(spec.type), + .mem => .{ try cg.tempAllocMem(spec.type), true }, .smin_mem, .smax_mem, .umin_mem, .umax_mem => |const_info| { const pt = cg.pt; const zcu = pt.zcu; @@ -40022,13 +40739,16 @@ const Select = struct { })).toIntern(), .storage = .{ .repeated_elem = res_scalar_val.toIntern() }, } })) else res_scalar_val; - return try cg.tempMemFromValue(res_val); + return .{ try cg.tempMemFromValue(res_val), true }; }, - .symbol => |symbol| if (cg.bin_file.cast(.elf)) |elf_file| try cg.tempInit(spec.type, .{ .lea_symbol = .{ - .sym_index = try elf_file.getGlobalSymbol(symbol.name, symbol.lib), - } }) else if (cg.bin_file.cast(.macho)) |macho_file| try cg.tempInit(spec.type, .{ .lea_symbol = .{ - .sym_index = try macho_file.getGlobalSymbol(symbol.name, symbol.lib), - } }) else cg.fail("external symbols unimplemented for {s}", .{@tagName(cg.bin_file.tag)}), + .symbol => |symbol| .{ try cg.tempInit(spec.type, .{ .lea_symbol = .{ + .sym_index = if (cg.bin_file.cast(.elf)) |elf_file| + try elf_file.getGlobalSymbol(symbol.name, symbol.lib) + else if (cg.bin_file.cast(.macho)) |macho_file| + try macho_file.getGlobalSymbol(symbol.name, symbol.lib) + else + return cg.fail("external symbols unimplemented for {s}", .{@tagName(cg.bin_file.tag)}), + } }), true }, }; } }; @@ -40390,14 +41110,24 @@ const Select = struct { fn sia(imm: i32, base: Ref.Sized, adjust: Adjust) Select.Operand { return .{ .tag = .simm, .base = base, .adjust = adjust, .imm = imm }; } - fn ui(imm: i32) Select.Operand { - return .{ .tag = .uimm, .imm = imm }; + fn ui(imm: u32) Select.Operand { + return .{ .tag = .uimm, .imm = @bitCast(imm) }; } fn ua(base: Ref.Sized, adjust: Adjust) Select.Operand { return .{ .tag = .uimm, .base = base, .adjust = adjust }; } - fn uia(imm: i32, base: Ref.Sized, adjust: Adjust) Select.Operand { - return .{ .tag = .uimm, .base = base, .adjust = adjust, .imm = imm }; + fn uia(imm: u32, base: Ref.Sized, adjust: Adjust) Select.Operand { + return .{ .tag = .uimm, .base = base, .adjust = adjust, .imm = @bitCast(imm) }; + } + + fn rm(mode: bits.RoundMode) Select.Operand { + return .{ .tag = .uimm, .imm = @intCast(mode.imm().unsigned) }; + } + fn sp(pred: bits.SseFloatPredicate) Select.Operand { + return .{ .tag = .uimm, .imm = @intCast(pred.imm().unsigned) }; + } + fn vp(pred: bits.VexFloatPredicate) Select.Operand { + return .{ .tag = .uimm, .imm = @intCast(pred.imm().unsigned) }; } fn lea(size: Memory.Size, base: Ref) Select.Operand { @@ -40705,6 +41435,7 @@ fn select( .ccc => cg.target.cCallingConvention().?, .zigcc => .auto, }; + assert(case.clobbers.eflags); const err_ret_trace_reg = if (cc == .auto and cg.pt.zcu.comp.config.any_error_tracing) err_ret_trace_reg: { const param_gpr = abi.getCAbiIntParamRegs(.auto); break :err_ret_trace_reg param_gpr[param_gpr.len - 1]; @@ -40722,8 +41453,14 @@ fn select( @memcpy(src_slots[0..src_temps.len], src_temps); std.mem.swap(Temp, &src_slots[pattern.commute[0]], &src_slots[pattern.commute[1]]); - for (1..3) |pass| for (tmp_slots, case.extra_temps) |*slot, spec| if (pass == spec.pass()) { - slot.* = try spec.create(&s); + for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) |*dst_temp, dst_ty, dst_kind| { + if (dst_kind.pass() != 1) continue; + dst_temp.*, _ = try Select.TempSpec.create(.{ .type = dst_ty, .kind = dst_kind }, &s); + } + var tmp_owned: [tmp_slots.len]bool = @splat(false); + for (1..3) |pass| for (tmp_slots, &tmp_owned, case.extra_temps) |*slot, *owned, spec| { + if (spec.kind.pass() != pass) continue; + slot.*, owned.* = try spec.create(&s); }; while (true) for (pattern.src[0..src_temps.len], src_temps) |src_pattern, *src_temp| { @@ -40734,8 +41471,10 @@ fn select( if (case.clobbers.eflags) try cg.spillEflagsIfOccupied(); - for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) |*dst_temp, dst_ty, dst_kind| - dst_temp.* = (try Select.TempSpec.create(.{ .type = dst_ty, .kind = dst_kind }, &s)); + for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) |*dst_temp, dst_ty, dst_kind| { + if (dst_kind.pass() != 2) continue; + dst_temp.*, _ = try Select.TempSpec.create(.{ .type = dst_ty, .kind = dst_kind }, &s); + } @memcpy(dst_slots[0..dst_temps.len], dst_temps); switch (case.each) { @@ -40765,7 +41504,7 @@ fn select( } } for (dst_temps, case.dst_temps[0..dst_temps.len]) |dst_temp, dst_kind| dst_kind.finish(dst_temp, &s); - for (case.extra_temps, tmp_slots) |spec, temp| if (spec.kind != .unused) try temp.die(cg); + for (tmp_owned, tmp_slots) |owned, temp| if (owned) try temp.die(cg); return; } } diff --git a/src/arch/x86_64/Mir.zig b/src/arch/x86_64/Mir.zig index b4d0ed94e6..b03e363903 100644 --- a/src/arch/x86_64/Mir.zig +++ b/src/arch/x86_64/Mir.zig @@ -467,7 +467,7 @@ pub const Inst = struct { /// Mask ___ Quadword k_q, - pub fn fromCondition(cc: bits.Condition) Fixes { + pub fn fromCond(cc: bits.Condition) Fixes { return switch (cc) { inline else => |cc_tag| @field(Fixes, "_" ++ @tagName(cc_tag)), .z_and_np, .nz_or_p => unreachable, diff --git a/src/arch/x86_64/bits.zig b/src/arch/x86_64/bits.zig index 8aae83d4c2..d7cfd50ab1 100644 --- a/src/arch/x86_64/bits.zig +++ b/src/arch/x86_64/bits.zig @@ -177,6 +177,172 @@ pub const Condition = enum(u5) { } }; +/// The immediate operand of vcvtps2ph. +pub const RoundMode = packed struct(u5) { + mode: enum(u4) { + /// Round to nearest (even) + nearest = 0b0_00, + /// Round down (toward -∞) + down = 0b0_01, + /// Round up (toward +∞) + up = 0b0_10, + /// Round toward zero (truncate) + zero = 0b0_11, + /// Use current rounding mode of MXCSR.RC + mxcsr = 0b1_00, + } = .mxcsr, + precision: enum(u1) { + normal = 0b0, + inexact = 0b1, + } = .normal, + + pub fn imm(mode: RoundMode) Immediate { + return .u(@as(@typeInfo(RoundMode).@"struct".backing_integer.?, @bitCast(mode))); + } +}; + +/// The immediate operand of cmppd, cmpps, cmpsd, and cmpss. +pub const SseFloatPredicate = enum(u3) { + /// Equal (ordered, non-signaling) + eq, + /// Less-than (ordered, signaling) + lt, + /// Less-than-or-equal (ordered, signaling) + le, + /// Unordered (non-signaling) + unord, + /// Not-equal (unordered, non-signaling) + neq, + /// Not-less-than (unordered, signaling) + nlt, + /// Not-less-than-or-equal (unordered, signaling) + nle, + /// Ordered (non-signaling) + ord, + + /// Equal (ordered, non-signaling) + pub const eq_oq: SseFloatPredicate = .eq; + /// Less-than (ordered, signaling) + pub const lt_os: SseFloatPredicate = .lt; + /// Less-than-or-equal (ordered, signaling) + pub const le_os: SseFloatPredicate = .le; + /// Unordered (non-signaling) + pub const unord_q: SseFloatPredicate = .unord; + /// Not-equal (unordered, non-signaling) + pub const neq_uq: SseFloatPredicate = .neq; + /// Not-less-than (unordered, signaling) + pub const nlt_us: SseFloatPredicate = .nlt; + /// Not-less-than-or-equal (unordered, signaling) + pub const nle_us: SseFloatPredicate = .nle; + /// Ordered (non-signaling) + pub const ord_q: SseFloatPredicate = .ord; + + pub fn imm(pred: SseFloatPredicate) Immediate { + return .u(@intFromEnum(pred)); + } +}; + +/// The immediate operand of vcmppd, vcmpps, vcmpsd, and vcmpss. +pub const VexFloatPredicate = enum(u5) { + /// Equal (ordered, non-signaling) + eq_oq, + /// Less-than (ordered, signaling) + lt_os, + /// Less-than-or-equal (ordered, signaling) + le_os, + /// Unordered (non-signaling) + unord_q, + /// Not-equal (unordered, non-signaling) + neq_uq, + /// Not-less-than (unordered, signaling) + nlt_us, + /// Not-less-than-or-equal (unordered, signaling) + nle_us, + /// Ordered (non-signaling) + ord_q, + /// Equal (unordered, non-signaling) + eq_uq, + /// Not-greater-than-or-equal (unordered, signaling) + nge_us, + /// Not-greater-than (unordered, signaling) + ngt_us, + /// False (ordered, non-signaling) + false_oq, + /// Not-equal (ordered, non-signaling) + neq_oq, + /// Greater-than-or-equal (ordered, signaling) + ge_os, + /// Greater-than (ordered, signaling) + gt_os, + /// True (unordered, non-signaling) + true_uq, + /// Equal (unordered, non-signaling) + eq_os, + /// Less-than (ordered, non-signaling) + lt_oq, + /// Less-than-or-equal (ordered, non-signaling) + le_oq, + /// Unordered (signaling) + unord_s, + /// Not-equal (unordered, signaling) + neq_us, + /// Not-less-than (unordered, non-signaling) + nlt_uq, + /// Not-less-than-or-equal (unordered, non-signaling) + nle_uq, + /// Ordered (signaling) + ord_s, + /// Equal (unordered, signaling) + eq_us, + /// Not-greater-than-or-equal (unordered, non-signaling) + nge_uq, + /// Not-greater-than (unordered, non-signaling) + ngt_uq, + /// False (ordered, signaling) + false_os, + /// Not-equal (ordered, signaling) + neq_os, + /// Greater-than-or-equal (ordered, non-signaling) + ge_oq, + /// Greater-than (ordered, non-signaling) + gt_oq, + /// True (unordered, signaling) + true_us, + + /// Equal (ordered, non-signaling) + pub const eq: VexFloatPredicate = .eq_oq; + /// Less-than (ordered, signaling) + pub const lt: VexFloatPredicate = .lt_os; + /// Less-than-or-equal (ordered, signaling) + pub const le: VexFloatPredicate = .le_os; + /// Unordered (non-signaling) + pub const unord: VexFloatPredicate = .unord_q; + /// Not-equal (unordered, non-signaling) + pub const neq: VexFloatPredicate = .neq_uq; + /// Not-less-than (unordered, signaling) + pub const nlt: VexFloatPredicate = .nlt_us; + /// Not-less-than-or-equal (unordered, signaling) + pub const nle: VexFloatPredicate = .nle_us; + /// Ordered (non-signaling) + pub const ord: VexFloatPredicate = .ord_q; + /// Not-greater-than-or-equal (unordered, signaling) + pub const nge: VexFloatPredicate = .nge_us; + /// Not-greater-than (unordered, signaling) + pub const ngt: VexFloatPredicate = .ngt_us; + /// False (ordered, non-signaling) + pub const @"false": VexFloatPredicate = .false_oq; + /// Greater-than-or-equal (ordered, signaling) + pub const ge: VexFloatPredicate = .ge_os; + /// Greater-than (ordered, signaling) + pub const gt: VexFloatPredicate = .gt_os; + /// True (unordered, non-signaling) + pub const @"true": VexFloatPredicate = .true_uq; + + pub fn imm(pred: VexFloatPredicate) Immediate { + return .u(@intFromEnum(pred)); + } +}; + pub const Register = enum(u8) { // zig fmt: off rax, rcx, rdx, rbx, rsp, rbp, rsi, rdi, diff --git a/test/behavior/maximum_minimum.zig b/test/behavior/maximum_minimum.zig index f4601bd580..e9bcdab125 100644 --- a/test/behavior/maximum_minimum.zig +++ b/test/behavior/maximum_minimum.zig @@ -121,8 +121,8 @@ test "@min/max for floats" { if (builtin.zig_backend == .stage2_sparc64) return error.SkipZigTest; // TODO if (builtin.zig_backend == .stage2_spirv64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_c and builtin.cpu.arch.isArm()) return error.SkipZigTest; - if (builtin.zig_backend == .stage2_x86_64) return error.SkipZigTest; if (builtin.zig_backend == .stage2_riscv64) return error.SkipZigTest; + if (builtin.zig_backend == .stage2_x86_64 and builtin.target.ofmt != .elf and builtin.target.ofmt != .macho) return error.SkipZigTest; const S = struct { fn doTheTest(comptime T: type) !void { diff --git a/test/behavior/x86_64/build.zig b/test/behavior/x86_64/build.zig index 6d7a5573e4..d18d5eb5ee 100644 --- a/test/behavior/x86_64/build.zig +++ b/test/behavior/x86_64/build.zig @@ -35,6 +35,12 @@ pub fn build(b: *std.Build) void { .sse2, }), }, + .{ + .cpu_arch = .x86_64, + .cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64 }, + .cpu_features_add = std.Target.x86.featureSet(&.{.sahf}), + .cpu_features_sub = std.Target.x86.featureSet(&.{.cmov}), + }, //.{ // .cpu_arch = .x86_64, // .cpu_model = .{ .explicit = &std.Target.x86.cpu.x86_64 }, diff --git a/test/behavior/x86_64/math.zig b/test/behavior/x86_64/math.zig index 5ae2b9c769..26d0930b48 100644 --- a/test/behavior/x86_64/math.zig +++ b/test/behavior/x86_64/math.zig @@ -73,14 +73,20 @@ inline fn boolOr(lhs: anytype, rhs: @TypeOf(lhs)) @TypeOf(lhs) { } // noinline for a more helpful stack trace -noinline fn checkExpected(expected: anytype, actual: @TypeOf(expected)) !void { +noinline fn checkExpected(expected: anytype, actual: @TypeOf(expected), comptime strict: bool) !void { const info = @typeInfo(@TypeOf(expected)); - const unexpected = switch (switch (info) { + const unexpected = unexpected: switch (switch (info) { else => info, .vector => |vector| @typeInfo(vector.child), }) { else => expected != actual, - .float => boolOr(boolAnd(expected != actual, boolOr(expected == expected, actual == actual)), sign(expected) != sign(actual)), + .float => { + const unequal = boolAnd(expected != actual, boolOr(expected == expected, actual == actual)); + break :unexpected switch (strict) { + false => unequal, + true => boolOr(unequal, sign(expected) != sign(actual)), + }; + }, }; if (switch (info) { else => unexpected, @@ -88,43 +94,43 @@ noinline fn checkExpected(expected: anytype, actual: @TypeOf(expected)) !void { }) return error.Unexpected; } test checkExpected { - if (checkExpected(nan(f16), nan(f16)) == error.Unexpected) return error.Unexpected; - if (checkExpected(nan(f16), -nan(f16)) != error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f16, 0.0), @as(f16, 0.0)) == error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f16, -0.0), @as(f16, -0.0)) == error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f16, -0.0), @as(f16, 0.0)) != error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f16, 0.0), @as(f16, -0.0)) != error.Unexpected) return error.Unexpected; + if (checkExpected(nan(f16), nan(f16), true) == error.Unexpected) return error.Unexpected; + if (checkExpected(nan(f16), -nan(f16), true) != error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f16, 0.0), @as(f16, 0.0), true) == error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f16, -0.0), @as(f16, -0.0), true) == error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f16, -0.0), @as(f16, 0.0), true) != error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f16, 0.0), @as(f16, -0.0), true) != error.Unexpected) return error.Unexpected; - if (checkExpected(nan(f32), nan(f32)) == error.Unexpected) return error.Unexpected; - if (checkExpected(nan(f32), -nan(f32)) != error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f32, 0.0), @as(f32, 0.0)) == error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f32, -0.0), @as(f32, -0.0)) == error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f32, -0.0), @as(f32, 0.0)) != error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f32, 0.0), @as(f32, -0.0)) != error.Unexpected) return error.Unexpected; + if (checkExpected(nan(f32), nan(f32), true) == error.Unexpected) return error.Unexpected; + if (checkExpected(nan(f32), -nan(f32), true) != error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f32, 0.0), @as(f32, 0.0), true) == error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f32, -0.0), @as(f32, -0.0), true) == error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f32, -0.0), @as(f32, 0.0), true) != error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f32, 0.0), @as(f32, -0.0), true) != error.Unexpected) return error.Unexpected; - if (checkExpected(nan(f64), nan(f64)) == error.Unexpected) return error.Unexpected; - if (checkExpected(nan(f64), -nan(f64)) != error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f64, 0.0), @as(f64, 0.0)) == error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f64, -0.0), @as(f64, -0.0)) == error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f64, -0.0), @as(f64, 0.0)) != error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f64, 0.0), @as(f64, -0.0)) != error.Unexpected) return error.Unexpected; + if (checkExpected(nan(f64), nan(f64), true) == error.Unexpected) return error.Unexpected; + if (checkExpected(nan(f64), -nan(f64), true) != error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f64, 0.0), @as(f64, 0.0), true) == error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f64, -0.0), @as(f64, -0.0), true) == error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f64, -0.0), @as(f64, 0.0), true) != error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f64, 0.0), @as(f64, -0.0), true) != error.Unexpected) return error.Unexpected; - if (checkExpected(nan(f80), nan(f80)) == error.Unexpected) return error.Unexpected; - if (checkExpected(nan(f80), -nan(f80)) != error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f80, 0.0), @as(f80, 0.0)) == error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f80, -0.0), @as(f80, -0.0)) == error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f80, -0.0), @as(f80, 0.0)) != error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f80, 0.0), @as(f80, -0.0)) != error.Unexpected) return error.Unexpected; + if (checkExpected(nan(f80), nan(f80), true) == error.Unexpected) return error.Unexpected; + if (checkExpected(nan(f80), -nan(f80), true) != error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f80, 0.0), @as(f80, 0.0), true) == error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f80, -0.0), @as(f80, -0.0), true) == error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f80, -0.0), @as(f80, 0.0), true) != error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f80, 0.0), @as(f80, -0.0), true) != error.Unexpected) return error.Unexpected; - if (checkExpected(nan(f128), nan(f128)) == error.Unexpected) return error.Unexpected; - if (checkExpected(nan(f128), -nan(f128)) != error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f128, 0.0), @as(f128, 0.0)) == error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f128, -0.0), @as(f128, -0.0)) == error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f128, -0.0), @as(f128, 0.0)) != error.Unexpected) return error.Unexpected; - if (checkExpected(@as(f128, 0.0), @as(f128, -0.0)) != error.Unexpected) return error.Unexpected; + if (checkExpected(nan(f128), nan(f128), true) == error.Unexpected) return error.Unexpected; + if (checkExpected(nan(f128), -nan(f128), true) != error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f128, 0.0), @as(f128, 0.0), true) == error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f128, -0.0), @as(f128, -0.0), true) == error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f128, -0.0), @as(f128, 0.0), true) != error.Unexpected) return error.Unexpected; + if (checkExpected(@as(f128, 0.0), @as(f128, -0.0), true) != error.Unexpected) return error.Unexpected; } -fn Unary(comptime op: anytype) type { +fn unary(comptime op: anytype, comptime opts: struct { strict: bool = false }) type { return struct { // noinline so that `mem_arg` is on the stack noinline fn testArgKinds( @@ -151,9 +157,9 @@ fn Unary(comptime op: anytype) type { const expected = comptime op(Type, imm_arg); var reg_arg = mem_arg; _ = .{®_arg}; - try checkExpected(expected, op(Type, reg_arg)); - try checkExpected(expected, op(Type, mem_arg)); - try checkExpected(expected, op(Type, imm_arg)); + try checkExpected(expected, op(Type, reg_arg), opts.strict); + try checkExpected(expected, op(Type, mem_arg), opts.strict); + try checkExpected(expected, op(Type, imm_arg), opts.strict); } // noinline for a more helpful stack trace noinline fn testArgs(comptime Type: type, comptime imm_arg: Type) !void { @@ -1325,7 +1331,7 @@ fn Unary(comptime op: anytype) type { }; } -fn Binary(comptime op: anytype) type { +fn binary(comptime op: anytype, comptime opts: struct { strict: bool = false }) type { return struct { // noinline so that `mem_lhs` and `mem_rhs` are on the stack noinline fn testArgKinds( @@ -1355,14 +1361,14 @@ fn Binary(comptime op: anytype) type { var reg_lhs = mem_lhs; var reg_rhs = mem_rhs; _ = .{ ®_lhs, ®_rhs }; - try checkExpected(expected, op(Type, reg_lhs, reg_rhs)); - try checkExpected(expected, op(Type, reg_lhs, mem_rhs)); - try checkExpected(expected, op(Type, reg_lhs, imm_rhs)); - try checkExpected(expected, op(Type, mem_lhs, reg_rhs)); - try checkExpected(expected, op(Type, mem_lhs, mem_rhs)); - try checkExpected(expected, op(Type, mem_lhs, imm_rhs)); - try checkExpected(expected, op(Type, imm_lhs, reg_rhs)); - try checkExpected(expected, op(Type, imm_lhs, mem_rhs)); + try checkExpected(expected, op(Type, reg_lhs, reg_rhs), opts.strict); + try checkExpected(expected, op(Type, reg_lhs, mem_rhs), opts.strict); + try checkExpected(expected, op(Type, reg_lhs, imm_rhs), opts.strict); + try checkExpected(expected, op(Type, mem_lhs, reg_rhs), opts.strict); + try checkExpected(expected, op(Type, mem_lhs, mem_rhs), opts.strict); + try checkExpected(expected, op(Type, mem_lhs, imm_rhs), opts.strict); + try checkExpected(expected, op(Type, imm_lhs, reg_rhs), opts.strict); + try checkExpected(expected, op(Type, imm_lhs, mem_rhs), opts.strict); } // noinline for a more helpful stack trace noinline fn testArgs(comptime Type: type, comptime imm_lhs: Type, comptime imm_rhs: Type) !void { @@ -1442,6 +1448,1719 @@ fn Binary(comptime op: anytype) type { 0x8b4bb7c2969e3b121cc1082c442f8b4330f0a50058438fed56447175bb10178607ecfe425cb54dacc25ef26810f3e04681de1844f1aa8d029aca75d658634806, ); } + fn testFloatTypes() !void { + @setEvalBranchQuota(21_700); + + try testArgs(f16, -nan(f16), -nan(f16)); + try testArgs(f16, -nan(f16), -inf(f16)); + try testArgs(f16, -nan(f16), -fmax(f16)); + try testArgs(f16, -nan(f16), -10.0); + try testArgs(f16, -nan(f16), -1.0); + try testArgs(f16, -nan(f16), -0.1); + try testArgs(f16, -nan(f16), -fmin(f16)); + try testArgs(f16, -nan(f16), -tmin(f16)); + try testArgs(f16, -nan(f16), -0.0); + try testArgs(f16, -nan(f16), 0.0); + try testArgs(f16, -nan(f16), tmin(f16)); + try testArgs(f16, -nan(f16), fmin(f16)); + try testArgs(f16, -nan(f16), 0.1); + try testArgs(f16, -nan(f16), 1.0); + try testArgs(f16, -nan(f16), 10.0); + try testArgs(f16, -nan(f16), fmax(f16)); + try testArgs(f16, -nan(f16), inf(f16)); + try testArgs(f16, -nan(f16), nan(f16)); + + try testArgs(f16, -inf(f16), -nan(f16)); + try testArgs(f16, -inf(f16), -inf(f16)); + try testArgs(f16, -inf(f16), -fmax(f16)); + try testArgs(f16, -inf(f16), -10.0); + try testArgs(f16, -inf(f16), -1.0); + try testArgs(f16, -inf(f16), -0.1); + try testArgs(f16, -inf(f16), -fmin(f16)); + try testArgs(f16, -inf(f16), -tmin(f16)); + try testArgs(f16, -inf(f16), -0.0); + try testArgs(f16, -inf(f16), 0.0); + try testArgs(f16, -inf(f16), tmin(f16)); + try testArgs(f16, -inf(f16), fmin(f16)); + try testArgs(f16, -inf(f16), 0.1); + try testArgs(f16, -inf(f16), 1.0); + try testArgs(f16, -inf(f16), 10.0); + try testArgs(f16, -inf(f16), fmax(f16)); + try testArgs(f16, -inf(f16), inf(f16)); + try testArgs(f16, -inf(f16), nan(f16)); + + try testArgs(f16, -fmax(f16), -nan(f16)); + try testArgs(f16, -fmax(f16), -inf(f16)); + try testArgs(f16, -fmax(f16), -fmax(f16)); + try testArgs(f16, -fmax(f16), -10.0); + try testArgs(f16, -fmax(f16), -1.0); + try testArgs(f16, -fmax(f16), -0.1); + try testArgs(f16, -fmax(f16), -fmin(f16)); + try testArgs(f16, -fmax(f16), -tmin(f16)); + try testArgs(f16, -fmax(f16), -0.0); + try testArgs(f16, -fmax(f16), 0.0); + try testArgs(f16, -fmax(f16), tmin(f16)); + try testArgs(f16, -fmax(f16), fmin(f16)); + try testArgs(f16, -fmax(f16), 0.1); + try testArgs(f16, -fmax(f16), 1.0); + try testArgs(f16, -fmax(f16), 10.0); + try testArgs(f16, -fmax(f16), fmax(f16)); + try testArgs(f16, -fmax(f16), inf(f16)); + try testArgs(f16, -fmax(f16), nan(f16)); + + try testArgs(f16, -10.0, -nan(f16)); + try testArgs(f16, -10.0, -inf(f16)); + try testArgs(f16, -10.0, -fmax(f16)); + try testArgs(f16, -10.0, -10.0); + try testArgs(f16, -10.0, -1.0); + try testArgs(f16, -10.0, -0.1); + try testArgs(f16, -10.0, -fmin(f16)); + try testArgs(f16, -10.0, -tmin(f16)); + try testArgs(f16, -10.0, -0.0); + try testArgs(f16, -10.0, 0.0); + try testArgs(f16, -10.0, tmin(f16)); + try testArgs(f16, -10.0, fmin(f16)); + try testArgs(f16, -10.0, 0.1); + try testArgs(f16, -10.0, 1.0); + try testArgs(f16, -10.0, 10.0); + try testArgs(f16, -10.0, fmax(f16)); + try testArgs(f16, -10.0, inf(f16)); + try testArgs(f16, -10.0, nan(f16)); + + try testArgs(f16, -1.0, -nan(f16)); + try testArgs(f16, -1.0, -inf(f16)); + try testArgs(f16, -1.0, -fmax(f16)); + try testArgs(f16, -1.0, -10.0); + try testArgs(f16, -1.0, -1.0); + try testArgs(f16, -1.0, -0.1); + try testArgs(f16, -1.0, -fmin(f16)); + try testArgs(f16, -1.0, -tmin(f16)); + try testArgs(f16, -1.0, -0.0); + try testArgs(f16, -1.0, 0.0); + try testArgs(f16, -1.0, tmin(f16)); + try testArgs(f16, -1.0, fmin(f16)); + try testArgs(f16, -1.0, 0.1); + try testArgs(f16, -1.0, 1.0); + try testArgs(f16, -1.0, 10.0); + try testArgs(f16, -1.0, fmax(f16)); + try testArgs(f16, -1.0, inf(f16)); + try testArgs(f16, -1.0, nan(f16)); + + try testArgs(f16, -0.1, -nan(f16)); + try testArgs(f16, -0.1, -inf(f16)); + try testArgs(f16, -0.1, -fmax(f16)); + try testArgs(f16, -0.1, -10.0); + try testArgs(f16, -0.1, -1.0); + try testArgs(f16, -0.1, -0.1); + try testArgs(f16, -0.1, -fmin(f16)); + try testArgs(f16, -0.1, -tmin(f16)); + try testArgs(f16, -0.1, -0.0); + try testArgs(f16, -0.1, 0.0); + try testArgs(f16, -0.1, tmin(f16)); + try testArgs(f16, -0.1, fmin(f16)); + try testArgs(f16, -0.1, 0.1); + try testArgs(f16, -0.1, 1.0); + try testArgs(f16, -0.1, 10.0); + try testArgs(f16, -0.1, fmax(f16)); + try testArgs(f16, -0.1, inf(f16)); + try testArgs(f16, -0.1, nan(f16)); + + try testArgs(f16, -fmin(f16), -nan(f16)); + try testArgs(f16, -fmin(f16), -inf(f16)); + try testArgs(f16, -fmin(f16), -fmax(f16)); + try testArgs(f16, -fmin(f16), -10.0); + try testArgs(f16, -fmin(f16), -1.0); + try testArgs(f16, -fmin(f16), -0.1); + try testArgs(f16, -fmin(f16), -fmin(f16)); + try testArgs(f16, -fmin(f16), -tmin(f16)); + try testArgs(f16, -fmin(f16), -0.0); + try testArgs(f16, -fmin(f16), 0.0); + try testArgs(f16, -fmin(f16), tmin(f16)); + try testArgs(f16, -fmin(f16), fmin(f16)); + try testArgs(f16, -fmin(f16), 0.1); + try testArgs(f16, -fmin(f16), 1.0); + try testArgs(f16, -fmin(f16), 10.0); + try testArgs(f16, -fmin(f16), fmax(f16)); + try testArgs(f16, -fmin(f16), inf(f16)); + try testArgs(f16, -fmin(f16), nan(f16)); + + try testArgs(f16, -tmin(f16), -nan(f16)); + try testArgs(f16, -tmin(f16), -inf(f16)); + try testArgs(f16, -tmin(f16), -fmax(f16)); + try testArgs(f16, -tmin(f16), -10.0); + try testArgs(f16, -tmin(f16), -1.0); + try testArgs(f16, -tmin(f16), -0.1); + try testArgs(f16, -tmin(f16), -fmin(f16)); + try testArgs(f16, -tmin(f16), -tmin(f16)); + try testArgs(f16, -tmin(f16), -0.0); + try testArgs(f16, -tmin(f16), 0.0); + try testArgs(f16, -tmin(f16), tmin(f16)); + try testArgs(f16, -tmin(f16), fmin(f16)); + try testArgs(f16, -tmin(f16), 0.1); + try testArgs(f16, -tmin(f16), 1.0); + try testArgs(f16, -tmin(f16), 10.0); + try testArgs(f16, -tmin(f16), fmax(f16)); + try testArgs(f16, -tmin(f16), inf(f16)); + try testArgs(f16, -tmin(f16), nan(f16)); + + try testArgs(f16, -0.0, -nan(f16)); + try testArgs(f16, -0.0, -inf(f16)); + try testArgs(f16, -0.0, -fmax(f16)); + try testArgs(f16, -0.0, -10.0); + try testArgs(f16, -0.0, -1.0); + try testArgs(f16, -0.0, -0.1); + try testArgs(f16, -0.0, -fmin(f16)); + try testArgs(f16, -0.0, -tmin(f16)); + try testArgs(f16, -0.0, -0.0); + try testArgs(f16, -0.0, 0.0); + try testArgs(f16, -0.0, tmin(f16)); + try testArgs(f16, -0.0, fmin(f16)); + try testArgs(f16, -0.0, 0.1); + try testArgs(f16, -0.0, 1.0); + try testArgs(f16, -0.0, 10.0); + try testArgs(f16, -0.0, fmax(f16)); + try testArgs(f16, -0.0, inf(f16)); + try testArgs(f16, -0.0, nan(f16)); + + try testArgs(f16, 0.0, -nan(f16)); + try testArgs(f16, 0.0, -inf(f16)); + try testArgs(f16, 0.0, -fmax(f16)); + try testArgs(f16, 0.0, -10.0); + try testArgs(f16, 0.0, -1.0); + try testArgs(f16, 0.0, -0.1); + try testArgs(f16, 0.0, -fmin(f16)); + try testArgs(f16, 0.0, -tmin(f16)); + try testArgs(f16, 0.0, -0.0); + try testArgs(f16, 0.0, 0.0); + try testArgs(f16, 0.0, tmin(f16)); + try testArgs(f16, 0.0, fmin(f16)); + try testArgs(f16, 0.0, 0.1); + try testArgs(f16, 0.0, 1.0); + try testArgs(f16, 0.0, 10.0); + try testArgs(f16, 0.0, fmax(f16)); + try testArgs(f16, 0.0, inf(f16)); + try testArgs(f16, 0.0, nan(f16)); + + try testArgs(f16, tmin(f16), -nan(f16)); + try testArgs(f16, tmin(f16), -inf(f16)); + try testArgs(f16, tmin(f16), -fmax(f16)); + try testArgs(f16, tmin(f16), -10.0); + try testArgs(f16, tmin(f16), -1.0); + try testArgs(f16, tmin(f16), -0.1); + try testArgs(f16, tmin(f16), -fmin(f16)); + try testArgs(f16, tmin(f16), -tmin(f16)); + try testArgs(f16, tmin(f16), -0.0); + try testArgs(f16, tmin(f16), 0.0); + try testArgs(f16, tmin(f16), tmin(f16)); + try testArgs(f16, tmin(f16), fmin(f16)); + try testArgs(f16, tmin(f16), 0.1); + try testArgs(f16, tmin(f16), 1.0); + try testArgs(f16, tmin(f16), 10.0); + try testArgs(f16, tmin(f16), fmax(f16)); + try testArgs(f16, tmin(f16), inf(f16)); + try testArgs(f16, tmin(f16), nan(f16)); + + try testArgs(f16, fmin(f16), -nan(f16)); + try testArgs(f16, fmin(f16), -inf(f16)); + try testArgs(f16, fmin(f16), -fmax(f16)); + try testArgs(f16, fmin(f16), -10.0); + try testArgs(f16, fmin(f16), -1.0); + try testArgs(f16, fmin(f16), -0.1); + try testArgs(f16, fmin(f16), -fmin(f16)); + try testArgs(f16, fmin(f16), -tmin(f16)); + try testArgs(f16, fmin(f16), -0.0); + try testArgs(f16, fmin(f16), 0.0); + try testArgs(f16, fmin(f16), tmin(f16)); + try testArgs(f16, fmin(f16), fmin(f16)); + try testArgs(f16, fmin(f16), 0.1); + try testArgs(f16, fmin(f16), 1.0); + try testArgs(f16, fmin(f16), 10.0); + try testArgs(f16, fmin(f16), fmax(f16)); + try testArgs(f16, fmin(f16), inf(f16)); + try testArgs(f16, fmin(f16), nan(f16)); + + try testArgs(f16, 0.1, -nan(f16)); + try testArgs(f16, 0.1, -inf(f16)); + try testArgs(f16, 0.1, -fmax(f16)); + try testArgs(f16, 0.1, -10.0); + try testArgs(f16, 0.1, -1.0); + try testArgs(f16, 0.1, -0.1); + try testArgs(f16, 0.1, -fmin(f16)); + try testArgs(f16, 0.1, -tmin(f16)); + try testArgs(f16, 0.1, -0.0); + try testArgs(f16, 0.1, 0.0); + try testArgs(f16, 0.1, tmin(f16)); + try testArgs(f16, 0.1, fmin(f16)); + try testArgs(f16, 0.1, 0.1); + try testArgs(f16, 0.1, 1.0); + try testArgs(f16, 0.1, 10.0); + try testArgs(f16, 0.1, fmax(f16)); + try testArgs(f16, 0.1, inf(f16)); + try testArgs(f16, 0.1, nan(f16)); + + try testArgs(f16, 1.0, -nan(f16)); + try testArgs(f16, 1.0, -inf(f16)); + try testArgs(f16, 1.0, -fmax(f16)); + try testArgs(f16, 1.0, -10.0); + try testArgs(f16, 1.0, -1.0); + try testArgs(f16, 1.0, -0.1); + try testArgs(f16, 1.0, -fmin(f16)); + try testArgs(f16, 1.0, -tmin(f16)); + try testArgs(f16, 1.0, -0.0); + try testArgs(f16, 1.0, 0.0); + try testArgs(f16, 1.0, tmin(f16)); + try testArgs(f16, 1.0, fmin(f16)); + try testArgs(f16, 1.0, 0.1); + try testArgs(f16, 1.0, 1.0); + try testArgs(f16, 1.0, 10.0); + try testArgs(f16, 1.0, fmax(f16)); + try testArgs(f16, 1.0, inf(f16)); + try testArgs(f16, 1.0, nan(f16)); + + try testArgs(f16, 10.0, -nan(f16)); + try testArgs(f16, 10.0, -inf(f16)); + try testArgs(f16, 10.0, -fmax(f16)); + try testArgs(f16, 10.0, -10.0); + try testArgs(f16, 10.0, -1.0); + try testArgs(f16, 10.0, -0.1); + try testArgs(f16, 10.0, -fmin(f16)); + try testArgs(f16, 10.0, -tmin(f16)); + try testArgs(f16, 10.0, -0.0); + try testArgs(f16, 10.0, 0.0); + try testArgs(f16, 10.0, tmin(f16)); + try testArgs(f16, 10.0, fmin(f16)); + try testArgs(f16, 10.0, 0.1); + try testArgs(f16, 10.0, 1.0); + try testArgs(f16, 10.0, 10.0); + try testArgs(f16, 10.0, fmax(f16)); + try testArgs(f16, 10.0, inf(f16)); + try testArgs(f16, 10.0, nan(f16)); + + try testArgs(f16, fmax(f16), -nan(f16)); + try testArgs(f16, fmax(f16), -inf(f16)); + try testArgs(f16, fmax(f16), -fmax(f16)); + try testArgs(f16, fmax(f16), -10.0); + try testArgs(f16, fmax(f16), -1.0); + try testArgs(f16, fmax(f16), -0.1); + try testArgs(f16, fmax(f16), -fmin(f16)); + try testArgs(f16, fmax(f16), -tmin(f16)); + try testArgs(f16, fmax(f16), -0.0); + try testArgs(f16, fmax(f16), 0.0); + try testArgs(f16, fmax(f16), tmin(f16)); + try testArgs(f16, fmax(f16), fmin(f16)); + try testArgs(f16, fmax(f16), 0.1); + try testArgs(f16, fmax(f16), 1.0); + try testArgs(f16, fmax(f16), 10.0); + try testArgs(f16, fmax(f16), fmax(f16)); + try testArgs(f16, fmax(f16), inf(f16)); + try testArgs(f16, fmax(f16), nan(f16)); + + try testArgs(f16, inf(f16), -nan(f16)); + try testArgs(f16, inf(f16), -inf(f16)); + try testArgs(f16, inf(f16), -fmax(f16)); + try testArgs(f16, inf(f16), -10.0); + try testArgs(f16, inf(f16), -1.0); + try testArgs(f16, inf(f16), -0.1); + try testArgs(f16, inf(f16), -fmin(f16)); + try testArgs(f16, inf(f16), -tmin(f16)); + try testArgs(f16, inf(f16), -0.0); + try testArgs(f16, inf(f16), 0.0); + try testArgs(f16, inf(f16), tmin(f16)); + try testArgs(f16, inf(f16), fmin(f16)); + try testArgs(f16, inf(f16), 0.1); + try testArgs(f16, inf(f16), 1.0); + try testArgs(f16, inf(f16), 10.0); + try testArgs(f16, inf(f16), fmax(f16)); + try testArgs(f16, inf(f16), inf(f16)); + try testArgs(f16, inf(f16), nan(f16)); + + try testArgs(f16, nan(f16), -nan(f16)); + try testArgs(f16, nan(f16), -inf(f16)); + try testArgs(f16, nan(f16), -fmax(f16)); + try testArgs(f16, nan(f16), -10.0); + try testArgs(f16, nan(f16), -1.0); + try testArgs(f16, nan(f16), -0.1); + try testArgs(f16, nan(f16), -fmin(f16)); + try testArgs(f16, nan(f16), -tmin(f16)); + try testArgs(f16, nan(f16), -0.0); + try testArgs(f16, nan(f16), 0.0); + try testArgs(f16, nan(f16), tmin(f16)); + try testArgs(f16, nan(f16), fmin(f16)); + try testArgs(f16, nan(f16), 0.1); + try testArgs(f16, nan(f16), 1.0); + try testArgs(f16, nan(f16), 10.0); + try testArgs(f16, nan(f16), fmax(f16)); + try testArgs(f16, nan(f16), inf(f16)); + try testArgs(f16, nan(f16), nan(f16)); + + try testArgs(f32, -nan(f32), -nan(f32)); + try testArgs(f32, -nan(f32), -inf(f32)); + try testArgs(f32, -nan(f32), -fmax(f32)); + try testArgs(f32, -nan(f32), -10.0); + try testArgs(f32, -nan(f32), -1.0); + try testArgs(f32, -nan(f32), -0.1); + try testArgs(f32, -nan(f32), -fmin(f32)); + try testArgs(f32, -nan(f32), -tmin(f32)); + try testArgs(f32, -nan(f32), -0.0); + try testArgs(f32, -nan(f32), 0.0); + try testArgs(f32, -nan(f32), tmin(f32)); + try testArgs(f32, -nan(f32), fmin(f32)); + try testArgs(f32, -nan(f32), 0.1); + try testArgs(f32, -nan(f32), 1.0); + try testArgs(f32, -nan(f32), 10.0); + try testArgs(f32, -nan(f32), fmax(f32)); + try testArgs(f32, -nan(f32), inf(f32)); + try testArgs(f32, -nan(f32), nan(f32)); + + try testArgs(f32, -inf(f32), -nan(f32)); + try testArgs(f32, -inf(f32), -inf(f32)); + try testArgs(f32, -inf(f32), -fmax(f32)); + try testArgs(f32, -inf(f32), -10.0); + try testArgs(f32, -inf(f32), -1.0); + try testArgs(f32, -inf(f32), -0.1); + try testArgs(f32, -inf(f32), -fmin(f32)); + try testArgs(f32, -inf(f32), -tmin(f32)); + try testArgs(f32, -inf(f32), -0.0); + try testArgs(f32, -inf(f32), 0.0); + try testArgs(f32, -inf(f32), tmin(f32)); + try testArgs(f32, -inf(f32), fmin(f32)); + try testArgs(f32, -inf(f32), 0.1); + try testArgs(f32, -inf(f32), 1.0); + try testArgs(f32, -inf(f32), 10.0); + try testArgs(f32, -inf(f32), fmax(f32)); + try testArgs(f32, -inf(f32), inf(f32)); + try testArgs(f32, -inf(f32), nan(f32)); + + try testArgs(f32, -fmax(f32), -nan(f32)); + try testArgs(f32, -fmax(f32), -inf(f32)); + try testArgs(f32, -fmax(f32), -fmax(f32)); + try testArgs(f32, -fmax(f32), -10.0); + try testArgs(f32, -fmax(f32), -1.0); + try testArgs(f32, -fmax(f32), -0.1); + try testArgs(f32, -fmax(f32), -fmin(f32)); + try testArgs(f32, -fmax(f32), -tmin(f32)); + try testArgs(f32, -fmax(f32), -0.0); + try testArgs(f32, -fmax(f32), 0.0); + try testArgs(f32, -fmax(f32), tmin(f32)); + try testArgs(f32, -fmax(f32), fmin(f32)); + try testArgs(f32, -fmax(f32), 0.1); + try testArgs(f32, -fmax(f32), 1.0); + try testArgs(f32, -fmax(f32), 10.0); + try testArgs(f32, -fmax(f32), fmax(f32)); + try testArgs(f32, -fmax(f32), inf(f32)); + try testArgs(f32, -fmax(f32), nan(f32)); + + try testArgs(f32, -10.0, -nan(f32)); + try testArgs(f32, -10.0, -inf(f32)); + try testArgs(f32, -10.0, -fmax(f32)); + try testArgs(f32, -10.0, -10.0); + try testArgs(f32, -10.0, -1.0); + try testArgs(f32, -10.0, -0.1); + try testArgs(f32, -10.0, -fmin(f32)); + try testArgs(f32, -10.0, -tmin(f32)); + try testArgs(f32, -10.0, -0.0); + try testArgs(f32, -10.0, 0.0); + try testArgs(f32, -10.0, tmin(f32)); + try testArgs(f32, -10.0, fmin(f32)); + try testArgs(f32, -10.0, 0.1); + try testArgs(f32, -10.0, 1.0); + try testArgs(f32, -10.0, 10.0); + try testArgs(f32, -10.0, fmax(f32)); + try testArgs(f32, -10.0, inf(f32)); + try testArgs(f32, -10.0, nan(f32)); + + try testArgs(f32, -1.0, -nan(f32)); + try testArgs(f32, -1.0, -inf(f32)); + try testArgs(f32, -1.0, -fmax(f32)); + try testArgs(f32, -1.0, -10.0); + try testArgs(f32, -1.0, -1.0); + try testArgs(f32, -1.0, -0.1); + try testArgs(f32, -1.0, -fmin(f32)); + try testArgs(f32, -1.0, -tmin(f32)); + try testArgs(f32, -1.0, -0.0); + try testArgs(f32, -1.0, 0.0); + try testArgs(f32, -1.0, tmin(f32)); + try testArgs(f32, -1.0, fmin(f32)); + try testArgs(f32, -1.0, 0.1); + try testArgs(f32, -1.0, 1.0); + try testArgs(f32, -1.0, 10.0); + try testArgs(f32, -1.0, fmax(f32)); + try testArgs(f32, -1.0, inf(f32)); + try testArgs(f32, -1.0, nan(f32)); + + try testArgs(f32, -0.1, -nan(f32)); + try testArgs(f32, -0.1, -inf(f32)); + try testArgs(f32, -0.1, -fmax(f32)); + try testArgs(f32, -0.1, -10.0); + try testArgs(f32, -0.1, -1.0); + try testArgs(f32, -0.1, -0.1); + try testArgs(f32, -0.1, -fmin(f32)); + try testArgs(f32, -0.1, -tmin(f32)); + try testArgs(f32, -0.1, -0.0); + try testArgs(f32, -0.1, 0.0); + try testArgs(f32, -0.1, tmin(f32)); + try testArgs(f32, -0.1, fmin(f32)); + try testArgs(f32, -0.1, 0.1); + try testArgs(f32, -0.1, 1.0); + try testArgs(f32, -0.1, 10.0); + try testArgs(f32, -0.1, fmax(f32)); + try testArgs(f32, -0.1, inf(f32)); + try testArgs(f32, -0.1, nan(f32)); + + try testArgs(f32, -fmin(f32), -nan(f32)); + try testArgs(f32, -fmin(f32), -inf(f32)); + try testArgs(f32, -fmin(f32), -fmax(f32)); + try testArgs(f32, -fmin(f32), -10.0); + try testArgs(f32, -fmin(f32), -1.0); + try testArgs(f32, -fmin(f32), -0.1); + try testArgs(f32, -fmin(f32), -fmin(f32)); + try testArgs(f32, -fmin(f32), -tmin(f32)); + try testArgs(f32, -fmin(f32), -0.0); + try testArgs(f32, -fmin(f32), 0.0); + try testArgs(f32, -fmin(f32), tmin(f32)); + try testArgs(f32, -fmin(f32), fmin(f32)); + try testArgs(f32, -fmin(f32), 0.1); + try testArgs(f32, -fmin(f32), 1.0); + try testArgs(f32, -fmin(f32), 10.0); + try testArgs(f32, -fmin(f32), fmax(f32)); + try testArgs(f32, -fmin(f32), inf(f32)); + try testArgs(f32, -fmin(f32), nan(f32)); + + try testArgs(f32, -tmin(f32), -nan(f32)); + try testArgs(f32, -tmin(f32), -inf(f32)); + try testArgs(f32, -tmin(f32), -fmax(f32)); + try testArgs(f32, -tmin(f32), -10.0); + try testArgs(f32, -tmin(f32), -1.0); + try testArgs(f32, -tmin(f32), -0.1); + try testArgs(f32, -tmin(f32), -fmin(f32)); + try testArgs(f32, -tmin(f32), -tmin(f32)); + try testArgs(f32, -tmin(f32), -0.0); + try testArgs(f32, -tmin(f32), 0.0); + try testArgs(f32, -tmin(f32), tmin(f32)); + try testArgs(f32, -tmin(f32), fmin(f32)); + try testArgs(f32, -tmin(f32), 0.1); + try testArgs(f32, -tmin(f32), 1.0); + try testArgs(f32, -tmin(f32), 10.0); + try testArgs(f32, -tmin(f32), fmax(f32)); + try testArgs(f32, -tmin(f32), inf(f32)); + try testArgs(f32, -tmin(f32), nan(f32)); + + try testArgs(f32, -0.0, -nan(f32)); + try testArgs(f32, -0.0, -inf(f32)); + try testArgs(f32, -0.0, -fmax(f32)); + try testArgs(f32, -0.0, -10.0); + try testArgs(f32, -0.0, -1.0); + try testArgs(f32, -0.0, -0.1); + try testArgs(f32, -0.0, -fmin(f32)); + try testArgs(f32, -0.0, -tmin(f32)); + try testArgs(f32, -0.0, -0.0); + try testArgs(f32, -0.0, 0.0); + try testArgs(f32, -0.0, tmin(f32)); + try testArgs(f32, -0.0, fmin(f32)); + try testArgs(f32, -0.0, 0.1); + try testArgs(f32, -0.0, 1.0); + try testArgs(f32, -0.0, 10.0); + try testArgs(f32, -0.0, fmax(f32)); + try testArgs(f32, -0.0, inf(f32)); + try testArgs(f32, -0.0, nan(f32)); + + try testArgs(f32, 0.0, -nan(f32)); + try testArgs(f32, 0.0, -inf(f32)); + try testArgs(f32, 0.0, -fmax(f32)); + try testArgs(f32, 0.0, -10.0); + try testArgs(f32, 0.0, -1.0); + try testArgs(f32, 0.0, -0.1); + try testArgs(f32, 0.0, -fmin(f32)); + try testArgs(f32, 0.0, -tmin(f32)); + try testArgs(f32, 0.0, -0.0); + try testArgs(f32, 0.0, 0.0); + try testArgs(f32, 0.0, tmin(f32)); + try testArgs(f32, 0.0, fmin(f32)); + try testArgs(f32, 0.0, 0.1); + try testArgs(f32, 0.0, 1.0); + try testArgs(f32, 0.0, 10.0); + try testArgs(f32, 0.0, fmax(f32)); + try testArgs(f32, 0.0, inf(f32)); + try testArgs(f32, 0.0, nan(f32)); + + try testArgs(f32, tmin(f32), -nan(f32)); + try testArgs(f32, tmin(f32), -inf(f32)); + try testArgs(f32, tmin(f32), -fmax(f32)); + try testArgs(f32, tmin(f32), -10.0); + try testArgs(f32, tmin(f32), -1.0); + try testArgs(f32, tmin(f32), -0.1); + try testArgs(f32, tmin(f32), -fmin(f32)); + try testArgs(f32, tmin(f32), -tmin(f32)); + try testArgs(f32, tmin(f32), -0.0); + try testArgs(f32, tmin(f32), 0.0); + try testArgs(f32, tmin(f32), tmin(f32)); + try testArgs(f32, tmin(f32), fmin(f32)); + try testArgs(f32, tmin(f32), 0.1); + try testArgs(f32, tmin(f32), 1.0); + try testArgs(f32, tmin(f32), 10.0); + try testArgs(f32, tmin(f32), fmax(f32)); + try testArgs(f32, tmin(f32), inf(f32)); + try testArgs(f32, tmin(f32), nan(f32)); + + try testArgs(f32, fmin(f32), -nan(f32)); + try testArgs(f32, fmin(f32), -inf(f32)); + try testArgs(f32, fmin(f32), -fmax(f32)); + try testArgs(f32, fmin(f32), -10.0); + try testArgs(f32, fmin(f32), -1.0); + try testArgs(f32, fmin(f32), -0.1); + try testArgs(f32, fmin(f32), -fmin(f32)); + try testArgs(f32, fmin(f32), -tmin(f32)); + try testArgs(f32, fmin(f32), -0.0); + try testArgs(f32, fmin(f32), 0.0); + try testArgs(f32, fmin(f32), tmin(f32)); + try testArgs(f32, fmin(f32), fmin(f32)); + try testArgs(f32, fmin(f32), 0.1); + try testArgs(f32, fmin(f32), 1.0); + try testArgs(f32, fmin(f32), 10.0); + try testArgs(f32, fmin(f32), fmax(f32)); + try testArgs(f32, fmin(f32), inf(f32)); + try testArgs(f32, fmin(f32), nan(f32)); + + try testArgs(f32, 0.1, -nan(f32)); + try testArgs(f32, 0.1, -inf(f32)); + try testArgs(f32, 0.1, -fmax(f32)); + try testArgs(f32, 0.1, -10.0); + try testArgs(f32, 0.1, -1.0); + try testArgs(f32, 0.1, -0.1); + try testArgs(f32, 0.1, -fmin(f32)); + try testArgs(f32, 0.1, -tmin(f32)); + try testArgs(f32, 0.1, -0.0); + try testArgs(f32, 0.1, 0.0); + try testArgs(f32, 0.1, tmin(f32)); + try testArgs(f32, 0.1, fmin(f32)); + try testArgs(f32, 0.1, 0.1); + try testArgs(f32, 0.1, 1.0); + try testArgs(f32, 0.1, 10.0); + try testArgs(f32, 0.1, fmax(f32)); + try testArgs(f32, 0.1, inf(f32)); + try testArgs(f32, 0.1, nan(f32)); + + try testArgs(f32, 1.0, -nan(f32)); + try testArgs(f32, 1.0, -inf(f32)); + try testArgs(f32, 1.0, -fmax(f32)); + try testArgs(f32, 1.0, -10.0); + try testArgs(f32, 1.0, -1.0); + try testArgs(f32, 1.0, -0.1); + try testArgs(f32, 1.0, -fmin(f32)); + try testArgs(f32, 1.0, -tmin(f32)); + try testArgs(f32, 1.0, -0.0); + try testArgs(f32, 1.0, 0.0); + try testArgs(f32, 1.0, tmin(f32)); + try testArgs(f32, 1.0, fmin(f32)); + try testArgs(f32, 1.0, 0.1); + try testArgs(f32, 1.0, 1.0); + try testArgs(f32, 1.0, 10.0); + try testArgs(f32, 1.0, fmax(f32)); + try testArgs(f32, 1.0, inf(f32)); + try testArgs(f32, 1.0, nan(f32)); + + try testArgs(f32, 10.0, -nan(f32)); + try testArgs(f32, 10.0, -inf(f32)); + try testArgs(f32, 10.0, -fmax(f32)); + try testArgs(f32, 10.0, -10.0); + try testArgs(f32, 10.0, -1.0); + try testArgs(f32, 10.0, -0.1); + try testArgs(f32, 10.0, -fmin(f32)); + try testArgs(f32, 10.0, -tmin(f32)); + try testArgs(f32, 10.0, -0.0); + try testArgs(f32, 10.0, 0.0); + try testArgs(f32, 10.0, tmin(f32)); + try testArgs(f32, 10.0, fmin(f32)); + try testArgs(f32, 10.0, 0.1); + try testArgs(f32, 10.0, 1.0); + try testArgs(f32, 10.0, 10.0); + try testArgs(f32, 10.0, fmax(f32)); + try testArgs(f32, 10.0, inf(f32)); + try testArgs(f32, 10.0, nan(f32)); + + try testArgs(f32, fmax(f32), -nan(f32)); + try testArgs(f32, fmax(f32), -inf(f32)); + try testArgs(f32, fmax(f32), -fmax(f32)); + try testArgs(f32, fmax(f32), -10.0); + try testArgs(f32, fmax(f32), -1.0); + try testArgs(f32, fmax(f32), -0.1); + try testArgs(f32, fmax(f32), -fmin(f32)); + try testArgs(f32, fmax(f32), -tmin(f32)); + try testArgs(f32, fmax(f32), -0.0); + try testArgs(f32, fmax(f32), 0.0); + try testArgs(f32, fmax(f32), tmin(f32)); + try testArgs(f32, fmax(f32), fmin(f32)); + try testArgs(f32, fmax(f32), 0.1); + try testArgs(f32, fmax(f32), 1.0); + try testArgs(f32, fmax(f32), 10.0); + try testArgs(f32, fmax(f32), fmax(f32)); + try testArgs(f32, fmax(f32), inf(f32)); + try testArgs(f32, fmax(f32), nan(f32)); + + try testArgs(f32, inf(f32), -nan(f32)); + try testArgs(f32, inf(f32), -inf(f32)); + try testArgs(f32, inf(f32), -fmax(f32)); + try testArgs(f32, inf(f32), -10.0); + try testArgs(f32, inf(f32), -1.0); + try testArgs(f32, inf(f32), -0.1); + try testArgs(f32, inf(f32), -fmin(f32)); + try testArgs(f32, inf(f32), -tmin(f32)); + try testArgs(f32, inf(f32), -0.0); + try testArgs(f32, inf(f32), 0.0); + try testArgs(f32, inf(f32), tmin(f32)); + try testArgs(f32, inf(f32), fmin(f32)); + try testArgs(f32, inf(f32), 0.1); + try testArgs(f32, inf(f32), 1.0); + try testArgs(f32, inf(f32), 10.0); + try testArgs(f32, inf(f32), fmax(f32)); + try testArgs(f32, inf(f32), inf(f32)); + try testArgs(f32, inf(f32), nan(f32)); + + try testArgs(f32, nan(f32), -nan(f32)); + try testArgs(f32, nan(f32), -inf(f32)); + try testArgs(f32, nan(f32), -fmax(f32)); + try testArgs(f32, nan(f32), -10.0); + try testArgs(f32, nan(f32), -1.0); + try testArgs(f32, nan(f32), -0.1); + try testArgs(f32, nan(f32), -fmin(f32)); + try testArgs(f32, nan(f32), -tmin(f32)); + try testArgs(f32, nan(f32), -0.0); + try testArgs(f32, nan(f32), 0.0); + try testArgs(f32, nan(f32), tmin(f32)); + try testArgs(f32, nan(f32), fmin(f32)); + try testArgs(f32, nan(f32), 0.1); + try testArgs(f32, nan(f32), 1.0); + try testArgs(f32, nan(f32), 10.0); + try testArgs(f32, nan(f32), fmax(f32)); + try testArgs(f32, nan(f32), inf(f32)); + try testArgs(f32, nan(f32), nan(f32)); + + try testArgs(f64, -nan(f64), -nan(f64)); + try testArgs(f64, -nan(f64), -inf(f64)); + try testArgs(f64, -nan(f64), -fmax(f64)); + try testArgs(f64, -nan(f64), -10.0); + try testArgs(f64, -nan(f64), -1.0); + try testArgs(f64, -nan(f64), -0.1); + try testArgs(f64, -nan(f64), -fmin(f64)); + try testArgs(f64, -nan(f64), -tmin(f64)); + try testArgs(f64, -nan(f64), -0.0); + try testArgs(f64, -nan(f64), 0.0); + try testArgs(f64, -nan(f64), tmin(f64)); + try testArgs(f64, -nan(f64), fmin(f64)); + try testArgs(f64, -nan(f64), 0.1); + try testArgs(f64, -nan(f64), 1.0); + try testArgs(f64, -nan(f64), 10.0); + try testArgs(f64, -nan(f64), fmax(f64)); + try testArgs(f64, -nan(f64), inf(f64)); + try testArgs(f64, -nan(f64), nan(f64)); + + try testArgs(f64, -inf(f64), -nan(f64)); + try testArgs(f64, -inf(f64), -inf(f64)); + try testArgs(f64, -inf(f64), -fmax(f64)); + try testArgs(f64, -inf(f64), -10.0); + try testArgs(f64, -inf(f64), -1.0); + try testArgs(f64, -inf(f64), -0.1); + try testArgs(f64, -inf(f64), -fmin(f64)); + try testArgs(f64, -inf(f64), -tmin(f64)); + try testArgs(f64, -inf(f64), -0.0); + try testArgs(f64, -inf(f64), 0.0); + try testArgs(f64, -inf(f64), tmin(f64)); + try testArgs(f64, -inf(f64), fmin(f64)); + try testArgs(f64, -inf(f64), 0.1); + try testArgs(f64, -inf(f64), 1.0); + try testArgs(f64, -inf(f64), 10.0); + try testArgs(f64, -inf(f64), fmax(f64)); + try testArgs(f64, -inf(f64), inf(f64)); + try testArgs(f64, -inf(f64), nan(f64)); + + try testArgs(f64, -fmax(f64), -nan(f64)); + try testArgs(f64, -fmax(f64), -inf(f64)); + try testArgs(f64, -fmax(f64), -fmax(f64)); + try testArgs(f64, -fmax(f64), -10.0); + try testArgs(f64, -fmax(f64), -1.0); + try testArgs(f64, -fmax(f64), -0.1); + try testArgs(f64, -fmax(f64), -fmin(f64)); + try testArgs(f64, -fmax(f64), -tmin(f64)); + try testArgs(f64, -fmax(f64), -0.0); + try testArgs(f64, -fmax(f64), 0.0); + try testArgs(f64, -fmax(f64), tmin(f64)); + try testArgs(f64, -fmax(f64), fmin(f64)); + try testArgs(f64, -fmax(f64), 0.1); + try testArgs(f64, -fmax(f64), 1.0); + try testArgs(f64, -fmax(f64), 10.0); + try testArgs(f64, -fmax(f64), fmax(f64)); + try testArgs(f64, -fmax(f64), inf(f64)); + try testArgs(f64, -fmax(f64), nan(f64)); + + try testArgs(f64, -10.0, -nan(f64)); + try testArgs(f64, -10.0, -inf(f64)); + try testArgs(f64, -10.0, -fmax(f64)); + try testArgs(f64, -10.0, -10.0); + try testArgs(f64, -10.0, -1.0); + try testArgs(f64, -10.0, -0.1); + try testArgs(f64, -10.0, -fmin(f64)); + try testArgs(f64, -10.0, -tmin(f64)); + try testArgs(f64, -10.0, -0.0); + try testArgs(f64, -10.0, 0.0); + try testArgs(f64, -10.0, tmin(f64)); + try testArgs(f64, -10.0, fmin(f64)); + try testArgs(f64, -10.0, 0.1); + try testArgs(f64, -10.0, 1.0); + try testArgs(f64, -10.0, 10.0); + try testArgs(f64, -10.0, fmax(f64)); + try testArgs(f64, -10.0, inf(f64)); + try testArgs(f64, -10.0, nan(f64)); + + try testArgs(f64, -1.0, -nan(f64)); + try testArgs(f64, -1.0, -inf(f64)); + try testArgs(f64, -1.0, -fmax(f64)); + try testArgs(f64, -1.0, -10.0); + try testArgs(f64, -1.0, -1.0); + try testArgs(f64, -1.0, -0.1); + try testArgs(f64, -1.0, -fmin(f64)); + try testArgs(f64, -1.0, -tmin(f64)); + try testArgs(f64, -1.0, -0.0); + try testArgs(f64, -1.0, 0.0); + try testArgs(f64, -1.0, tmin(f64)); + try testArgs(f64, -1.0, fmin(f64)); + try testArgs(f64, -1.0, 0.1); + try testArgs(f64, -1.0, 1.0); + try testArgs(f64, -1.0, 10.0); + try testArgs(f64, -1.0, fmax(f64)); + try testArgs(f64, -1.0, inf(f64)); + try testArgs(f64, -1.0, nan(f64)); + + try testArgs(f64, -0.1, -nan(f64)); + try testArgs(f64, -0.1, -inf(f64)); + try testArgs(f64, -0.1, -fmax(f64)); + try testArgs(f64, -0.1, -10.0); + try testArgs(f64, -0.1, -1.0); + try testArgs(f64, -0.1, -0.1); + try testArgs(f64, -0.1, -fmin(f64)); + try testArgs(f64, -0.1, -tmin(f64)); + try testArgs(f64, -0.1, -0.0); + try testArgs(f64, -0.1, 0.0); + try testArgs(f64, -0.1, tmin(f64)); + try testArgs(f64, -0.1, fmin(f64)); + try testArgs(f64, -0.1, 0.1); + try testArgs(f64, -0.1, 1.0); + try testArgs(f64, -0.1, 10.0); + try testArgs(f64, -0.1, fmax(f64)); + try testArgs(f64, -0.1, inf(f64)); + try testArgs(f64, -0.1, nan(f64)); + + try testArgs(f64, -fmin(f64), -nan(f64)); + try testArgs(f64, -fmin(f64), -inf(f64)); + try testArgs(f64, -fmin(f64), -fmax(f64)); + try testArgs(f64, -fmin(f64), -10.0); + try testArgs(f64, -fmin(f64), -1.0); + try testArgs(f64, -fmin(f64), -0.1); + try testArgs(f64, -fmin(f64), -fmin(f64)); + try testArgs(f64, -fmin(f64), -tmin(f64)); + try testArgs(f64, -fmin(f64), -0.0); + try testArgs(f64, -fmin(f64), 0.0); + try testArgs(f64, -fmin(f64), tmin(f64)); + try testArgs(f64, -fmin(f64), fmin(f64)); + try testArgs(f64, -fmin(f64), 0.1); + try testArgs(f64, -fmin(f64), 1.0); + try testArgs(f64, -fmin(f64), 10.0); + try testArgs(f64, -fmin(f64), fmax(f64)); + try testArgs(f64, -fmin(f64), inf(f64)); + try testArgs(f64, -fmin(f64), nan(f64)); + + try testArgs(f64, -tmin(f64), -nan(f64)); + try testArgs(f64, -tmin(f64), -inf(f64)); + try testArgs(f64, -tmin(f64), -fmax(f64)); + try testArgs(f64, -tmin(f64), -10.0); + try testArgs(f64, -tmin(f64), -1.0); + try testArgs(f64, -tmin(f64), -0.1); + try testArgs(f64, -tmin(f64), -fmin(f64)); + try testArgs(f64, -tmin(f64), -tmin(f64)); + try testArgs(f64, -tmin(f64), -0.0); + try testArgs(f64, -tmin(f64), 0.0); + try testArgs(f64, -tmin(f64), tmin(f64)); + try testArgs(f64, -tmin(f64), fmin(f64)); + try testArgs(f64, -tmin(f64), 0.1); + try testArgs(f64, -tmin(f64), 1.0); + try testArgs(f64, -tmin(f64), 10.0); + try testArgs(f64, -tmin(f64), fmax(f64)); + try testArgs(f64, -tmin(f64), inf(f64)); + try testArgs(f64, -tmin(f64), nan(f64)); + + try testArgs(f64, -0.0, -nan(f64)); + try testArgs(f64, -0.0, -inf(f64)); + try testArgs(f64, -0.0, -fmax(f64)); + try testArgs(f64, -0.0, -10.0); + try testArgs(f64, -0.0, -1.0); + try testArgs(f64, -0.0, -0.1); + try testArgs(f64, -0.0, -fmin(f64)); + try testArgs(f64, -0.0, -tmin(f64)); + try testArgs(f64, -0.0, -0.0); + try testArgs(f64, -0.0, 0.0); + try testArgs(f64, -0.0, tmin(f64)); + try testArgs(f64, -0.0, fmin(f64)); + try testArgs(f64, -0.0, 0.1); + try testArgs(f64, -0.0, 1.0); + try testArgs(f64, -0.0, 10.0); + try testArgs(f64, -0.0, fmax(f64)); + try testArgs(f64, -0.0, inf(f64)); + try testArgs(f64, -0.0, nan(f64)); + + try testArgs(f64, 0.0, -nan(f64)); + try testArgs(f64, 0.0, -inf(f64)); + try testArgs(f64, 0.0, -fmax(f64)); + try testArgs(f64, 0.0, -10.0); + try testArgs(f64, 0.0, -1.0); + try testArgs(f64, 0.0, -0.1); + try testArgs(f64, 0.0, -fmin(f64)); + try testArgs(f64, 0.0, -tmin(f64)); + try testArgs(f64, 0.0, -0.0); + try testArgs(f64, 0.0, 0.0); + try testArgs(f64, 0.0, tmin(f64)); + try testArgs(f64, 0.0, fmin(f64)); + try testArgs(f64, 0.0, 0.1); + try testArgs(f64, 0.0, 1.0); + try testArgs(f64, 0.0, 10.0); + try testArgs(f64, 0.0, fmax(f64)); + try testArgs(f64, 0.0, inf(f64)); + try testArgs(f64, 0.0, nan(f64)); + + try testArgs(f64, tmin(f64), -nan(f64)); + try testArgs(f64, tmin(f64), -inf(f64)); + try testArgs(f64, tmin(f64), -fmax(f64)); + try testArgs(f64, tmin(f64), -10.0); + try testArgs(f64, tmin(f64), -1.0); + try testArgs(f64, tmin(f64), -0.1); + try testArgs(f64, tmin(f64), -fmin(f64)); + try testArgs(f64, tmin(f64), -tmin(f64)); + try testArgs(f64, tmin(f64), -0.0); + try testArgs(f64, tmin(f64), 0.0); + try testArgs(f64, tmin(f64), tmin(f64)); + try testArgs(f64, tmin(f64), fmin(f64)); + try testArgs(f64, tmin(f64), 0.1); + try testArgs(f64, tmin(f64), 1.0); + try testArgs(f64, tmin(f64), 10.0); + try testArgs(f64, tmin(f64), fmax(f64)); + try testArgs(f64, tmin(f64), inf(f64)); + try testArgs(f64, tmin(f64), nan(f64)); + + try testArgs(f64, fmin(f64), -nan(f64)); + try testArgs(f64, fmin(f64), -inf(f64)); + try testArgs(f64, fmin(f64), -fmax(f64)); + try testArgs(f64, fmin(f64), -10.0); + try testArgs(f64, fmin(f64), -1.0); + try testArgs(f64, fmin(f64), -0.1); + try testArgs(f64, fmin(f64), -fmin(f64)); + try testArgs(f64, fmin(f64), -tmin(f64)); + try testArgs(f64, fmin(f64), -0.0); + try testArgs(f64, fmin(f64), 0.0); + try testArgs(f64, fmin(f64), tmin(f64)); + try testArgs(f64, fmin(f64), fmin(f64)); + try testArgs(f64, fmin(f64), 0.1); + try testArgs(f64, fmin(f64), 1.0); + try testArgs(f64, fmin(f64), 10.0); + try testArgs(f64, fmin(f64), fmax(f64)); + try testArgs(f64, fmin(f64), inf(f64)); + try testArgs(f64, fmin(f64), nan(f64)); + + try testArgs(f64, 0.1, -nan(f64)); + try testArgs(f64, 0.1, -inf(f64)); + try testArgs(f64, 0.1, -fmax(f64)); + try testArgs(f64, 0.1, -10.0); + try testArgs(f64, 0.1, -1.0); + try testArgs(f64, 0.1, -0.1); + try testArgs(f64, 0.1, -fmin(f64)); + try testArgs(f64, 0.1, -tmin(f64)); + try testArgs(f64, 0.1, -0.0); + try testArgs(f64, 0.1, 0.0); + try testArgs(f64, 0.1, tmin(f64)); + try testArgs(f64, 0.1, fmin(f64)); + try testArgs(f64, 0.1, 0.1); + try testArgs(f64, 0.1, 1.0); + try testArgs(f64, 0.1, 10.0); + try testArgs(f64, 0.1, fmax(f64)); + try testArgs(f64, 0.1, inf(f64)); + try testArgs(f64, 0.1, nan(f64)); + + try testArgs(f64, 1.0, -nan(f64)); + try testArgs(f64, 1.0, -inf(f64)); + try testArgs(f64, 1.0, -fmax(f64)); + try testArgs(f64, 1.0, -10.0); + try testArgs(f64, 1.0, -1.0); + try testArgs(f64, 1.0, -0.1); + try testArgs(f64, 1.0, -fmin(f64)); + try testArgs(f64, 1.0, -tmin(f64)); + try testArgs(f64, 1.0, -0.0); + try testArgs(f64, 1.0, 0.0); + try testArgs(f64, 1.0, tmin(f64)); + try testArgs(f64, 1.0, fmin(f64)); + try testArgs(f64, 1.0, 0.1); + try testArgs(f64, 1.0, 1.0); + try testArgs(f64, 1.0, 10.0); + try testArgs(f64, 1.0, fmax(f64)); + try testArgs(f64, 1.0, inf(f64)); + try testArgs(f64, 1.0, nan(f64)); + + try testArgs(f64, 10.0, -nan(f64)); + try testArgs(f64, 10.0, -inf(f64)); + try testArgs(f64, 10.0, -fmax(f64)); + try testArgs(f64, 10.0, -10.0); + try testArgs(f64, 10.0, -1.0); + try testArgs(f64, 10.0, -0.1); + try testArgs(f64, 10.0, -fmin(f64)); + try testArgs(f64, 10.0, -tmin(f64)); + try testArgs(f64, 10.0, -0.0); + try testArgs(f64, 10.0, 0.0); + try testArgs(f64, 10.0, tmin(f64)); + try testArgs(f64, 10.0, fmin(f64)); + try testArgs(f64, 10.0, 0.1); + try testArgs(f64, 10.0, 1.0); + try testArgs(f64, 10.0, 10.0); + try testArgs(f64, 10.0, fmax(f64)); + try testArgs(f64, 10.0, inf(f64)); + try testArgs(f64, 10.0, nan(f64)); + + try testArgs(f64, fmax(f64), -nan(f64)); + try testArgs(f64, fmax(f64), -inf(f64)); + try testArgs(f64, fmax(f64), -fmax(f64)); + try testArgs(f64, fmax(f64), -10.0); + try testArgs(f64, fmax(f64), -1.0); + try testArgs(f64, fmax(f64), -0.1); + try testArgs(f64, fmax(f64), -fmin(f64)); + try testArgs(f64, fmax(f64), -tmin(f64)); + try testArgs(f64, fmax(f64), -0.0); + try testArgs(f64, fmax(f64), 0.0); + try testArgs(f64, fmax(f64), tmin(f64)); + try testArgs(f64, fmax(f64), fmin(f64)); + try testArgs(f64, fmax(f64), 0.1); + try testArgs(f64, fmax(f64), 1.0); + try testArgs(f64, fmax(f64), 10.0); + try testArgs(f64, fmax(f64), fmax(f64)); + try testArgs(f64, fmax(f64), inf(f64)); + try testArgs(f64, fmax(f64), nan(f64)); + + try testArgs(f64, inf(f64), -nan(f64)); + try testArgs(f64, inf(f64), -inf(f64)); + try testArgs(f64, inf(f64), -fmax(f64)); + try testArgs(f64, inf(f64), -10.0); + try testArgs(f64, inf(f64), -1.0); + try testArgs(f64, inf(f64), -0.1); + try testArgs(f64, inf(f64), -fmin(f64)); + try testArgs(f64, inf(f64), -tmin(f64)); + try testArgs(f64, inf(f64), -0.0); + try testArgs(f64, inf(f64), 0.0); + try testArgs(f64, inf(f64), tmin(f64)); + try testArgs(f64, inf(f64), fmin(f64)); + try testArgs(f64, inf(f64), 0.1); + try testArgs(f64, inf(f64), 1.0); + try testArgs(f64, inf(f64), 10.0); + try testArgs(f64, inf(f64), fmax(f64)); + try testArgs(f64, inf(f64), inf(f64)); + try testArgs(f64, inf(f64), nan(f64)); + + try testArgs(f64, nan(f64), -nan(f64)); + try testArgs(f64, nan(f64), -inf(f64)); + try testArgs(f64, nan(f64), -fmax(f64)); + try testArgs(f64, nan(f64), -10.0); + try testArgs(f64, nan(f64), -1.0); + try testArgs(f64, nan(f64), -0.1); + try testArgs(f64, nan(f64), -fmin(f64)); + try testArgs(f64, nan(f64), -tmin(f64)); + try testArgs(f64, nan(f64), -0.0); + try testArgs(f64, nan(f64), 0.0); + try testArgs(f64, nan(f64), tmin(f64)); + try testArgs(f64, nan(f64), fmin(f64)); + try testArgs(f64, nan(f64), 0.1); + try testArgs(f64, nan(f64), 1.0); + try testArgs(f64, nan(f64), 10.0); + try testArgs(f64, nan(f64), fmax(f64)); + try testArgs(f64, nan(f64), inf(f64)); + try testArgs(f64, nan(f64), nan(f64)); + + try testArgs(f80, -nan(f80), -nan(f80)); + try testArgs(f80, -nan(f80), -inf(f80)); + try testArgs(f80, -nan(f80), -fmax(f80)); + try testArgs(f80, -nan(f80), -10.0); + try testArgs(f80, -nan(f80), -1.0); + try testArgs(f80, -nan(f80), -0.1); + try testArgs(f80, -nan(f80), -fmin(f80)); + try testArgs(f80, -nan(f80), -tmin(f80)); + try testArgs(f80, -nan(f80), -0.0); + try testArgs(f80, -nan(f80), 0.0); + try testArgs(f80, -nan(f80), tmin(f80)); + try testArgs(f80, -nan(f80), fmin(f80)); + try testArgs(f80, -nan(f80), 0.1); + try testArgs(f80, -nan(f80), 1.0); + try testArgs(f80, -nan(f80), 10.0); + try testArgs(f80, -nan(f80), fmax(f80)); + try testArgs(f80, -nan(f80), inf(f80)); + try testArgs(f80, -nan(f80), nan(f80)); + + try testArgs(f80, -inf(f80), -nan(f80)); + try testArgs(f80, -inf(f80), -inf(f80)); + try testArgs(f80, -inf(f80), -fmax(f80)); + try testArgs(f80, -inf(f80), -10.0); + try testArgs(f80, -inf(f80), -1.0); + try testArgs(f80, -inf(f80), -0.1); + try testArgs(f80, -inf(f80), -fmin(f80)); + try testArgs(f80, -inf(f80), -tmin(f80)); + try testArgs(f80, -inf(f80), -0.0); + try testArgs(f80, -inf(f80), 0.0); + try testArgs(f80, -inf(f80), tmin(f80)); + try testArgs(f80, -inf(f80), fmin(f80)); + try testArgs(f80, -inf(f80), 0.1); + try testArgs(f80, -inf(f80), 1.0); + try testArgs(f80, -inf(f80), 10.0); + try testArgs(f80, -inf(f80), fmax(f80)); + try testArgs(f80, -inf(f80), inf(f80)); + try testArgs(f80, -inf(f80), nan(f80)); + + try testArgs(f80, -fmax(f80), -nan(f80)); + try testArgs(f80, -fmax(f80), -inf(f80)); + try testArgs(f80, -fmax(f80), -fmax(f80)); + try testArgs(f80, -fmax(f80), -10.0); + try testArgs(f80, -fmax(f80), -1.0); + try testArgs(f80, -fmax(f80), -0.1); + try testArgs(f80, -fmax(f80), -fmin(f80)); + try testArgs(f80, -fmax(f80), -tmin(f80)); + try testArgs(f80, -fmax(f80), -0.0); + try testArgs(f80, -fmax(f80), 0.0); + try testArgs(f80, -fmax(f80), tmin(f80)); + try testArgs(f80, -fmax(f80), fmin(f80)); + try testArgs(f80, -fmax(f80), 0.1); + try testArgs(f80, -fmax(f80), 1.0); + try testArgs(f80, -fmax(f80), 10.0); + try testArgs(f80, -fmax(f80), fmax(f80)); + try testArgs(f80, -fmax(f80), inf(f80)); + try testArgs(f80, -fmax(f80), nan(f80)); + + try testArgs(f80, -10.0, -nan(f80)); + try testArgs(f80, -10.0, -inf(f80)); + try testArgs(f80, -10.0, -fmax(f80)); + try testArgs(f80, -10.0, -10.0); + try testArgs(f80, -10.0, -1.0); + try testArgs(f80, -10.0, -0.1); + try testArgs(f80, -10.0, -fmin(f80)); + try testArgs(f80, -10.0, -tmin(f80)); + try testArgs(f80, -10.0, -0.0); + try testArgs(f80, -10.0, 0.0); + try testArgs(f80, -10.0, tmin(f80)); + try testArgs(f80, -10.0, fmin(f80)); + try testArgs(f80, -10.0, 0.1); + try testArgs(f80, -10.0, 1.0); + try testArgs(f80, -10.0, 10.0); + try testArgs(f80, -10.0, fmax(f80)); + try testArgs(f80, -10.0, inf(f80)); + try testArgs(f80, -10.0, nan(f80)); + + try testArgs(f80, -1.0, -nan(f80)); + try testArgs(f80, -1.0, -inf(f80)); + try testArgs(f80, -1.0, -fmax(f80)); + try testArgs(f80, -1.0, -10.0); + try testArgs(f80, -1.0, -1.0); + try testArgs(f80, -1.0, -0.1); + try testArgs(f80, -1.0, -fmin(f80)); + try testArgs(f80, -1.0, -tmin(f80)); + try testArgs(f80, -1.0, -0.0); + try testArgs(f80, -1.0, 0.0); + try testArgs(f80, -1.0, tmin(f80)); + try testArgs(f80, -1.0, fmin(f80)); + try testArgs(f80, -1.0, 0.1); + try testArgs(f80, -1.0, 1.0); + try testArgs(f80, -1.0, 10.0); + try testArgs(f80, -1.0, fmax(f80)); + try testArgs(f80, -1.0, inf(f80)); + try testArgs(f80, -1.0, nan(f80)); + + try testArgs(f80, -0.1, -nan(f80)); + try testArgs(f80, -0.1, -inf(f80)); + try testArgs(f80, -0.1, -fmax(f80)); + try testArgs(f80, -0.1, -10.0); + try testArgs(f80, -0.1, -1.0); + try testArgs(f80, -0.1, -0.1); + try testArgs(f80, -0.1, -fmin(f80)); + try testArgs(f80, -0.1, -tmin(f80)); + try testArgs(f80, -0.1, -0.0); + try testArgs(f80, -0.1, 0.0); + try testArgs(f80, -0.1, tmin(f80)); + try testArgs(f80, -0.1, fmin(f80)); + try testArgs(f80, -0.1, 0.1); + try testArgs(f80, -0.1, 1.0); + try testArgs(f80, -0.1, 10.0); + try testArgs(f80, -0.1, fmax(f80)); + try testArgs(f80, -0.1, inf(f80)); + try testArgs(f80, -0.1, nan(f80)); + + try testArgs(f80, -fmin(f80), -nan(f80)); + try testArgs(f80, -fmin(f80), -inf(f80)); + try testArgs(f80, -fmin(f80), -fmax(f80)); + try testArgs(f80, -fmin(f80), -10.0); + try testArgs(f80, -fmin(f80), -1.0); + try testArgs(f80, -fmin(f80), -0.1); + try testArgs(f80, -fmin(f80), -fmin(f80)); + try testArgs(f80, -fmin(f80), -tmin(f80)); + try testArgs(f80, -fmin(f80), -0.0); + try testArgs(f80, -fmin(f80), 0.0); + try testArgs(f80, -fmin(f80), tmin(f80)); + try testArgs(f80, -fmin(f80), fmin(f80)); + try testArgs(f80, -fmin(f80), 0.1); + try testArgs(f80, -fmin(f80), 1.0); + try testArgs(f80, -fmin(f80), 10.0); + try testArgs(f80, -fmin(f80), fmax(f80)); + try testArgs(f80, -fmin(f80), inf(f80)); + try testArgs(f80, -fmin(f80), nan(f80)); + + try testArgs(f80, -tmin(f80), -nan(f80)); + try testArgs(f80, -tmin(f80), -inf(f80)); + try testArgs(f80, -tmin(f80), -fmax(f80)); + try testArgs(f80, -tmin(f80), -10.0); + try testArgs(f80, -tmin(f80), -1.0); + try testArgs(f80, -tmin(f80), -0.1); + try testArgs(f80, -tmin(f80), -fmin(f80)); + try testArgs(f80, -tmin(f80), -tmin(f80)); + try testArgs(f80, -tmin(f80), -0.0); + try testArgs(f80, -tmin(f80), 0.0); + try testArgs(f80, -tmin(f80), tmin(f80)); + try testArgs(f80, -tmin(f80), fmin(f80)); + try testArgs(f80, -tmin(f80), 0.1); + try testArgs(f80, -tmin(f80), 1.0); + try testArgs(f80, -tmin(f80), 10.0); + try testArgs(f80, -tmin(f80), fmax(f80)); + try testArgs(f80, -tmin(f80), inf(f80)); + try testArgs(f80, -tmin(f80), nan(f80)); + + try testArgs(f80, -0.0, -nan(f80)); + try testArgs(f80, -0.0, -inf(f80)); + try testArgs(f80, -0.0, -fmax(f80)); + try testArgs(f80, -0.0, -10.0); + try testArgs(f80, -0.0, -1.0); + try testArgs(f80, -0.0, -0.1); + try testArgs(f80, -0.0, -fmin(f80)); + try testArgs(f80, -0.0, -tmin(f80)); + try testArgs(f80, -0.0, -0.0); + try testArgs(f80, -0.0, 0.0); + try testArgs(f80, -0.0, tmin(f80)); + try testArgs(f80, -0.0, fmin(f80)); + try testArgs(f80, -0.0, 0.1); + try testArgs(f80, -0.0, 1.0); + try testArgs(f80, -0.0, 10.0); + try testArgs(f80, -0.0, fmax(f80)); + try testArgs(f80, -0.0, inf(f80)); + try testArgs(f80, -0.0, nan(f80)); + + try testArgs(f80, 0.0, -nan(f80)); + try testArgs(f80, 0.0, -inf(f80)); + try testArgs(f80, 0.0, -fmax(f80)); + try testArgs(f80, 0.0, -10.0); + try testArgs(f80, 0.0, -1.0); + try testArgs(f80, 0.0, -0.1); + try testArgs(f80, 0.0, -fmin(f80)); + try testArgs(f80, 0.0, -tmin(f80)); + try testArgs(f80, 0.0, -0.0); + try testArgs(f80, 0.0, 0.0); + try testArgs(f80, 0.0, tmin(f80)); + try testArgs(f80, 0.0, fmin(f80)); + try testArgs(f80, 0.0, 0.1); + try testArgs(f80, 0.0, 1.0); + try testArgs(f80, 0.0, 10.0); + try testArgs(f80, 0.0, fmax(f80)); + try testArgs(f80, 0.0, inf(f80)); + try testArgs(f80, 0.0, nan(f80)); + + try testArgs(f80, tmin(f80), -nan(f80)); + try testArgs(f80, tmin(f80), -inf(f80)); + try testArgs(f80, tmin(f80), -fmax(f80)); + try testArgs(f80, tmin(f80), -10.0); + try testArgs(f80, tmin(f80), -1.0); + try testArgs(f80, tmin(f80), -0.1); + try testArgs(f80, tmin(f80), -fmin(f80)); + try testArgs(f80, tmin(f80), -tmin(f80)); + try testArgs(f80, tmin(f80), -0.0); + try testArgs(f80, tmin(f80), 0.0); + try testArgs(f80, tmin(f80), tmin(f80)); + try testArgs(f80, tmin(f80), fmin(f80)); + try testArgs(f80, tmin(f80), 0.1); + try testArgs(f80, tmin(f80), 1.0); + try testArgs(f80, tmin(f80), 10.0); + try testArgs(f80, tmin(f80), fmax(f80)); + try testArgs(f80, tmin(f80), inf(f80)); + try testArgs(f80, tmin(f80), nan(f80)); + + try testArgs(f80, fmin(f80), -nan(f80)); + try testArgs(f80, fmin(f80), -inf(f80)); + try testArgs(f80, fmin(f80), -fmax(f80)); + try testArgs(f80, fmin(f80), -10.0); + try testArgs(f80, fmin(f80), -1.0); + try testArgs(f80, fmin(f80), -0.1); + try testArgs(f80, fmin(f80), -fmin(f80)); + try testArgs(f80, fmin(f80), -tmin(f80)); + try testArgs(f80, fmin(f80), -0.0); + try testArgs(f80, fmin(f80), 0.0); + try testArgs(f80, fmin(f80), tmin(f80)); + try testArgs(f80, fmin(f80), fmin(f80)); + try testArgs(f80, fmin(f80), 0.1); + try testArgs(f80, fmin(f80), 1.0); + try testArgs(f80, fmin(f80), 10.0); + try testArgs(f80, fmin(f80), fmax(f80)); + try testArgs(f80, fmin(f80), inf(f80)); + try testArgs(f80, fmin(f80), nan(f80)); + + try testArgs(f80, 0.1, -nan(f80)); + try testArgs(f80, 0.1, -inf(f80)); + try testArgs(f80, 0.1, -fmax(f80)); + try testArgs(f80, 0.1, -10.0); + try testArgs(f80, 0.1, -1.0); + try testArgs(f80, 0.1, -0.1); + try testArgs(f80, 0.1, -fmin(f80)); + try testArgs(f80, 0.1, -tmin(f80)); + try testArgs(f80, 0.1, -0.0); + try testArgs(f80, 0.1, 0.0); + try testArgs(f80, 0.1, tmin(f80)); + try testArgs(f80, 0.1, fmin(f80)); + try testArgs(f80, 0.1, 0.1); + try testArgs(f80, 0.1, 1.0); + try testArgs(f80, 0.1, 10.0); + try testArgs(f80, 0.1, fmax(f80)); + try testArgs(f80, 0.1, inf(f80)); + try testArgs(f80, 0.1, nan(f80)); + + try testArgs(f80, 1.0, -nan(f80)); + try testArgs(f80, 1.0, -inf(f80)); + try testArgs(f80, 1.0, -fmax(f80)); + try testArgs(f80, 1.0, -10.0); + try testArgs(f80, 1.0, -1.0); + try testArgs(f80, 1.0, -0.1); + try testArgs(f80, 1.0, -fmin(f80)); + try testArgs(f80, 1.0, -tmin(f80)); + try testArgs(f80, 1.0, -0.0); + try testArgs(f80, 1.0, 0.0); + try testArgs(f80, 1.0, tmin(f80)); + try testArgs(f80, 1.0, fmin(f80)); + try testArgs(f80, 1.0, 0.1); + try testArgs(f80, 1.0, 1.0); + try testArgs(f80, 1.0, 10.0); + try testArgs(f80, 1.0, fmax(f80)); + try testArgs(f80, 1.0, inf(f80)); + try testArgs(f80, 1.0, nan(f80)); + + try testArgs(f80, 10.0, -nan(f80)); + try testArgs(f80, 10.0, -inf(f80)); + try testArgs(f80, 10.0, -fmax(f80)); + try testArgs(f80, 10.0, -10.0); + try testArgs(f80, 10.0, -1.0); + try testArgs(f80, 10.0, -0.1); + try testArgs(f80, 10.0, -fmin(f80)); + try testArgs(f80, 10.0, -tmin(f80)); + try testArgs(f80, 10.0, -0.0); + try testArgs(f80, 10.0, 0.0); + try testArgs(f80, 10.0, tmin(f80)); + try testArgs(f80, 10.0, fmin(f80)); + try testArgs(f80, 10.0, 0.1); + try testArgs(f80, 10.0, 1.0); + try testArgs(f80, 10.0, 10.0); + try testArgs(f80, 10.0, fmax(f80)); + try testArgs(f80, 10.0, inf(f80)); + try testArgs(f80, 10.0, nan(f80)); + + try testArgs(f80, fmax(f80), -nan(f80)); + try testArgs(f80, fmax(f80), -inf(f80)); + try testArgs(f80, fmax(f80), -fmax(f80)); + try testArgs(f80, fmax(f80), -10.0); + try testArgs(f80, fmax(f80), -1.0); + try testArgs(f80, fmax(f80), -0.1); + try testArgs(f80, fmax(f80), -fmin(f80)); + try testArgs(f80, fmax(f80), -tmin(f80)); + try testArgs(f80, fmax(f80), -0.0); + try testArgs(f80, fmax(f80), 0.0); + try testArgs(f80, fmax(f80), tmin(f80)); + try testArgs(f80, fmax(f80), fmin(f80)); + try testArgs(f80, fmax(f80), 0.1); + try testArgs(f80, fmax(f80), 1.0); + try testArgs(f80, fmax(f80), 10.0); + try testArgs(f80, fmax(f80), fmax(f80)); + try testArgs(f80, fmax(f80), inf(f80)); + try testArgs(f80, fmax(f80), nan(f80)); + + try testArgs(f80, inf(f80), -nan(f80)); + try testArgs(f80, inf(f80), -inf(f80)); + try testArgs(f80, inf(f80), -fmax(f80)); + try testArgs(f80, inf(f80), -10.0); + try testArgs(f80, inf(f80), -1.0); + try testArgs(f80, inf(f80), -0.1); + try testArgs(f80, inf(f80), -fmin(f80)); + try testArgs(f80, inf(f80), -tmin(f80)); + try testArgs(f80, inf(f80), -0.0); + try testArgs(f80, inf(f80), 0.0); + try testArgs(f80, inf(f80), tmin(f80)); + try testArgs(f80, inf(f80), fmin(f80)); + try testArgs(f80, inf(f80), 0.1); + try testArgs(f80, inf(f80), 1.0); + try testArgs(f80, inf(f80), 10.0); + try testArgs(f80, inf(f80), fmax(f80)); + try testArgs(f80, inf(f80), inf(f80)); + try testArgs(f80, inf(f80), nan(f80)); + + try testArgs(f80, nan(f80), -nan(f80)); + try testArgs(f80, nan(f80), -inf(f80)); + try testArgs(f80, nan(f80), -fmax(f80)); + try testArgs(f80, nan(f80), -10.0); + try testArgs(f80, nan(f80), -1.0); + try testArgs(f80, nan(f80), -0.1); + try testArgs(f80, nan(f80), -fmin(f80)); + try testArgs(f80, nan(f80), -tmin(f80)); + try testArgs(f80, nan(f80), -0.0); + try testArgs(f80, nan(f80), 0.0); + try testArgs(f80, nan(f80), tmin(f80)); + try testArgs(f80, nan(f80), fmin(f80)); + try testArgs(f80, nan(f80), 0.1); + try testArgs(f80, nan(f80), 1.0); + try testArgs(f80, nan(f80), 10.0); + try testArgs(f80, nan(f80), fmax(f80)); + try testArgs(f80, nan(f80), inf(f80)); + try testArgs(f80, nan(f80), nan(f80)); + + try testArgs(f128, -nan(f128), -nan(f128)); + try testArgs(f128, -nan(f128), -inf(f128)); + try testArgs(f128, -nan(f128), -fmax(f128)); + try testArgs(f128, -nan(f128), -10.0); + try testArgs(f128, -nan(f128), -1.0); + try testArgs(f128, -nan(f128), -0.1); + try testArgs(f128, -nan(f128), -fmin(f128)); + try testArgs(f128, -nan(f128), -tmin(f128)); + try testArgs(f128, -nan(f128), -0.0); + try testArgs(f128, -nan(f128), 0.0); + try testArgs(f128, -nan(f128), tmin(f128)); + try testArgs(f128, -nan(f128), fmin(f128)); + try testArgs(f128, -nan(f128), 0.1); + try testArgs(f128, -nan(f128), 1.0); + try testArgs(f128, -nan(f128), 10.0); + try testArgs(f128, -nan(f128), fmax(f128)); + try testArgs(f128, -nan(f128), inf(f128)); + try testArgs(f128, -nan(f128), nan(f128)); + + try testArgs(f128, -inf(f128), -nan(f128)); + try testArgs(f128, -inf(f128), -inf(f128)); + try testArgs(f128, -inf(f128), -fmax(f128)); + try testArgs(f128, -inf(f128), -10.0); + try testArgs(f128, -inf(f128), -1.0); + try testArgs(f128, -inf(f128), -0.1); + try testArgs(f128, -inf(f128), -fmin(f128)); + try testArgs(f128, -inf(f128), -tmin(f128)); + try testArgs(f128, -inf(f128), -0.0); + try testArgs(f128, -inf(f128), 0.0); + try testArgs(f128, -inf(f128), tmin(f128)); + try testArgs(f128, -inf(f128), fmin(f128)); + try testArgs(f128, -inf(f128), 0.1); + try testArgs(f128, -inf(f128), 1.0); + try testArgs(f128, -inf(f128), 10.0); + try testArgs(f128, -inf(f128), fmax(f128)); + try testArgs(f128, -inf(f128), inf(f128)); + try testArgs(f128, -inf(f128), nan(f128)); + + try testArgs(f128, -fmax(f128), -nan(f128)); + try testArgs(f128, -fmax(f128), -inf(f128)); + try testArgs(f128, -fmax(f128), -fmax(f128)); + try testArgs(f128, -fmax(f128), -10.0); + try testArgs(f128, -fmax(f128), -1.0); + try testArgs(f128, -fmax(f128), -0.1); + try testArgs(f128, -fmax(f128), -fmin(f128)); + try testArgs(f128, -fmax(f128), -tmin(f128)); + try testArgs(f128, -fmax(f128), -0.0); + try testArgs(f128, -fmax(f128), 0.0); + try testArgs(f128, -fmax(f128), tmin(f128)); + try testArgs(f128, -fmax(f128), fmin(f128)); + try testArgs(f128, -fmax(f128), 0.1); + try testArgs(f128, -fmax(f128), 1.0); + try testArgs(f128, -fmax(f128), 10.0); + try testArgs(f128, -fmax(f128), fmax(f128)); + try testArgs(f128, -fmax(f128), inf(f128)); + try testArgs(f128, -fmax(f128), nan(f128)); + + try testArgs(f128, -10.0, -nan(f128)); + try testArgs(f128, -10.0, -inf(f128)); + try testArgs(f128, -10.0, -fmax(f128)); + try testArgs(f128, -10.0, -10.0); + try testArgs(f128, -10.0, -1.0); + try testArgs(f128, -10.0, -0.1); + try testArgs(f128, -10.0, -fmin(f128)); + try testArgs(f128, -10.0, -tmin(f128)); + try testArgs(f128, -10.0, -0.0); + try testArgs(f128, -10.0, 0.0); + try testArgs(f128, -10.0, tmin(f128)); + try testArgs(f128, -10.0, fmin(f128)); + try testArgs(f128, -10.0, 0.1); + try testArgs(f128, -10.0, 1.0); + try testArgs(f128, -10.0, 10.0); + try testArgs(f128, -10.0, fmax(f128)); + try testArgs(f128, -10.0, inf(f128)); + try testArgs(f128, -10.0, nan(f128)); + + try testArgs(f128, -1.0, -nan(f128)); + try testArgs(f128, -1.0, -inf(f128)); + try testArgs(f128, -1.0, -fmax(f128)); + try testArgs(f128, -1.0, -10.0); + try testArgs(f128, -1.0, -1.0); + try testArgs(f128, -1.0, -0.1); + try testArgs(f128, -1.0, -fmin(f128)); + try testArgs(f128, -1.0, -tmin(f128)); + try testArgs(f128, -1.0, -0.0); + try testArgs(f128, -1.0, 0.0); + try testArgs(f128, -1.0, tmin(f128)); + try testArgs(f128, -1.0, fmin(f128)); + try testArgs(f128, -1.0, 0.1); + try testArgs(f128, -1.0, 1.0); + try testArgs(f128, -1.0, 10.0); + try testArgs(f128, -1.0, fmax(f128)); + try testArgs(f128, -1.0, inf(f128)); + try testArgs(f128, -1.0, nan(f128)); + + try testArgs(f128, -0.1, -nan(f128)); + try testArgs(f128, -0.1, -inf(f128)); + try testArgs(f128, -0.1, -fmax(f128)); + try testArgs(f128, -0.1, -10.0); + try testArgs(f128, -0.1, -1.0); + try testArgs(f128, -0.1, -0.1); + try testArgs(f128, -0.1, -fmin(f128)); + try testArgs(f128, -0.1, -tmin(f128)); + try testArgs(f128, -0.1, -0.0); + try testArgs(f128, -0.1, 0.0); + try testArgs(f128, -0.1, tmin(f128)); + try testArgs(f128, -0.1, fmin(f128)); + try testArgs(f128, -0.1, 0.1); + try testArgs(f128, -0.1, 1.0); + try testArgs(f128, -0.1, 10.0); + try testArgs(f128, -0.1, fmax(f128)); + try testArgs(f128, -0.1, inf(f128)); + try testArgs(f128, -0.1, nan(f128)); + + try testArgs(f128, -fmin(f128), -nan(f128)); + try testArgs(f128, -fmin(f128), -inf(f128)); + try testArgs(f128, -fmin(f128), -fmax(f128)); + try testArgs(f128, -fmin(f128), -10.0); + try testArgs(f128, -fmin(f128), -1.0); + try testArgs(f128, -fmin(f128), -0.1); + try testArgs(f128, -fmin(f128), -fmin(f128)); + try testArgs(f128, -fmin(f128), -tmin(f128)); + try testArgs(f128, -fmin(f128), -0.0); + try testArgs(f128, -fmin(f128), 0.0); + try testArgs(f128, -fmin(f128), tmin(f128)); + try testArgs(f128, -fmin(f128), fmin(f128)); + try testArgs(f128, -fmin(f128), 0.1); + try testArgs(f128, -fmin(f128), 1.0); + try testArgs(f128, -fmin(f128), 10.0); + try testArgs(f128, -fmin(f128), fmax(f128)); + try testArgs(f128, -fmin(f128), inf(f128)); + try testArgs(f128, -fmin(f128), nan(f128)); + + try testArgs(f128, -tmin(f128), -nan(f128)); + try testArgs(f128, -tmin(f128), -inf(f128)); + try testArgs(f128, -tmin(f128), -fmax(f128)); + try testArgs(f128, -tmin(f128), -10.0); + try testArgs(f128, -tmin(f128), -1.0); + try testArgs(f128, -tmin(f128), -0.1); + try testArgs(f128, -tmin(f128), -fmin(f128)); + try testArgs(f128, -tmin(f128), -tmin(f128)); + try testArgs(f128, -tmin(f128), -0.0); + try testArgs(f128, -tmin(f128), 0.0); + try testArgs(f128, -tmin(f128), tmin(f128)); + try testArgs(f128, -tmin(f128), fmin(f128)); + try testArgs(f128, -tmin(f128), 0.1); + try testArgs(f128, -tmin(f128), 1.0); + try testArgs(f128, -tmin(f128), 10.0); + try testArgs(f128, -tmin(f128), fmax(f128)); + try testArgs(f128, -tmin(f128), inf(f128)); + try testArgs(f128, -tmin(f128), nan(f128)); + + try testArgs(f128, -0.0, -nan(f128)); + try testArgs(f128, -0.0, -inf(f128)); + try testArgs(f128, -0.0, -fmax(f128)); + try testArgs(f128, -0.0, -10.0); + try testArgs(f128, -0.0, -1.0); + try testArgs(f128, -0.0, -0.1); + try testArgs(f128, -0.0, -fmin(f128)); + try testArgs(f128, -0.0, -tmin(f128)); + try testArgs(f128, -0.0, -0.0); + try testArgs(f128, -0.0, 0.0); + try testArgs(f128, -0.0, tmin(f128)); + try testArgs(f128, -0.0, fmin(f128)); + try testArgs(f128, -0.0, 0.1); + try testArgs(f128, -0.0, 1.0); + try testArgs(f128, -0.0, 10.0); + try testArgs(f128, -0.0, fmax(f128)); + try testArgs(f128, -0.0, inf(f128)); + try testArgs(f128, -0.0, nan(f128)); + + try testArgs(f128, 0.0, -nan(f128)); + try testArgs(f128, 0.0, -inf(f128)); + try testArgs(f128, 0.0, -fmax(f128)); + try testArgs(f128, 0.0, -10.0); + try testArgs(f128, 0.0, -1.0); + try testArgs(f128, 0.0, -0.1); + try testArgs(f128, 0.0, -fmin(f128)); + try testArgs(f128, 0.0, -tmin(f128)); + try testArgs(f128, 0.0, -0.0); + try testArgs(f128, 0.0, 0.0); + try testArgs(f128, 0.0, tmin(f128)); + try testArgs(f128, 0.0, fmin(f128)); + try testArgs(f128, 0.0, 0.1); + try testArgs(f128, 0.0, 1.0); + try testArgs(f128, 0.0, 10.0); + try testArgs(f128, 0.0, fmax(f128)); + try testArgs(f128, 0.0, inf(f128)); + try testArgs(f128, 0.0, nan(f128)); + + try testArgs(f128, tmin(f128), -nan(f128)); + try testArgs(f128, tmin(f128), -inf(f128)); + try testArgs(f128, tmin(f128), -fmax(f128)); + try testArgs(f128, tmin(f128), -10.0); + try testArgs(f128, tmin(f128), -1.0); + try testArgs(f128, tmin(f128), -0.1); + try testArgs(f128, tmin(f128), -fmin(f128)); + try testArgs(f128, tmin(f128), -tmin(f128)); + try testArgs(f128, tmin(f128), -0.0); + try testArgs(f128, tmin(f128), 0.0); + try testArgs(f128, tmin(f128), tmin(f128)); + try testArgs(f128, tmin(f128), fmin(f128)); + try testArgs(f128, tmin(f128), 0.1); + try testArgs(f128, tmin(f128), 1.0); + try testArgs(f128, tmin(f128), 10.0); + try testArgs(f128, tmin(f128), fmax(f128)); + try testArgs(f128, tmin(f128), inf(f128)); + try testArgs(f128, tmin(f128), nan(f128)); + + try testArgs(f128, fmin(f128), -nan(f128)); + try testArgs(f128, fmin(f128), -inf(f128)); + try testArgs(f128, fmin(f128), -fmax(f128)); + try testArgs(f128, fmin(f128), -10.0); + try testArgs(f128, fmin(f128), -1.0); + try testArgs(f128, fmin(f128), -0.1); + try testArgs(f128, fmin(f128), -fmin(f128)); + try testArgs(f128, fmin(f128), -tmin(f128)); + try testArgs(f128, fmin(f128), -0.0); + try testArgs(f128, fmin(f128), 0.0); + try testArgs(f128, fmin(f128), tmin(f128)); + try testArgs(f128, fmin(f128), fmin(f128)); + try testArgs(f128, fmin(f128), 0.1); + try testArgs(f128, fmin(f128), 1.0); + try testArgs(f128, fmin(f128), 10.0); + try testArgs(f128, fmin(f128), fmax(f128)); + try testArgs(f128, fmin(f128), inf(f128)); + try testArgs(f128, fmin(f128), nan(f128)); + + try testArgs(f128, 0.1, -nan(f128)); + try testArgs(f128, 0.1, -inf(f128)); + try testArgs(f128, 0.1, -fmax(f128)); + try testArgs(f128, 0.1, -10.0); + try testArgs(f128, 0.1, -1.0); + try testArgs(f128, 0.1, -0.1); + try testArgs(f128, 0.1, -fmin(f128)); + try testArgs(f128, 0.1, -tmin(f128)); + try testArgs(f128, 0.1, -0.0); + try testArgs(f128, 0.1, 0.0); + try testArgs(f128, 0.1, tmin(f128)); + try testArgs(f128, 0.1, fmin(f128)); + try testArgs(f128, 0.1, 0.1); + try testArgs(f128, 0.1, 1.0); + try testArgs(f128, 0.1, 10.0); + try testArgs(f128, 0.1, fmax(f128)); + try testArgs(f128, 0.1, inf(f128)); + try testArgs(f128, 0.1, nan(f128)); + + try testArgs(f128, 1.0, -nan(f128)); + try testArgs(f128, 1.0, -inf(f128)); + try testArgs(f128, 1.0, -fmax(f128)); + try testArgs(f128, 1.0, -10.0); + try testArgs(f128, 1.0, -1.0); + try testArgs(f128, 1.0, -0.1); + try testArgs(f128, 1.0, -fmin(f128)); + try testArgs(f128, 1.0, -tmin(f128)); + try testArgs(f128, 1.0, -0.0); + try testArgs(f128, 1.0, 0.0); + try testArgs(f128, 1.0, tmin(f128)); + try testArgs(f128, 1.0, fmin(f128)); + try testArgs(f128, 1.0, 0.1); + try testArgs(f128, 1.0, 1.0); + try testArgs(f128, 1.0, 10.0); + try testArgs(f128, 1.0, fmax(f128)); + try testArgs(f128, 1.0, inf(f128)); + try testArgs(f128, 1.0, nan(f128)); + + try testArgs(f128, 10.0, -nan(f128)); + try testArgs(f128, 10.0, -inf(f128)); + try testArgs(f128, 10.0, -fmax(f128)); + try testArgs(f128, 10.0, -10.0); + try testArgs(f128, 10.0, -1.0); + try testArgs(f128, 10.0, -0.1); + try testArgs(f128, 10.0, -fmin(f128)); + try testArgs(f128, 10.0, -tmin(f128)); + try testArgs(f128, 10.0, -0.0); + try testArgs(f128, 10.0, 0.0); + try testArgs(f128, 10.0, tmin(f128)); + try testArgs(f128, 10.0, fmin(f128)); + try testArgs(f128, 10.0, 0.1); + try testArgs(f128, 10.0, 1.0); + try testArgs(f128, 10.0, 10.0); + try testArgs(f128, 10.0, fmax(f128)); + try testArgs(f128, 10.0, inf(f128)); + try testArgs(f128, 10.0, nan(f128)); + + try testArgs(f128, fmax(f128), -nan(f128)); + try testArgs(f128, fmax(f128), -inf(f128)); + try testArgs(f128, fmax(f128), -fmax(f128)); + try testArgs(f128, fmax(f128), -10.0); + try testArgs(f128, fmax(f128), -1.0); + try testArgs(f128, fmax(f128), -0.1); + try testArgs(f128, fmax(f128), -fmin(f128)); + try testArgs(f128, fmax(f128), -tmin(f128)); + try testArgs(f128, fmax(f128), -0.0); + try testArgs(f128, fmax(f128), 0.0); + try testArgs(f128, fmax(f128), tmin(f128)); + try testArgs(f128, fmax(f128), fmin(f128)); + try testArgs(f128, fmax(f128), 0.1); + try testArgs(f128, fmax(f128), 1.0); + try testArgs(f128, fmax(f128), 10.0); + try testArgs(f128, fmax(f128), fmax(f128)); + try testArgs(f128, fmax(f128), inf(f128)); + try testArgs(f128, fmax(f128), nan(f128)); + + try testArgs(f128, inf(f128), -nan(f128)); + try testArgs(f128, inf(f128), -inf(f128)); + try testArgs(f128, inf(f128), -fmax(f128)); + try testArgs(f128, inf(f128), -10.0); + try testArgs(f128, inf(f128), -1.0); + try testArgs(f128, inf(f128), -0.1); + try testArgs(f128, inf(f128), -fmin(f128)); + try testArgs(f128, inf(f128), -tmin(f128)); + try testArgs(f128, inf(f128), -0.0); + try testArgs(f128, inf(f128), 0.0); + try testArgs(f128, inf(f128), tmin(f128)); + try testArgs(f128, inf(f128), fmin(f128)); + try testArgs(f128, inf(f128), 0.1); + try testArgs(f128, inf(f128), 1.0); + try testArgs(f128, inf(f128), 10.0); + try testArgs(f128, inf(f128), fmax(f128)); + try testArgs(f128, inf(f128), inf(f128)); + try testArgs(f128, inf(f128), nan(f128)); + + try testArgs(f128, nan(f128), -nan(f128)); + try testArgs(f128, nan(f128), -inf(f128)); + try testArgs(f128, nan(f128), -fmax(f128)); + try testArgs(f128, nan(f128), -10.0); + try testArgs(f128, nan(f128), -1.0); + try testArgs(f128, nan(f128), -0.1); + try testArgs(f128, nan(f128), -fmin(f128)); + try testArgs(f128, nan(f128), -tmin(f128)); + try testArgs(f128, nan(f128), -0.0); + try testArgs(f128, nan(f128), 0.0); + try testArgs(f128, nan(f128), tmin(f128)); + try testArgs(f128, nan(f128), fmin(f128)); + try testArgs(f128, nan(f128), 0.1); + try testArgs(f128, nan(f128), 1.0); + try testArgs(f128, nan(f128), 10.0); + try testArgs(f128, nan(f128), fmax(f128)); + try testArgs(f128, nan(f128), inf(f128)); + try testArgs(f128, nan(f128), nan(f128)); + } fn testIntVectorTypes() !void { try testArgs(@Vector(1, i8), .{ -0x54, @@ -2069,64 +3788,74 @@ inline fn bitNot(comptime Type: type, rhs: Type) @TypeOf(~rhs) { return ~rhs; } test bitNot { - try Unary(bitNot).testIntTypes(); - try Unary(bitNot).testIntVectorTypes(); + const t = unary(bitNot, .{}); + try t.testIntTypes(); + try t.testIntVectorTypes(); } inline fn abs(comptime Type: type, rhs: Type) @TypeOf(@abs(rhs)) { return @abs(rhs); } test abs { - try Unary(abs).testIntTypes(); - try Unary(abs).testIntVectorTypes(); - try Unary(abs).testFloatTypes(); - try Unary(abs).testFloatVectorTypes(); + const t = unary(abs, .{ .strict = true }); + try t.testIntTypes(); + try t.testIntVectorTypes(); + try t.testFloatTypes(); + try t.testFloatVectorTypes(); } inline fn clz(comptime Type: type, rhs: Type) @TypeOf(@clz(rhs)) { return @clz(rhs); } test clz { - try Unary(clz).testIntTypes(); - try Unary(clz).testIntVectorTypes(); + const t = unary(clz, .{}); + try t.testIntTypes(); + try t.testIntVectorTypes(); } inline fn bitAnd(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs & rhs) { return lhs & rhs; } test bitAnd { - try Binary(bitAnd).testIntTypes(); - try Binary(bitAnd).testIntVectorTypes(); + const t = binary(bitAnd, .{}); + try t.testIntTypes(); + try t.testIntVectorTypes(); } inline fn bitOr(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs | rhs) { return lhs | rhs; } test bitOr { - try Binary(bitOr).testIntTypes(); - try Binary(bitOr).testIntVectorTypes(); + const t = binary(bitOr, .{}); + try t.testIntTypes(); + try t.testIntVectorTypes(); } inline fn bitXor(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs ^ rhs) { return lhs ^ rhs; } test bitXor { - try Binary(bitXor).testIntTypes(); - try Binary(bitXor).testIntVectorTypes(); + const t = binary(bitXor, .{}); + try t.testIntTypes(); + try t.testIntVectorTypes(); } inline fn min(comptime Type: type, lhs: Type, rhs: Type) Type { return @min(lhs, rhs); } test min { - try Binary(min).testIntTypes(); - try Binary(min).testIntVectorTypes(); + const t = binary(min, .{}); + try t.testIntTypes(); + try t.testIntVectorTypes(); + try t.testFloatTypes(); } inline fn max(comptime Type: type, lhs: Type, rhs: Type) Type { return @max(lhs, rhs); } test max { - try Binary(max).testIntTypes(); - try Binary(max).testIntVectorTypes(); + const t = binary(max, .{}); + try t.testIntTypes(); + try t.testIntVectorTypes(); + try t.testFloatTypes(); }