authorgravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2025-02-13 17:28:33-05:00
committergravatar for jacobly@ziglang.orgJacob Young <jacobly@ziglang.org> 2025-02-15 03:45:21-05:00
log8c48376d64391aba5edd0e2c8219537554cf2819
tree58548c76f15cae07fbadfef5faac8ac10b0366af
parent9f121ec8fb07f20413584068105bee3430be3e70

x86_64: rewrite scalar and vector int `@divTrunc`

7 files changed, 2864 insertions(+), 1138 deletions(-)

lib/compiler_rt.zig+1
...@@ -230,6 +230,7 @@ comptime {...@@ -230,6 +230,7 @@ comptime {
230 _ = @import("compiler_rt/trunc.zig");230 _ = @import("compiler_rt/trunc.zig");
231231
232 // BigInt. Alphabetically sorted.232 // BigInt. Alphabetically sorted.
233 _ = @import("compiler_rt/divmodei4.zig");
233 _ = @import("compiler_rt/udivmodei4.zig");234 _ = @import("compiler_rt/udivmodei4.zig");
234 _ = @import("compiler_rt/udivmodti4.zig");235 _ = @import("compiler_rt/udivmodti4.zig");
235236
lib/compiler_rt/divmodei4.zig created+50
...@@ -0,0 +1,50 @@
1const std = @import("std");
2const builtin = @import("builtin");
3const common = @import("common.zig");
4const udivmod = @import("udivmodei4.zig").divmod;
5
6comptime {
7 @export(&__divei4, .{ .name = "__divei4", .linkage = common.linkage, .visibility = common.visibility });
8 @export(&__modei4, .{ .name = "__modei4", .linkage = common.linkage, .visibility = common.visibility });
9}
10
11const endian = builtin.cpu.arch.endian();
12
13inline fn limb(x: []u32, i: usize) *u32 {
14 return if (endian == .little) &x[i] else &x[x.len - 1 - i];
15}
16
17inline fn neg(x: []u32) void {
18 var ov: u1 = 1;
19 for (0..x.len) |limb_index| {
20 const l = limb(x, limb_index);
21 l.*, ov = @addWithOverflow(~l.*, ov);
22 }
23}
24
25/// Mutates the arguments!
26fn divmod(q: ?[]u32, r: ?[]u32, u: []u32, v: []u32) !void {
27 const u_sign: i32 = @bitCast(u[u.len - 1]);
28 const v_sign: i32 = @bitCast(v[v.len - 1]);
29 if (u_sign < 0) neg(u);
30 if (v_sign < 0) neg(v);
31 try @call(.always_inline, udivmod, .{ q, r, u, v });
32 if (q) |x| if (u_sign ^ v_sign < 0) neg(x);
33 if (r) |x| if (u_sign < 0) neg(x);
34}
35
36pub fn __divei4(r_q: [*]u32, u_p: [*]u32, v_p: [*]u32, bits: usize) callconv(.C) void {
37 @setRuntimeSafety(builtin.is_test);
38 const u = u_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
39 const v = v_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
40 const q = r_q[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
41 @call(.always_inline, divmod, .{ q, null, u, v }) catch unreachable;
42}
43
44pub fn __modei4(r_p: [*]u32, u_p: [*]u32, v_p: [*]u32, bits: usize) callconv(.C) void {
45 @setRuntimeSafety(builtin.is_test);
46 const u = u_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
47 const v = v_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
48 const r = r_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
49 @call(.always_inline, divmod, .{ null, r, u, v }) catch unreachable;
50}
lib/compiler_rt/udivmodei4.zig+2-2
...@@ -27,8 +27,8 @@ inline fn limb_set(x: []u32, i: usize, v: u32) void {...@@ -27,8 +27,8 @@ inline fn limb_set(x: []u32, i: usize, v: u32) void {
27 }27 }
28}28}
2929
30// Uses Knuth's Algorithm D, 4.3.1, p. 272.30/// Uses Knuth's Algorithm D, 4.3.1, p. 272.
31fn divmod(q: ?[]u32, r: ?[]u32, u: []const u32, v: []const u32) !void {31pub fn divmod(q: ?[]u32, r: ?[]u32, u: []const u32, v: []const u32) !void {
32 if (q) |q_| @memset(q_[0..], 0);32 if (q) |q_| @memset(q_[0..], 0);
33 if (r) |r_| @memset(r_[0..], 0);33 if (r) |r_| @memset(r_[0..], 0);
3434
src/arch/x86_64/CodeGen.zig+2768-1102
...@@ -2418,7 +2418,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void {...@@ -2418,7 +2418,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
2418}2418}
24192419
2420fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {2420fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
2421 @setEvalBranchQuota(12_200);2421 @setEvalBranchQuota(12_300);
2422 const pt = cg.pt;2422 const pt = cg.pt;
2423 const zcu = pt.zcu;2423 const zcu = pt.zcu;
2424 const ip = &zcu.intern_pool;2424 const ip = &zcu.intern_pool;
...@@ -7785,1068 +7785,1726 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {...@@ -7785,1068 +7785,1726 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
7785 };7785 };
7786 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);7786 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
7787 },7787 },
7788 .div_trunc, .div_floor => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else fallback: {7788 .div_trunc => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else {
7789 const bin_op = air_datas[@intFromEnum(inst)].bin_op;7789 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
7790 if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airMulDivBinOp(inst, air_tag);
7791 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });7790 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
7792 var res: [1]Temp = undefined;7791 var res: [1]Temp = undefined;
7793 cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, switch (@as(bits.RoundMode.Direction, switch (air_tag) {7792 cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
7794 else => unreachable,7793 .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
7795 .div_trunc => .zero,7794 .patterns = &.{
7796 .div_floor => .down,7795 .{ .src = .{ .mem, .mem, .none } },
7797 })) {7796 .{ .src = .{ .to_gpr, .mem, .none } },
7798 else => unreachable,7797 .{ .src = .{ .mem, .to_gpr, .none } },
7799 inline .zero, .down => |direction| comptime &.{ .{7798 .{ .src = .{ .to_gpr, .to_gpr, .none } },
7800 .required_features = .{ .f16c, null, null, null },7799 },
7801 .src_constraints = .{7800 .dst_temps = .{ .{ .reg = .al }, .unused },
7802 .{ .scalar_float = .{ .of = .word, .is = .word } },7801 .clobbers = .{ .eflags = true },
7803 .{ .scalar_float = .{ .of = .word, .is = .word } },7802 .each = .{ .once = &.{
7804 .any,7803 .{ ._, ._, .movsx, .dst0d, .src0b, ._, ._ },
7805 },7804 .{ ._, .i_, .div, .src1b, ._, ._, ._ },
7806 .patterns = &.{7805 } },
7807 .{ .src = .{ .to_sse, .to_sse, .none } },7806 }, .{
7808 },7807 .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
7809 .extra_temps = .{7808 .patterns = &.{
7810 .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },7809 .{ .src = .{ .mem, .mem, .none } },
7811 .unused,7810 .{ .src = .{ .to_gpr, .mem, .none } },
7812 .unused,7811 .{ .src = .{ .mem, .to_gpr, .none } },
7813 .unused,7812 .{ .src = .{ .to_gpr, .to_gpr, .none } },
7814 .unused,7813 },
7815 .unused,7814 .dst_temps = .{ .{ .reg = .al }, .unused },
7816 .unused,7815 .clobbers = .{ .eflags = true },
7817 .unused,7816 .each = .{ .once = &.{
7818 .unused,7817 .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
7819 },7818 .{ ._, ._, .div, .src1b, ._, ._, ._ },
7820 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },7819 } },
7821 .each = .{ .once = &.{7820 }, .{
7822 .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },7821 .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
7823 .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },7822 .patterns = &.{
7824 .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },7823 .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
7825 .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },7824 .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
7826 .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },7825 },
7827 .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) },7826 .extra_temps = .{
7828 .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },7827 .{ .type = .i16, .kind = .{ .reg = .dx } },
7829 } },7828 .unused,
7830 }, .{7829 .unused,
7831 .required_features = .{ .sse, null, null, null },7830 .unused,
7832 .src_constraints = .{7831 .unused,
7833 .{ .scalar_float = .{ .of = .word, .is = .word } },7832 .unused,
7834 .{ .scalar_float = .{ .of = .word, .is = .word } },7833 .unused,
7835 .any,7834 .unused,
7836 },7835 .unused,
7837 .patterns = &.{7836 },
7838 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },7837 .dst_temps = .{ .{ .ref = .src0 }, .unused },
7839 },7838 .clobbers = .{ .eflags = true },
7840 .call_frame = .{ .alignment = .@"16" },7839 .each = .{ .once = &.{
7841 .extra_temps = .{7840 .{ ._, ._, .cwd, ._, ._, ._, ._ },
7842 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },7841 .{ ._, .i_, .div, .src1w, ._, ._, ._ },
7843 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {7842 } },
7844 else => unreachable,7843 }, .{
7845 .zero => "__trunch",7844 .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
7846 .down => "__floorh",7845 .patterns = &.{
7847 } } } },7846 .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
7848 .unused,7847 .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
7849 .unused,7848 },
7850 .unused,7849 .extra_temps = .{
7851 .unused,7850 .{ .type = .u16, .kind = .{ .reg = .dx } },
7852 .unused,7851 .unused,
7853 .unused,7852 .unused,
7854 .unused,7853 .unused,
7855 },7854 .unused,
7856 .dst_temps = .{ .{ .ref = .src0 }, .unused },7855 .unused,
7857 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },7856 .unused,
7858 .each = .{ .once = &.{7857 .unused,
7859 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },7858 .unused,
7860 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },7859 },
7861 } },7860 .dst_temps = .{ .{ .ref = .src0 }, .unused },
7862 }, .{7861 .clobbers = .{ .eflags = true },
7863 .required_features = .{ .f16c, null, null, null },7862 .each = .{ .once = &.{
7864 .src_constraints = .{7863 .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
7865 .{ .scalar_float = .{ .of = .qword, .is = .word } },7864 .{ ._, ._, .div, .src1w, ._, ._, ._ },
7866 .{ .scalar_float = .{ .of = .qword, .is = .word } },7865 } },
7867 .any,7866 }, .{
7868 },7867 .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
7869 .patterns = &.{7868 .patterns = &.{
7870 .{ .src = .{ .mem, .mem, .none } },7869 .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
7871 .{ .src = .{ .to_sse, .mem, .none } },7870 .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
7872 .{ .src = .{ .mem, .to_sse, .none } },7871 },
7873 .{ .src = .{ .to_sse, .to_sse, .none } },7872 .extra_temps = .{
7874 },7873 .{ .type = .i32, .kind = .{ .reg = .edx } },
7875 .extra_temps = .{7874 .unused,
7876 .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },7875 .unused,
7877 .unused,7876 .unused,
7878 .unused,7877 .unused,
7879 .unused,7878 .unused,
7880 .unused,7879 .unused,
7881 .unused,7880 .unused,
7882 .unused,7881 .unused,
7883 .unused,7882 },
7884 .unused,7883 .dst_temps = .{ .{ .ref = .src0 }, .unused },
7885 },7884 .clobbers = .{ .eflags = true },
7886 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },7885 .each = .{ .once = &.{
7887 .each = .{ .once = &.{7886 .{ ._, ._, .cdq, ._, ._, ._, ._ },
7888 .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },7887 .{ ._, .i_, .div, .src1d, ._, ._, ._ },
7889 .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },7888 } },
7890 .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },7889 }, .{
7891 .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },7890 .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
7892 .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },7891 .patterns = &.{
7893 .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },7892 .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
7894 .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },7893 .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
7895 } },7894 },
7896 }, .{7895 .extra_temps = .{
7897 .required_features = .{ .f16c, null, null, null },7896 .{ .type = .u32, .kind = .{ .reg = .edx } },
7898 .src_constraints = .{7897 .unused,
7899 .{ .scalar_float = .{ .of = .xword, .is = .word } },7898 .unused,
7900 .{ .scalar_float = .{ .of = .xword, .is = .word } },7899 .unused,
7901 .any,7900 .unused,
7902 },7901 .unused,
7903 .patterns = &.{7902 .unused,
7904 .{ .src = .{ .mem, .mem, .none } },7903 .unused,
7905 .{ .src = .{ .to_sse, .mem, .none } },7904 .unused,
7906 .{ .src = .{ .mem, .to_sse, .none } },7905 },
7907 .{ .src = .{ .to_sse, .to_sse, .none } },7906 .dst_temps = .{ .{ .ref = .src0 }, .unused },
7908 },7907 .clobbers = .{ .eflags = true },
7909 .extra_temps = .{7908 .each = .{ .once = &.{
7910 .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },7909 .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
7911 .unused,7910 .{ ._, ._, .div, .src1d, ._, ._, ._ },
7912 .unused,7911 } },
7913 .unused,7912 }, .{
7914 .unused,7913 .required_features = .{ .@"64bit", null, null, null },
7915 .unused,7914 .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
7916 .unused,7915 .patterns = &.{
7917 .unused,7916 .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
7918 .unused,7917 .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
7919 },7918 },
7920 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },7919 .extra_temps = .{
7921 .each = .{ .once = &.{7920 .{ .type = .i64, .kind = .{ .reg = .rdx } },
7922 .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },7921 .unused,
7923 .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },7922 .unused,
7924 .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },7923 .unused,
7925 .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },7924 .unused,
7926 .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },7925 .unused,
7927 .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },7926 .unused,
7928 .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },7927 .unused,
7929 } },7928 .unused,
7930 }, .{7929 },
7931 .required_features = .{ .f16c, null, null, null },7930 .dst_temps = .{ .{ .ref = .src0 }, .unused },
7932 .src_constraints = .{7931 .clobbers = .{ .eflags = true },
7933 .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },7932 .each = .{ .once = &.{
7934 .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },7933 .{ ._, ._, .cqo, ._, ._, ._, ._ },
7935 .any,7934 .{ ._, .i_, .div, .src1q, ._, ._, ._ },
7936 },7935 } },
7937 .patterns = &.{7936 }, .{
7938 .{ .src = .{ .to_mem, .to_mem, .none } },7937 .required_features = .{ .@"64bit", null, null, null },
7939 },7938 .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
7940 .extra_temps = .{7939 .patterns = &.{
7941 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },7940 .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
7942 .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },7941 .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
7943 .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },7942 },
7944 .unused,7943 .extra_temps = .{
7945 .unused,7944 .{ .type = .u64, .kind = .{ .reg = .rdx } },
7946 .unused,7945 .unused,
7947 .unused,7946 .unused,
7948 .unused,7947 .unused,
7949 .unused,7948 .unused,
7950 },7949 .unused,
7951 .dst_temps = .{ .mem, .unused },7950 .unused,
7952 .clobbers = .{ .eflags = true },7951 .unused,
7953 .each = .{ .once = &.{7952 .unused,
7954 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },7953 },
7955 .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },7954 .dst_temps = .{ .{ .ref = .src0 }, .unused },
7956 .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },7955 .clobbers = .{ .eflags = true },
7957 .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },7956 .each = .{ .once = &.{
7958 .{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ },7957 .{ ._, ._, .xor, .tmp0q, .tmp0q, ._, ._ },
7959 .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },7958 .{ ._, ._, .div, .src1q, ._, ._, ._ },
7960 .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },7959 } },
7961 .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },7960 }, .{
7962 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },7961 .required_features = .{ .@"64bit", null, null, null },
7963 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },7962 .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
7964 } },7963 .patterns = &.{
7965 }, .{7964 .{ .src = .{
7966 .required_features = .{ .avx, null, null, null },7965 .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 0 } },
7967 .src_constraints = .{7966 .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 2 } },
7968 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },7967 .none,
7969 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
7970 .any,
7971 },
7972 .patterns = &.{
7973 .{ .src = .{ .to_mem, .to_mem, .none } },
7974 },
7975 .call_frame = .{ .alignment = .@"16" },
7976 .extra_temps = .{
7977 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
7978 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
7979 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
7980 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
7981 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
7982 else => unreachable,
7983 .zero => "__trunch",
7984 .down => "__floorh",
7985 } } } },
7986 .unused,
7987 .unused,
7988 .unused,
7989 .unused,
7990 },
7991 .dst_temps = .{ .mem, .unused },
7992 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
7993 .each = .{ .once = &.{
7994 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
7995 .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
7996 .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
7997 .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
7998 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
7999 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8000 .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
8001 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
8002 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8003 } },
8004 }, .{
8005 .required_features = .{ .sse4_1, null, null, null },
8006 .src_constraints = .{
8007 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8008 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8009 .any,
8010 },
8011 .patterns = &.{
8012 .{ .src = .{ .to_mem, .to_mem, .none } },
8013 },
8014 .call_frame = .{ .alignment = .@"16" },
8015 .extra_temps = .{
8016 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8017 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
8018 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
8019 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
8020 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8021 else => unreachable,
8022 .zero => "__trunch",
8023 .down => "__floorh",
8024 } } } },
8025 .unused,
8026 .unused,
8027 .unused,
8028 .unused,
8029 },
8030 .dst_temps = .{ .mem, .unused },
8031 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8032 .each = .{ .once = &.{
8033 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8034 .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
8035 .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
8036 .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
8037 .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
8038 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8039 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8040 .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
8041 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
8042 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8043 } },
8044 }, .{
8045 .required_features = .{ .sse2, null, null, null },
8046 .src_constraints = .{
8047 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8048 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8049 .any,
8050 },
8051 .patterns = &.{
8052 .{ .src = .{ .to_mem, .to_mem, .none } },
8053 },
8054 .call_frame = .{ .alignment = .@"16" },
8055 .extra_temps = .{
8056 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8057 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
8058 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
8059 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
8060 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8061 else => unreachable,
8062 .zero => "__trunch",
8063 .down => "__floorh",
8064 } } } },
8065 .{ .type = .f16, .kind = .{ .reg = .ax } },
8066 .unused,
8067 .unused,
8068 .unused,
8069 },
8070 .dst_temps = .{ .mem, .unused },
8071 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8072 .each = .{ .once = &.{
8073 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8074 .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
8075 .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
8076 .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
8077 .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
8078 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8079 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8080 .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
8081 .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
8082 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
8083 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8084 } },
8085 }, .{
8086 .required_features = .{ .sse, null, null, null },
8087 .src_constraints = .{
8088 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8089 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8090 .any,
8091 },
8092 .patterns = &.{
8093 .{ .src = .{ .to_mem, .to_mem, .none } },
8094 },
8095 .call_frame = .{ .alignment = .@"16" },
8096 .extra_temps = .{
8097 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8098 .{ .type = .f16, .kind = .{ .reg = .ax } },
8099 .{ .type = .f32, .kind = .mem },
8100 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
8101 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
8102 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
8103 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8104 else => unreachable,
8105 .zero => "__trunch",
8106 .down => "__floorh",
8107 } } } },
8108 .unused,
8109 .unused,
8110 },
8111 .dst_temps = .{ .mem, .unused },
8112 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8113 .each = .{ .once = &.{
8114 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8115 .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
8116 .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
8117 .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
8118 .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
8119 .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
8120 .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
8121 .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
8122 .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
8123 .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
8124 .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
8125 .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
8126 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
8127 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8128 } },7968 } },
8129 }, .{7969 },
8130 .required_features = .{ .avx, null, null, null },7970 .call_frame = .{ .alignment = .@"16" },
8131 .src_constraints = .{7971 .extra_temps = .{
8132 .{ .scalar_float = .{ .of = .dword, .is = .dword } },7972 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divti3" } } },
8133 .{ .scalar_float = .{ .of = .dword, .is = .dword } },7973 .unused,
8134 .any,7974 .unused,
8135 },7975 .unused,
8136 .patterns = &.{7976 .unused,
8137 .{ .src = .{ .to_sse, .mem, .none } },7977 .unused,
8138 .{ .src = .{ .to_sse, .to_sse, .none } },7978 .unused,
8139 },7979 .unused,
8140 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },7980 .unused,
8141 .each = .{ .once = &.{7981 },
8142 .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },7982 .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .index = 0 } }, .unused },
8143 .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) },7983 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8144 } },7984 .each = .{ .once = &.{
8145 }, .{7985 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
8146 .required_features = .{ .sse4_1, null, null, null },7986 } },
8147 .src_constraints = .{7987 }, .{
8148 .{ .scalar_float = .{ .of = .dword, .is = .dword } },7988 .required_features = .{ .@"64bit", null, null, null },
8149 .{ .scalar_float = .{ .of = .dword, .is = .dword } },7989 .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
8150 .any,7990 .patterns = &.{
8151 },7991 .{ .src = .{
8152 .patterns = &.{7992 .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 0 } },
8153 .{ .src = .{ .to_mut_sse, .mem, .none } },7993 .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 2 } },
8154 .{ .src = .{ .to_mut_sse, .to_sse, .none } },7994 .none,
8155 },
8156 .dst_temps = .{ .{ .ref = .src0 }, .unused },
8157 .each = .{ .once = &.{
8158 .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
8159 .{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8160 } },
8161 }, .{
8162 .required_features = .{ .sse, null, null, null },
8163 .src_constraints = .{
8164 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
8165 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
8166 .any,
8167 },
8168 .patterns = &.{
8169 .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
8170 },
8171 .call_frame = .{ .alignment = .@"16" },
8172 .extra_temps = .{
8173 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8174 else => unreachable,
8175 .zero => "truncf",
8176 .down => "floorf",
8177 } } } },
8178 .unused,
8179 .unused,
8180 .unused,
8181 .unused,
8182 .unused,
8183 .unused,
8184 .unused,
8185 .unused,
8186 },
8187 .dst_temps = .{ .{ .ref = .src0 }, .unused },
8188 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8189 .each = .{ .once = &.{
8190 .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
8191 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
8192 } },
8193 }, .{
8194 .required_features = .{ .avx, null, null, null },
8195 .src_constraints = .{
8196 .{ .scalar_float = .{ .of = .xword, .is = .dword } },
8197 .{ .scalar_float = .{ .of = .xword, .is = .dword } },
8198 .any,
8199 },
8200 .patterns = &.{
8201 .{ .src = .{ .to_sse, .mem, .none } },
8202 .{ .src = .{ .to_sse, .to_sse, .none } },
8203 },
8204 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8205 .each = .{ .once = &.{
8206 .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
8207 .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8208 } },
8209 }, .{
8210 .required_features = .{ .sse4_1, null, null, null },
8211 .src_constraints = .{
8212 .{ .scalar_float = .{ .of = .xword, .is = .dword } },
8213 .{ .scalar_float = .{ .of = .xword, .is = .dword } },
8214 .any,
8215 },
8216 .patterns = &.{
8217 .{ .src = .{ .to_mut_sse, .mem, .none } },
8218 .{ .src = .{ .to_mut_sse, .to_sse, .none } },
8219 },
8220 .dst_temps = .{ .{ .ref = .src0 }, .unused },
8221 .each = .{ .once = &.{
8222 .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
8223 .{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8224 } },
8225 }, .{
8226 .required_features = .{ .sse, null, null, null },
8227 .src_constraints = .{
8228 .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
8229 .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
8230 .any,
8231 },
8232 .patterns = &.{
8233 .{ .src = .{ .to_mem, .to_mem, .none } },
8234 },
8235 .call_frame = .{ .alignment = .@"16" },
8236 .extra_temps = .{
8237 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8238 .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
8239 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8240 else => unreachable,
8241 .zero => "truncf",
8242 .down => "floorf",
8243 } } } },
8244 .unused,
8245 .unused,
8246 .unused,
8247 .unused,
8248 .unused,
8249 .unused,
8250 },
8251 .dst_temps = .{ .mem, .unused },
8252 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8253 .each = .{ .once = &.{
8254 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8255 .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
8256 .{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
8257 .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
8258 .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8259 .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
8260 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8261 } },
8262 }, .{
8263 .required_features = .{ .avx, null, null, null },
8264 .src_constraints = .{
8265 .{ .scalar_float = .{ .of = .yword, .is = .dword } },
8266 .{ .scalar_float = .{ .of = .yword, .is = .dword } },
8267 .any,
8268 },
8269 .patterns = &.{
8270 .{ .src = .{ .to_sse, .mem, .none } },
8271 .{ .src = .{ .to_sse, .to_sse, .none } },
8272 },
8273 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8274 .each = .{ .once = &.{
8275 .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
8276 .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8277 } },
8278 }, .{
8279 .required_features = .{ .avx, null, null, null },
8280 .src_constraints = .{
8281 .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
8282 .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
8283 .any,
8284 },
8285 .patterns = &.{
8286 .{ .src = .{ .to_mem, .to_mem, .none } },
8287 },
8288 .extra_temps = .{
8289 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8290 .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
8291 .unused,
8292 .unused,
8293 .unused,
8294 .unused,
8295 .unused,
8296 .unused,
8297 .unused,
8298 },
8299 .dst_temps = .{ .mem, .unused },
8300 .clobbers = .{ .eflags = true },
8301 .each = .{ .once = &.{
8302 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8303 .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
8304 .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
8305 .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8306 .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
8307 .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
8308 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8309 } },
8310 }, .{
8311 .required_features = .{ .sse4_1, null, null, null },
8312 .src_constraints = .{
8313 .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
8314 .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
8315 .any,
8316 },
8317 .patterns = &.{
8318 .{ .src = .{ .to_mem, .to_mem, .none } },
8319 },
8320 .extra_temps = .{
8321 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8322 .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
8323 .unused,
8324 .unused,
8325 .unused,
8326 .unused,
8327 .unused,
8328 .unused,
8329 .unused,
8330 },
8331 .dst_temps = .{ .mem, .unused },
8332 .clobbers = .{ .eflags = true },
8333 .each = .{ .once = &.{
8334 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8335 .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
8336 .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
8337 .{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8338 .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8339 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
8340 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8341 } },
8342 }, .{
8343 .required_features = .{ .avx, null, null, null },
8344 .src_constraints = .{
8345 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
8346 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
8347 .any,
8348 },
8349 .patterns = &.{
8350 .{ .src = .{ .to_sse, .mem, .none } },
8351 .{ .src = .{ .to_sse, .to_sse, .none } },
8352 },
8353 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8354 .each = .{ .once = &.{
8355 .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
8356 .{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = direction, .precision = .inexact }) },
8357 } },
8358 }, .{
8359 .required_features = .{ .sse4_1, null, null, null },
8360 .src_constraints = .{
8361 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
8362 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
8363 .any,
8364 },
8365 .patterns = &.{
8366 .{ .src = .{ .to_mut_sse, .mem, .none } },
8367 .{ .src = .{ .to_mut_sse, .to_sse, .none } },
8368 },
8369 .dst_temps = .{ .{ .ref = .src0 }, .unused },
8370 .each = .{ .once = &.{
8371 .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
8372 .{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8373 } },
8374 }, .{
8375 .required_features = .{ .sse2, null, null, null },
8376 .src_constraints = .{
8377 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
8378 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
8379 .any,
8380 },
8381 .patterns = &.{
8382 .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
8383 },
8384 .call_frame = .{ .alignment = .@"16" },
8385 .extra_temps = .{
8386 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8387 else => unreachable,
8388 .zero => "trunc",
8389 .down => "floor",
8390 } } } },
8391 .unused,
8392 .unused,
8393 .unused,
8394 .unused,
8395 .unused,
8396 .unused,
8397 .unused,
8398 .unused,
8399 },
8400 .dst_temps = .{ .{ .ref = .src0 }, .unused },
8401 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8402 .each = .{ .once = &.{
8403 .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
8404 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
8405 } },
8406 }, .{
8407 .required_features = .{ .sse, null, null, null },
8408 .src_constraints = .{
8409 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
8410 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
8411 .any,
8412 },
8413 .patterns = &.{
8414 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
8415 },
8416 .call_frame = .{ .alignment = .@"16" },
8417 .extra_temps = .{
8418 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
8419 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8420 else => unreachable,
8421 .zero => "trunc",
8422 .down => "floor",
8423 } } } },
8424 .unused,
8425 .unused,
8426 .unused,
8427 .unused,
8428 .unused,
8429 .unused,
8430 .unused,
8431 },
8432 .dst_temps = .{ .{ .ref = .src0 }, .unused },
8433 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8434 .each = .{ .once = &.{
8435 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
8436 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
8437 } },
8438 }, .{
8439 .required_features = .{ .avx, null, null, null },
8440 .src_constraints = .{
8441 .{ .scalar_float = .{ .of = .xword, .is = .qword } },
8442 .{ .scalar_float = .{ .of = .xword, .is = .qword } },
8443 .any,
8444 },
8445 .patterns = &.{
8446 .{ .src = .{ .to_sse, .mem, .none } },
8447 .{ .src = .{ .to_sse, .to_sse, .none } },
8448 },
8449 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8450 .each = .{ .once = &.{
8451 .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
8452 .{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8453 } },
8454 }, .{
8455 .required_features = .{ .sse4_1, null, null, null },
8456 .src_constraints = .{
8457 .{ .scalar_float = .{ .of = .xword, .is = .qword } },
8458 .{ .scalar_float = .{ .of = .xword, .is = .qword } },
8459 .any,
8460 },
8461 .patterns = &.{
8462 .{ .src = .{ .to_mut_sse, .mem, .none } },
8463 .{ .src = .{ .to_mut_sse, .to_sse, .none } },
8464 },
8465 .dst_temps = .{ .{ .ref = .src0 }, .unused },
8466 .each = .{ .once = &.{
8467 .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
8468 .{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8469 } },
8470 }, .{
8471 .required_features = .{ .avx, null, null, null },
8472 .src_constraints = .{
8473 .{ .scalar_float = .{ .of = .yword, .is = .qword } },
8474 .{ .scalar_float = .{ .of = .yword, .is = .qword } },
8475 .any,
8476 },
8477 .patterns = &.{
8478 .{ .src = .{ .to_sse, .mem, .none } },
8479 .{ .src = .{ .to_sse, .to_sse, .none } },
8480 },
8481 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8482 .each = .{ .once = &.{
8483 .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
8484 .{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8485 } },
8486 }, .{
8487 .required_features = .{ .avx, null, null, null },
8488 .src_constraints = .{
8489 .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
8490 .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
8491 .any,
8492 },
8493 .patterns = &.{
8494 .{ .src = .{ .to_mem, .to_mem, .none } },
8495 },
8496 .extra_temps = .{
8497 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8498 .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
8499 .unused,
8500 .unused,
8501 .unused,
8502 .unused,
8503 .unused,
8504 .unused,
8505 .unused,
8506 },
8507 .dst_temps = .{ .mem, .unused },
8508 .clobbers = .{ .eflags = true },
8509 .each = .{ .once = &.{
8510 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8511 .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
8512 .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
8513 .{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8514 .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
8515 .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
8516 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8517 } },
8518 }, .{
8519 .required_features = .{ .sse4_1, null, null, null },
8520 .src_constraints = .{
8521 .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
8522 .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
8523 .any,
8524 },
8525 .patterns = &.{
8526 .{ .src = .{ .to_mem, .to_mem, .none } },
8527 },
8528 .extra_temps = .{
8529 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8530 .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
8531 .unused,
8532 .unused,
8533 .unused,
8534 .unused,
8535 .unused,
8536 .unused,
8537 .unused,
8538 },
8539 .dst_temps = .{ .mem, .unused },
8540 .clobbers = .{ .eflags = true },
8541 .each = .{ .once = &.{
8542 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8543 .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
8544 .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
8545 .{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
8546 .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8547 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
8548 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8549 } },
8550 }, .{
8551 .required_features = .{ .sse2, null, null, null },
8552 .src_constraints = .{
8553 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
8554 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
8555 .any,
8556 },
8557 .patterns = &.{
8558 .{ .src = .{ .to_mem, .to_mem, .none } },
8559 },
8560 .call_frame = .{ .alignment = .@"16" },
8561 .extra_temps = .{
8562 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8563 .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
8564 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8565 else => unreachable,
8566 .zero => "trunc",
8567 .down => "floor",
8568 } } } },
8569 .unused,
8570 .unused,
8571 .unused,
8572 .unused,
8573 .unused,
8574 .unused,
8575 },
8576 .dst_temps = .{ .mem, .unused },
8577 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8578 .each = .{ .once = &.{
8579 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8580 .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
8581 .{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
8582 .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
8583 .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8584 .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
8585 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8586 } },
8587 }, .{
8588 .required_features = .{ .sse, null, null, null },
8589 .src_constraints = .{
8590 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
8591 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
8592 .any,
8593 },
8594 .patterns = &.{
8595 .{ .src = .{ .to_mem, .to_mem, .none } },
8596 },
8597 .call_frame = .{ .alignment = .@"16" },
8598 .extra_temps = .{
8599 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8600 .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
8601 .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
8602 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
8603 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8604 else => unreachable,
8605 .zero => "trunc",
8606 .down => "floor",
8607 } } } },
8608 .unused,
8609 .unused,
8610 .unused,
8611 .unused,
8612 },
8613 .dst_temps = .{ .mem, .unused },
8614 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8615 .each = .{ .once = &.{
8616 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8617 .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
8618 .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
8619 .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
8620 .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
8621 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8622 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8623 .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8624 .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
8625 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8626 } },
8627 }, .{
8628 .required_features = .{ .x87, null, null, null },
8629 .src_constraints = .{
8630 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
8631 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
8632 .any,
8633 },
8634 .patterns = &.{
8635 .{ .src = .{ .to_mem, .to_mem, .none } },
8636 },
8637 .call_frame = .{ .size = 16, .alignment = .@"16" },
8638 .extra_temps = .{
8639 .{ .type = .f80, .kind = .{ .reg = .st6 } },
8640 .{ .type = .f80, .kind = .{ .reg = .st7 } },
8641 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
8642 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8643 else => unreachable,
8644 .zero => "__truncx",
8645 .down => "__floorx",
8646 } } } },
8647 .unused,
8648 .unused,
8649 .unused,
8650 .unused,
8651 .unused,
8652 },
8653 .dst_temps = .{ .{ .reg = .st0 }, .unused },
8654 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8655 .each = .{ .once = &.{
8656 .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
8657 .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
8658 .{ ._, .f_p, .div, ._, ._, ._, ._ },
8659 .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
8660 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8661 } },
8662 }, .{
8663 .required_features = .{ .x87, null, null, null },
8664 .src_constraints = .{
8665 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
8666 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
8667 .any,
8668 },
8669 .patterns = &.{
8670 .{ .src = .{ .to_mem, .to_mem, .none } },
8671 },
8672 .call_frame = .{ .size = 16, .alignment = .@"16" },
8673 .extra_temps = .{
8674 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8675 .{ .type = .f80, .kind = .{ .reg = .st6 } },
8676 .{ .type = .f80, .kind = .{ .reg = .st7 } },
8677 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
8678 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8679 else => unreachable,
8680 .zero => "__truncx",
8681 .down => "__floorx",
8682 } } } },
8683 .unused,
8684 .unused,
8685 .unused,
8686 .unused,
8687 },
8688 .dst_temps = .{ .mem, .unused },
8689 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8690 .each = .{ .once = &.{
8691 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8692 .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
8693 .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
8694 .{ ._, .f_p, .div, ._, ._, ._, ._ },
8695 .{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ },
8696 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8697 .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
8698 .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
8699 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
8700 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8701 } },
8702 }, .{
8703 .required_features = .{ .sse, null, null, null },
8704 .src_constraints = .{
8705 .{ .scalar_float = .{ .of = .xword, .is = .xword } },
8706 .{ .scalar_float = .{ .of = .xword, .is = .xword } },
8707 .any,
8708 },
8709 .patterns = &.{
8710 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
8711 },
8712 .call_frame = .{ .alignment = .@"16" },
8713 .extra_temps = .{
8714 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
8715 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8716 else => unreachable,
8717 .zero => "truncq",
8718 .down => "floorq",
8719 } } } },
8720 .unused,
8721 .unused,
8722 .unused,
8723 .unused,
8724 .unused,
8725 .unused,
8726 .unused,
8727 },
8728 .dst_temps = .{ .{ .ref = .src0 }, .unused },
8729 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8730 .each = .{ .once = &.{
8731 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
8732 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
8733 } },
8734 }, .{
8735 .required_features = .{ .avx, null, null, null },
8736 .src_constraints = .{
8737 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
8738 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
8739 .any,
8740 },
8741 .patterns = &.{
8742 .{ .src = .{ .to_mem, .to_mem, .none } },
8743 },
8744 .call_frame = .{ .alignment = .@"16" },
8745 .extra_temps = .{
8746 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8747 .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
8748 .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
8749 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
8750 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8751 else => unreachable,
8752 .zero => "truncq",
8753 .down => "floorq",
8754 } } } },
8755 .unused,
8756 .unused,
8757 .unused,
8758 .unused,
8759 },
8760 .dst_temps = .{ .mem, .unused },
8761 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8762 .each = .{ .once = &.{
8763 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8764 .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
8765 .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
8766 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8767 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8768 .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8769 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
8770 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8771 } },
8772 }, .{
8773 .required_features = .{ .sse2, null, null, null },
8774 .src_constraints = .{
8775 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
8776 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
8777 .any,
8778 },
8779 .patterns = &.{
8780 .{ .src = .{ .to_mem, .to_mem, .none } },
8781 },
8782 .call_frame = .{ .alignment = .@"16" },
8783 .extra_temps = .{
8784 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8785 .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
8786 .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
8787 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
8788 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8789 else => unreachable,
8790 .zero => "truncq",
8791 .down => "floorq",
8792 } } } },
8793 .unused,
8794 .unused,
8795 .unused,
8796 .unused,
8797 },
8798 .dst_temps = .{ .mem, .unused },
8799 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8800 .each = .{ .once = &.{
8801 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8802 .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
8803 .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
8804 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8805 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8806 .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8807 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
8808 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8809 } },
8810 }, .{
8811 .required_features = .{ .sse, null, null, null },
8812 .src_constraints = .{
8813 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
8814 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
8815 .any,
8816 },
8817 .patterns = &.{
8818 .{ .src = .{ .to_mem, .to_mem, .none } },
8819 },
8820 .call_frame = .{ .alignment = .@"16" },
8821 .extra_temps = .{
8822 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8823 .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
8824 .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
8825 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
8826 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
8827 else => unreachable,
8828 .zero => "truncq",
8829 .down => "floorq",
8830 } } } },
8831 .unused,
8832 .unused,
8833 .unused,
8834 .unused,
8835 },
8836 .dst_temps = .{ .mem, .unused },
8837 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8838 .each = .{ .once = &.{
8839 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8840 .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
8841 .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
8842 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8843 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8844 .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8845 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
8846 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8847 } },7995 } },
7996 },
7997 .call_frame = .{ .alignment = .@"16" },
7998 .extra_temps = .{
7999 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivti3" } } },
8000 .unused,
8001 .unused,
8002 .unused,
8003 .unused,
8004 .unused,
8005 .unused,
8006 .unused,
8007 .unused,
8008 },
8009 .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .index = 0 } }, .unused },
8010 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8011 .each = .{ .once = &.{
8012 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
8013 } },
8014 }, .{
8015 .required_features = .{ .@"64bit", null, null, null },
8016 .src_constraints = .{
8017 .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
8018 .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
8019 .any,
8020 },
8021 .patterns = &.{
8022 .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
8023 },
8024 .call_frame = .{ .alignment = .@"16" },
8025 .extra_temps = .{
8026 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
8027 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
8028 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
8029 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
8030 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divei4" } } },
8031 .unused,
8032 .unused,
8033 .unused,
8034 .unused,
8035 },
8036 .dst_temps = .{ .mem, .unused },
8037 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8038 .each = .{ .once = &.{
8039 .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
8040 .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
8041 .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
8042 .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ },
8043 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8044 } },
8045 }, .{
8046 .required_features = .{ .@"64bit", null, null, null },
8047 .src_constraints = .{
8048 .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
8049 .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
8050 .any,
8051 },
8052 .patterns = &.{
8053 .{ .src = .{ .to_mem, .to_mem, .none } },
8054 },
8055 .call_frame = .{ .alignment = .@"16" },
8056 .extra_temps = .{
8057 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
8058 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
8059 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
8060 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
8061 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivei4" } } },
8062 .unused,
8063 .unused,
8064 .unused,
8065 .unused,
8066 },
8067 .dst_temps = .{ .mem, .unused },
8068 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8069 .each = .{ .once = &.{
8070 .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
8071 .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
8072 .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
8073 .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ },
8074 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8075 } },
8076 }, .{
8077 .required_features = .{ .slow_incdec, null, null, null },
8078 .src_constraints = .{
8079 .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
8080 .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
8081 .any,
8082 },
8083 .patterns = &.{
8084 .{ .src = .{ .to_mem, .to_mem, .none } },
8085 },
8086 .extra_temps = .{
8087 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8088 .{ .type = .i8, .kind = .{ .reg = .al } },
8089 .unused,
8090 .unused,
8091 .unused,
8092 .unused,
8093 .unused,
8094 .unused,
8095 .unused,
8096 },
8097 .dst_temps = .{ .mem, .unused },
8098 .clobbers = .{ .eflags = true },
8099 .each = .{ .once = &.{
8100 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8101 .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
8102 .{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
8103 .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
8104 .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
8105 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8106 } },
8107 }, .{
8108 .src_constraints = .{
8109 .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
8110 .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
8111 .any,
8112 },
8113 .patterns = &.{
8114 .{ .src = .{ .to_mem, .to_mem, .none } },
8115 },
8116 .extra_temps = .{
8117 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8118 .{ .type = .i8, .kind = .{ .reg = .al } },
8119 .unused,
8120 .unused,
8121 .unused,
8122 .unused,
8123 .unused,
8124 .unused,
8125 .unused,
8126 },
8127 .dst_temps = .{ .mem, .unused },
8128 .clobbers = .{ .eflags = true },
8129 .each = .{ .once = &.{
8130 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8131 .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
8132 .{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
8133 .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
8134 .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
8135 .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
8136 } },
8137 }, .{
8138 .required_features = .{ .slow_incdec, null, null, null },
8139 .src_constraints = .{
8140 .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
8141 .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
8142 .any,
8143 },
8144 .patterns = &.{
8145 .{ .src = .{ .to_mem, .to_mem, .none } },
8146 },
8147 .extra_temps = .{
8148 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8149 .{ .type = .u8, .kind = .{ .reg = .al } },
8150 .unused,
8151 .unused,
8152 .unused,
8153 .unused,
8154 .unused,
8155 .unused,
8156 .unused,
8157 },
8158 .dst_temps = .{ .mem, .unused },
8159 .clobbers = .{ .eflags = true },
8160 .each = .{ .once = &.{
8161 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8162 .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
8163 .{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
8164 .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
8165 .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
8166 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8167 } },
8168 }, .{
8169 .src_constraints = .{
8170 .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
8171 .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
8172 .any,
8173 },
8174 .patterns = &.{
8175 .{ .src = .{ .to_mem, .to_mem, .none } },
8176 },
8177 .extra_temps = .{
8178 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8179 .{ .type = .u8, .kind = .{ .reg = .al } },
8180 .unused,
8181 .unused,
8182 .unused,
8183 .unused,
8184 .unused,
8185 .unused,
8186 .unused,
8187 },
8188 .dst_temps = .{ .mem, .unused },
8189 .clobbers = .{ .eflags = true },
8190 .each = .{ .once = &.{
8191 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8192 .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
8193 .{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
8194 .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
8195 .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
8196 .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
8197 } },
8198 }, .{
8199 .src_constraints = .{
8200 .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
8201 .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
8202 .any,
8203 },
8204 .patterns = &.{
8205 .{ .src = .{ .to_mem, .to_mem, .none } },
8206 },
8207 .extra_temps = .{
8208 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8209 .{ .type = .i16, .kind = .{ .reg = .ax } },
8210 .{ .type = .i16, .kind = .{ .reg = .dx } },
8211 .unused,
8212 .unused,
8213 .unused,
8214 .unused,
8215 .unused,
8216 .unused,
8217 },
8218 .dst_temps = .{ .mem, .unused },
8219 .clobbers = .{ .eflags = true },
8220 .each = .{ .once = &.{
8221 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8222 .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
8223 .{ ._, ._, .cwd, ._, ._, ._, ._ },
8224 .{ ._, .i_, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ },
8225 .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
8226 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
8227 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8228 } },
8229 }, .{
8230 .src_constraints = .{
8231 .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
8232 .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
8233 .any,
8234 },
8235 .patterns = &.{
8236 .{ .src = .{ .to_mem, .to_mem, .none } },
8237 },
8238 .extra_temps = .{
8239 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8240 .{ .type = .u16, .kind = .{ .reg = .ax } },
8241 .{ .type = .u16, .kind = .{ .reg = .dx } },
8242 .unused,
8243 .unused,
8244 .unused,
8245 .unused,
8246 .unused,
8247 .unused,
8248 },
8249 .dst_temps = .{ .mem, .unused },
8250 .clobbers = .{ .eflags = true },
8251 .each = .{ .once = &.{
8252 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8253 .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
8254 .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
8255 .{ ._, ._, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ },
8256 .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
8257 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
8258 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8259 } },
8260 }, .{
8261 .src_constraints = .{
8262 .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
8263 .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
8264 .any,
8265 },
8266 .patterns = &.{
8267 .{ .src = .{ .to_mem, .to_mem, .none } },
8268 },
8269 .extra_temps = .{
8270 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8271 .{ .type = .i32, .kind = .{ .reg = .eax } },
8272 .{ .type = .i32, .kind = .{ .reg = .edx } },
8273 .unused,
8274 .unused,
8275 .unused,
8276 .unused,
8277 .unused,
8278 .unused,
8279 },
8280 .dst_temps = .{ .mem, .unused },
8281 .clobbers = .{ .eflags = true },
8282 .each = .{ .once = &.{
8283 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8284 .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
8285 .{ ._, ._, .cdq, ._, ._, ._, ._ },
8286 .{ ._, .i_, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ },
8287 .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
8288 .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
8289 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8290 } },
8291 }, .{
8292 .src_constraints = .{
8293 .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
8294 .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
8295 .any,
8296 },
8297 .patterns = &.{
8298 .{ .src = .{ .to_mem, .to_mem, .none } },
8299 },
8300 .extra_temps = .{
8301 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8302 .{ .type = .u32, .kind = .{ .reg = .eax } },
8303 .{ .type = .u32, .kind = .{ .reg = .edx } },
8304 .unused,
8305 .unused,
8306 .unused,
8307 .unused,
8308 .unused,
8309 .unused,
8310 },
8311 .dst_temps = .{ .mem, .unused },
8312 .clobbers = .{ .eflags = true },
8313 .each = .{ .once = &.{
8314 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8315 .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
8316 .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
8317 .{ ._, ._, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ },
8318 .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
8319 .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
8320 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8321 } },
8322 }, .{
8323 .required_features = .{ .@"64bit", null, null, null },
8324 .src_constraints = .{
8325 .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
8326 .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
8327 .any,
8328 },
8329 .patterns = &.{
8330 .{ .src = .{ .to_mem, .to_mem, .none } },
8331 },
8332 .extra_temps = .{
8333 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8334 .{ .type = .i64, .kind = .{ .reg = .rax } },
8335 .{ .type = .i64, .kind = .{ .reg = .rdx } },
8336 .unused,
8337 .unused,
8338 .unused,
8339 .unused,
8340 .unused,
8341 .unused,
8342 },
8343 .dst_temps = .{ .mem, .unused },
8344 .clobbers = .{ .eflags = true },
8345 .each = .{ .once = &.{
8346 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8347 .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
8348 .{ ._, ._, .cqo, ._, ._, ._, ._ },
8349 .{ ._, .i_, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
8350 .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
8351 .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
8352 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8353 } },
8354 }, .{
8355 .required_features = .{ .@"64bit", null, null, null },
8356 .src_constraints = .{
8357 .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
8358 .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
8359 .any,
8360 },
8361 .patterns = &.{
8362 .{ .src = .{ .to_mem, .to_mem, .none } },
8363 },
8364 .extra_temps = .{
8365 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8366 .{ .type = .u64, .kind = .{ .reg = .rax } },
8367 .{ .type = .u64, .kind = .{ .reg = .rdx } },
8368 .unused,
8369 .unused,
8370 .unused,
8371 .unused,
8372 .unused,
8373 .unused,
8374 },
8375 .dst_temps = .{ .mem, .unused },
8376 .clobbers = .{ .eflags = true },
8377 .each = .{ .once = &.{
8378 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8379 .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
8380 .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
8381 .{ ._, ._, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
8382 .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
8383 .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
8384 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8385 } },
8386 }, .{
8387 .required_features = .{ .@"64bit", null, null, null },
8388 .src_constraints = .{
8389 .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
8390 .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
8391 .any,
8392 },
8393 .patterns = &.{
8394 .{ .src = .{ .to_mem, .to_mem, .none } },
8395 },
8396 .call_frame = .{ .alignment = .@"16" },
8397 .extra_temps = .{
8398 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8399 .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
8400 .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
8401 .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
8402 .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
8403 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divti3" } } },
8404 .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .index = 0 } } },
8405 .unused,
8406 .unused,
8407 },
8408 .dst_temps = .{ .mem, .unused },
8409 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8410 .each = .{ .once = &.{
8411 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8412 .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
8413 .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
8414 .{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
8415 .{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
8416 .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
8417 .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ },
8418 .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ },
8419 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
8420 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8421 } },
8422 }, .{
8423 .required_features = .{ .@"64bit", null, null, null },
8424 .src_constraints = .{
8425 .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
8426 .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
8427 .any,
8428 },
8429 .patterns = &.{
8430 .{ .src = .{ .to_mem, .to_mem, .none } },
8431 },
8432 .call_frame = .{ .alignment = .@"16" },
8433 .extra_temps = .{
8434 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8435 .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
8436 .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
8437 .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
8438 .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
8439 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivti3" } } },
8440 .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .index = 0 } } },
8441 .unused,
8442 .unused,
8443 },
8444 .dst_temps = .{ .mem, .unused },
8445 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8446 .each = .{ .once = &.{
8447 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8448 .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
8449 .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
8450 .{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
8451 .{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
8452 .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
8453 .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ },
8454 .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ },
8455 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
8456 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8457 } },
8458 }, .{
8459 .required_features = .{ .@"64bit", null, null, null },
8460 .src_constraints = .{
8461 .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } },
8462 .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } },
8463 .any,
8464 },
8465 .patterns = &.{
8466 .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
8467 },
8468 .call_frame = .{ .alignment = .@"16" },
8469 .extra_temps = .{
8470 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8471 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
8472 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
8473 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
8474 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
8475 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divei4" } } },
8476 .unused,
8477 .unused,
8478 .unused,
8479 },
8480 .dst_temps = .{ .mem, .unused },
8481 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8482 .each = .{ .once = &.{
8483 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8484 .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
8485 .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
8486 .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
8487 .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ },
8488 .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
8489 .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
8490 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8491 } },
8492 }, .{
8493 .required_features = .{ .@"64bit", null, null, null },
8494 .src_constraints = .{
8495 .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
8496 .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
8497 .any,
8498 },
8499 .patterns = &.{
8500 .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
8501 },
8502 .call_frame = .{ .alignment = .@"16" },
8503 .extra_temps = .{
8504 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8505 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
8506 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
8507 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
8508 .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
8509 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivei4" } } },
8510 .unused,
8511 .unused,
8512 .unused,
8513 },
8514 .dst_temps = .{ .mem, .unused },
8515 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8516 .each = .{ .once = &.{
8517 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8518 .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
8519 .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
8520 .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
8521 .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ },
8522 .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
8523 .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
8524 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8525 } },
8526 }, .{
8527 .required_features = .{ .f16c, null, null, null },
8528 .src_constraints = .{
8529 .{ .scalar_float = .{ .of = .word, .is = .word } },
8530 .{ .scalar_float = .{ .of = .word, .is = .word } },
8531 .any,
8532 },
8533 .patterns = &.{
8534 .{ .src = .{ .to_sse, .to_sse, .none } },
8535 },
8536 .extra_temps = .{
8537 .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
8538 .unused,
8539 .unused,
8540 .unused,
8541 .unused,
8542 .unused,
8543 .unused,
8544 .unused,
8545 .unused,
8546 },
8547 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8548 .each = .{ .once = &.{
8549 .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
8550 .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
8551 .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },
8552 .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
8553 .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
8554 .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .zero, .precision = .inexact }) },
8555 .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
8556 } },
8557 }, .{
8558 .required_features = .{ .sse, null, null, null },
8559 .src_constraints = .{
8560 .{ .scalar_float = .{ .of = .word, .is = .word } },
8561 .{ .scalar_float = .{ .of = .word, .is = .word } },
8562 .any,
8563 },
8564 .patterns = &.{
8565 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
8566 },
8567 .call_frame = .{ .alignment = .@"16" },
8568 .extra_temps = .{
8569 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
8570 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
8571 .unused,
8572 .unused,
8573 .unused,
8574 .unused,
8575 .unused,
8576 .unused,
8577 .unused,
8578 },
8579 .dst_temps = .{ .{ .ref = .src0 }, .unused },
8580 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8581 .each = .{ .once = &.{
8582 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
8583 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
8584 } },
8585 }, .{
8586 .required_features = .{ .f16c, null, null, null },
8587 .src_constraints = .{
8588 .{ .scalar_float = .{ .of = .qword, .is = .word } },
8589 .{ .scalar_float = .{ .of = .qword, .is = .word } },
8590 .any,
8591 },
8592 .patterns = &.{
8593 .{ .src = .{ .mem, .mem, .none } },
8594 .{ .src = .{ .to_sse, .mem, .none } },
8595 .{ .src = .{ .mem, .to_sse, .none } },
8596 .{ .src = .{ .to_sse, .to_sse, .none } },
8597 },
8598 .extra_temps = .{
8599 .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
8600 .unused,
8601 .unused,
8602 .unused,
8603 .unused,
8604 .unused,
8605 .unused,
8606 .unused,
8607 .unused,
8608 },
8609 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8610 .each = .{ .once = &.{
8611 .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
8612 .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
8613 .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },
8614 .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
8615 .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
8616 .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
8617 .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
8618 } },
8619 }, .{
8620 .required_features = .{ .f16c, null, null, null },
8621 .src_constraints = .{
8622 .{ .scalar_float = .{ .of = .xword, .is = .word } },
8623 .{ .scalar_float = .{ .of = .xword, .is = .word } },
8624 .any,
8625 },
8626 .patterns = &.{
8627 .{ .src = .{ .mem, .mem, .none } },
8628 .{ .src = .{ .to_sse, .mem, .none } },
8629 .{ .src = .{ .mem, .to_sse, .none } },
8630 .{ .src = .{ .to_sse, .to_sse, .none } },
8631 },
8632 .extra_temps = .{
8633 .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
8634 .unused,
8635 .unused,
8636 .unused,
8637 .unused,
8638 .unused,
8639 .unused,
8640 .unused,
8641 .unused,
8642 },
8643 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8644 .each = .{ .once = &.{
8645 .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
8646 .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
8647 .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },
8648 .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
8649 .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
8650 .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
8651 .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
8652 } },
8653 }, .{
8654 .required_features = .{ .f16c, null, null, null },
8655 .src_constraints = .{
8656 .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
8657 .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
8658 .any,
8659 },
8660 .patterns = &.{
8661 .{ .src = .{ .to_mem, .to_mem, .none } },
8662 },
8663 .extra_temps = .{
8664 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8665 .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
8666 .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
8667 .unused,
8668 .unused,
8669 .unused,
8670 .unused,
8671 .unused,
8672 .unused,
8673 },
8674 .dst_temps = .{ .mem, .unused },
8675 .clobbers = .{ .eflags = true },
8676 .each = .{ .once = &.{
8677 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8678 .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
8679 .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
8680 .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },
8681 .{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ },
8682 .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
8683 .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
8684 .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
8685 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
8686 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8687 } },
8688 }, .{
8689 .required_features = .{ .avx, null, null, null },
8690 .src_constraints = .{
8691 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8692 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8693 .any,
8694 },
8695 .patterns = &.{
8696 .{ .src = .{ .to_mem, .to_mem, .none } },
8697 },
8698 .call_frame = .{ .alignment = .@"16" },
8699 .extra_temps = .{
8700 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8701 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
8702 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
8703 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
8704 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
8705 .unused,
8706 .unused,
8707 .unused,
8708 .unused,
8709 },
8710 .dst_temps = .{ .mem, .unused },
8711 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8712 .each = .{ .once = &.{
8713 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8714 .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
8715 .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
8716 .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
8717 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8718 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8719 .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
8720 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
8721 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8722 } },
8723 }, .{
8724 .required_features = .{ .sse4_1, null, null, null },
8725 .src_constraints = .{
8726 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8727 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8728 .any,
8729 },
8730 .patterns = &.{
8731 .{ .src = .{ .to_mem, .to_mem, .none } },
8732 },
8733 .call_frame = .{ .alignment = .@"16" },
8734 .extra_temps = .{
8735 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8736 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
8737 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
8738 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
8739 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
8740 .unused,
8741 .unused,
8742 .unused,
8743 .unused,
8744 },
8745 .dst_temps = .{ .mem, .unused },
8746 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8747 .each = .{ .once = &.{
8748 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8749 .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
8750 .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
8751 .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
8752 .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
8753 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8754 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8755 .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
8756 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
8757 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8758 } },
8759 }, .{
8760 .required_features = .{ .sse2, null, null, null },
8761 .src_constraints = .{
8762 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8763 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8764 .any,
8765 },
8766 .patterns = &.{
8767 .{ .src = .{ .to_mem, .to_mem, .none } },
8768 },
8769 .call_frame = .{ .alignment = .@"16" },
8770 .extra_temps = .{
8771 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8772 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
8773 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
8774 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
8775 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
8776 .{ .type = .f16, .kind = .{ .reg = .ax } },
8777 .unused,
8778 .unused,
8779 .unused,
8780 },
8781 .dst_temps = .{ .mem, .unused },
8782 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8783 .each = .{ .once = &.{
8784 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8785 .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
8786 .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
8787 .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
8788 .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
8789 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
8790 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
8791 .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
8792 .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
8793 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
8794 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8795 } },
8796 }, .{
8797 .required_features = .{ .sse, null, null, null },
8798 .src_constraints = .{
8799 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8800 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
8801 .any,
8802 },
8803 .patterns = &.{
8804 .{ .src = .{ .to_mem, .to_mem, .none } },
8805 },
8806 .call_frame = .{ .alignment = .@"16" },
8807 .extra_temps = .{
8808 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8809 .{ .type = .f16, .kind = .{ .reg = .ax } },
8810 .{ .type = .f32, .kind = .mem },
8811 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
8812 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
8813 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
8814 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
8815 .unused,
8816 .unused,
8817 },
8818 .dst_temps = .{ .mem, .unused },
8819 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8820 .each = .{ .once = &.{
8821 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8822 .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
8823 .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
8824 .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
8825 .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
8826 .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
8827 .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
8828 .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
8829 .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
8830 .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
8831 .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
8832 .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
8833 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
8834 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8835 } },
8836 }, .{
8837 .required_features = .{ .avx, null, null, null },
8838 .src_constraints = .{
8839 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
8840 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
8841 .any,
8842 },
8843 .patterns = &.{
8844 .{ .src = .{ .to_sse, .mem, .none } },
8845 .{ .src = .{ .to_sse, .to_sse, .none } },
8846 },
8847 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8848 .each = .{ .once = &.{
8849 .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },
8850 .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .zero, .precision = .inexact }) },
8851 } },
8852 }, .{
8853 .required_features = .{ .sse4_1, null, null, null },
8854 .src_constraints = .{
8855 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
8856 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
8857 .any,
8858 },
8859 .patterns = &.{
8860 .{ .src = .{ .to_mut_sse, .mem, .none } },
8861 .{ .src = .{ .to_mut_sse, .to_sse, .none } },
8862 },
8863 .dst_temps = .{ .{ .ref = .src0 }, .unused },
8864 .each = .{ .once = &.{
8865 .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
8866 .{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
8867 } },
8868 }, .{
8869 .required_features = .{ .sse, null, null, null },
8870 .src_constraints = .{
8871 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
8872 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
8873 .any,
8874 },
8875 .patterns = &.{
8876 .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
8877 },
8878 .call_frame = .{ .alignment = .@"16" },
8879 .extra_temps = .{
8880 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncf" } } },
8881 .unused,
8882 .unused,
8883 .unused,
8884 .unused,
8885 .unused,
8886 .unused,
8887 .unused,
8888 .unused,
8889 },
8890 .dst_temps = .{ .{ .ref = .src0 }, .unused },
8891 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8892 .each = .{ .once = &.{
8893 .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
8894 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
8895 } },
8896 }, .{
8897 .required_features = .{ .avx, null, null, null },
8898 .src_constraints = .{
8899 .{ .scalar_float = .{ .of = .xword, .is = .dword } },
8900 .{ .scalar_float = .{ .of = .xword, .is = .dword } },
8901 .any,
8902 },
8903 .patterns = &.{
8904 .{ .src = .{ .to_sse, .mem, .none } },
8905 .{ .src = .{ .to_sse, .to_sse, .none } },
8906 },
8907 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8908 .each = .{ .once = &.{
8909 .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
8910 .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
8911 } },
8912 }, .{
8913 .required_features = .{ .sse4_1, null, null, null },
8914 .src_constraints = .{
8915 .{ .scalar_float = .{ .of = .xword, .is = .dword } },
8916 .{ .scalar_float = .{ .of = .xword, .is = .dword } },
8917 .any,
8918 },
8919 .patterns = &.{
8920 .{ .src = .{ .to_mut_sse, .mem, .none } },
8921 .{ .src = .{ .to_mut_sse, .to_sse, .none } },
8922 },
8923 .dst_temps = .{ .{ .ref = .src0 }, .unused },
8924 .each = .{ .once = &.{
8925 .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
8926 .{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
8927 } },
8928 }, .{
8929 .required_features = .{ .sse, null, null, null },
8930 .src_constraints = .{
8931 .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
8932 .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
8933 .any,
8934 },
8935 .patterns = &.{
8936 .{ .src = .{ .to_mem, .to_mem, .none } },
8937 },
8938 .call_frame = .{ .alignment = .@"16" },
8939 .extra_temps = .{
8940 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8941 .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
8942 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncf" } } },
8943 .unused,
8944 .unused,
8945 .unused,
8946 .unused,
8947 .unused,
8948 .unused,
8949 },
8950 .dst_temps = .{ .mem, .unused },
8951 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
8952 .each = .{ .once = &.{
8953 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
8954 .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
8955 .{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
8956 .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
8957 .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
8958 .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
8959 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
8960 } },
8961 }, .{
8962 .required_features = .{ .avx, null, null, null },
8963 .src_constraints = .{
8964 .{ .scalar_float = .{ .of = .yword, .is = .dword } },
8965 .{ .scalar_float = .{ .of = .yword, .is = .dword } },
8966 .any,
8967 },
8968 .patterns = &.{
8969 .{ .src = .{ .to_sse, .mem, .none } },
8970 .{ .src = .{ .to_sse, .to_sse, .none } },
8971 },
8972 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
8973 .each = .{ .once = &.{
8974 .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
8975 .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
8848 } },8976 } },
8849 }) catch |err| switch (err) {8977 }, .{
8978 .required_features = .{ .avx, null, null, null },
8979 .src_constraints = .{
8980 .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
8981 .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
8982 .any,
8983 },
8984 .patterns = &.{
8985 .{ .src = .{ .to_mem, .to_mem, .none } },
8986 },
8987 .extra_temps = .{
8988 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
8989 .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
8990 .unused,
8991 .unused,
8992 .unused,
8993 .unused,
8994 .unused,
8995 .unused,
8996 .unused,
8997 },
8998 .dst_temps = .{ .mem, .unused },
8999 .clobbers = .{ .eflags = true },
9000 .each = .{ .once = &.{
9001 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
9002 .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
9003 .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
9004 .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
9005 .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
9006 .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
9007 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9008 } },
9009 }, .{
9010 .required_features = .{ .sse4_1, null, null, null },
9011 .src_constraints = .{
9012 .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
9013 .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
9014 .any,
9015 },
9016 .patterns = &.{
9017 .{ .src = .{ .to_mem, .to_mem, .none } },
9018 },
9019 .extra_temps = .{
9020 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9021 .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
9022 .unused,
9023 .unused,
9024 .unused,
9025 .unused,
9026 .unused,
9027 .unused,
9028 .unused,
9029 },
9030 .dst_temps = .{ .mem, .unused },
9031 .clobbers = .{ .eflags = true },
9032 .each = .{ .once = &.{
9033 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
9034 .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
9035 .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
9036 .{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
9037 .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
9038 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
9039 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9040 } },
9041 }, .{
9042 .required_features = .{ .avx, null, null, null },
9043 .src_constraints = .{
9044 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
9045 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
9046 .any,
9047 },
9048 .patterns = &.{
9049 .{ .src = .{ .to_sse, .mem, .none } },
9050 .{ .src = .{ .to_sse, .to_sse, .none } },
9051 },
9052 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
9053 .each = .{ .once = &.{
9054 .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
9055 .{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = .zero, .precision = .inexact }) },
9056 } },
9057 }, .{
9058 .required_features = .{ .sse4_1, null, null, null },
9059 .src_constraints = .{
9060 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
9061 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
9062 .any,
9063 },
9064 .patterns = &.{
9065 .{ .src = .{ .to_mut_sse, .mem, .none } },
9066 .{ .src = .{ .to_mut_sse, .to_sse, .none } },
9067 },
9068 .dst_temps = .{ .{ .ref = .src0 }, .unused },
9069 .each = .{ .once = &.{
9070 .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
9071 .{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
9072 } },
9073 }, .{
9074 .required_features = .{ .sse2, null, null, null },
9075 .src_constraints = .{
9076 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
9077 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
9078 .any,
9079 },
9080 .patterns = &.{
9081 .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
9082 },
9083 .call_frame = .{ .alignment = .@"16" },
9084 .extra_temps = .{
9085 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
9086 .unused,
9087 .unused,
9088 .unused,
9089 .unused,
9090 .unused,
9091 .unused,
9092 .unused,
9093 .unused,
9094 },
9095 .dst_temps = .{ .{ .ref = .src0 }, .unused },
9096 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9097 .each = .{ .once = &.{
9098 .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
9099 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
9100 } },
9101 }, .{
9102 .required_features = .{ .sse, null, null, null },
9103 .src_constraints = .{
9104 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
9105 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
9106 .any,
9107 },
9108 .patterns = &.{
9109 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
9110 },
9111 .call_frame = .{ .alignment = .@"16" },
9112 .extra_temps = .{
9113 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
9114 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
9115 .unused,
9116 .unused,
9117 .unused,
9118 .unused,
9119 .unused,
9120 .unused,
9121 .unused,
9122 },
9123 .dst_temps = .{ .{ .ref = .src0 }, .unused },
9124 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9125 .each = .{ .once = &.{
9126 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
9127 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
9128 } },
9129 }, .{
9130 .required_features = .{ .avx, null, null, null },
9131 .src_constraints = .{
9132 .{ .scalar_float = .{ .of = .xword, .is = .qword } },
9133 .{ .scalar_float = .{ .of = .xword, .is = .qword } },
9134 .any,
9135 },
9136 .patterns = &.{
9137 .{ .src = .{ .to_sse, .mem, .none } },
9138 .{ .src = .{ .to_sse, .to_sse, .none } },
9139 },
9140 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
9141 .each = .{ .once = &.{
9142 .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
9143 .{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
9144 } },
9145 }, .{
9146 .required_features = .{ .sse4_1, null, null, null },
9147 .src_constraints = .{
9148 .{ .scalar_float = .{ .of = .xword, .is = .qword } },
9149 .{ .scalar_float = .{ .of = .xword, .is = .qword } },
9150 .any,
9151 },
9152 .patterns = &.{
9153 .{ .src = .{ .to_mut_sse, .mem, .none } },
9154 .{ .src = .{ .to_mut_sse, .to_sse, .none } },
9155 },
9156 .dst_temps = .{ .{ .ref = .src0 }, .unused },
9157 .each = .{ .once = &.{
9158 .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
9159 .{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
9160 } },
9161 }, .{
9162 .required_features = .{ .avx, null, null, null },
9163 .src_constraints = .{
9164 .{ .scalar_float = .{ .of = .yword, .is = .qword } },
9165 .{ .scalar_float = .{ .of = .yword, .is = .qword } },
9166 .any,
9167 },
9168 .patterns = &.{
9169 .{ .src = .{ .to_sse, .mem, .none } },
9170 .{ .src = .{ .to_sse, .to_sse, .none } },
9171 },
9172 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
9173 .each = .{ .once = &.{
9174 .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
9175 .{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
9176 } },
9177 }, .{
9178 .required_features = .{ .avx, null, null, null },
9179 .src_constraints = .{
9180 .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
9181 .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
9182 .any,
9183 },
9184 .patterns = &.{
9185 .{ .src = .{ .to_mem, .to_mem, .none } },
9186 },
9187 .extra_temps = .{
9188 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9189 .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
9190 .unused,
9191 .unused,
9192 .unused,
9193 .unused,
9194 .unused,
9195 .unused,
9196 .unused,
9197 },
9198 .dst_temps = .{ .mem, .unused },
9199 .clobbers = .{ .eflags = true },
9200 .each = .{ .once = &.{
9201 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
9202 .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
9203 .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
9204 .{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
9205 .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
9206 .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
9207 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9208 } },
9209 }, .{
9210 .required_features = .{ .sse4_1, null, null, null },
9211 .src_constraints = .{
9212 .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
9213 .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
9214 .any,
9215 },
9216 .patterns = &.{
9217 .{ .src = .{ .to_mem, .to_mem, .none } },
9218 },
9219 .extra_temps = .{
9220 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9221 .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
9222 .unused,
9223 .unused,
9224 .unused,
9225 .unused,
9226 .unused,
9227 .unused,
9228 .unused,
9229 },
9230 .dst_temps = .{ .mem, .unused },
9231 .clobbers = .{ .eflags = true },
9232 .each = .{ .once = &.{
9233 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
9234 .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
9235 .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
9236 .{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
9237 .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
9238 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
9239 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9240 } },
9241 }, .{
9242 .required_features = .{ .sse2, null, null, null },
9243 .src_constraints = .{
9244 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
9245 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
9246 .any,
9247 },
9248 .patterns = &.{
9249 .{ .src = .{ .to_mem, .to_mem, .none } },
9250 },
9251 .call_frame = .{ .alignment = .@"16" },
9252 .extra_temps = .{
9253 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9254 .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
9255 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
9256 .unused,
9257 .unused,
9258 .unused,
9259 .unused,
9260 .unused,
9261 .unused,
9262 },
9263 .dst_temps = .{ .mem, .unused },
9264 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9265 .each = .{ .once = &.{
9266 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
9267 .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
9268 .{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
9269 .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
9270 .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
9271 .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
9272 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9273 } },
9274 }, .{
9275 .required_features = .{ .sse, null, null, null },
9276 .src_constraints = .{
9277 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
9278 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
9279 .any,
9280 },
9281 .patterns = &.{
9282 .{ .src = .{ .to_mem, .to_mem, .none } },
9283 },
9284 .call_frame = .{ .alignment = .@"16" },
9285 .extra_temps = .{
9286 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9287 .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
9288 .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
9289 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
9290 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
9291 .unused,
9292 .unused,
9293 .unused,
9294 .unused,
9295 },
9296 .dst_temps = .{ .mem, .unused },
9297 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9298 .each = .{ .once = &.{
9299 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
9300 .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
9301 .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
9302 .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
9303 .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
9304 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
9305 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9306 .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
9307 .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
9308 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9309 } },
9310 }, .{
9311 .required_features = .{ .x87, null, null, null },
9312 .src_constraints = .{
9313 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
9314 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
9315 .any,
9316 },
9317 .patterns = &.{
9318 .{ .src = .{ .to_mem, .to_mem, .none } },
9319 },
9320 .call_frame = .{ .size = 16, .alignment = .@"16" },
9321 .extra_temps = .{
9322 .{ .type = .f80, .kind = .{ .reg = .st6 } },
9323 .{ .type = .f80, .kind = .{ .reg = .st7 } },
9324 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
9325 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncx" } } },
9326 .unused,
9327 .unused,
9328 .unused,
9329 .unused,
9330 .unused,
9331 },
9332 .dst_temps = .{ .{ .reg = .st0 }, .unused },
9333 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9334 .each = .{ .once = &.{
9335 .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
9336 .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
9337 .{ ._, .f_p, .div, ._, ._, ._, ._ },
9338 .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
9339 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
9340 } },
9341 }, .{
9342 .required_features = .{ .x87, null, null, null },
9343 .src_constraints = .{
9344 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
9345 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
9346 .any,
9347 },
9348 .patterns = &.{
9349 .{ .src = .{ .to_mem, .to_mem, .none } },
9350 },
9351 .call_frame = .{ .size = 16, .alignment = .@"16" },
9352 .extra_temps = .{
9353 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9354 .{ .type = .f80, .kind = .{ .reg = .st6 } },
9355 .{ .type = .f80, .kind = .{ .reg = .st7 } },
9356 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
9357 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncx" } } },
9358 .unused,
9359 .unused,
9360 .unused,
9361 .unused,
9362 },
9363 .dst_temps = .{ .mem, .unused },
9364 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9365 .each = .{ .once = &.{
9366 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
9367 .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
9368 .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
9369 .{ ._, .f_p, .div, ._, ._, ._, ._ },
9370 .{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ },
9371 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9372 .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
9373 .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
9374 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
9375 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9376 } },
9377 }, .{
9378 .required_features = .{ .sse, null, null, null },
9379 .src_constraints = .{
9380 .{ .scalar_float = .{ .of = .xword, .is = .xword } },
9381 .{ .scalar_float = .{ .of = .xword, .is = .xword } },
9382 .any,
9383 },
9384 .patterns = &.{
9385 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
9386 },
9387 .call_frame = .{ .alignment = .@"16" },
9388 .extra_temps = .{
9389 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
9390 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
9391 .unused,
9392 .unused,
9393 .unused,
9394 .unused,
9395 .unused,
9396 .unused,
9397 .unused,
9398 },
9399 .dst_temps = .{ .{ .ref = .src0 }, .unused },
9400 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9401 .each = .{ .once = &.{
9402 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
9403 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
9404 } },
9405 }, .{
9406 .required_features = .{ .avx, null, null, null },
9407 .src_constraints = .{
9408 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
9409 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
9410 .any,
9411 },
9412 .patterns = &.{
9413 .{ .src = .{ .to_mem, .to_mem, .none } },
9414 },
9415 .call_frame = .{ .alignment = .@"16" },
9416 .extra_temps = .{
9417 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9418 .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
9419 .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
9420 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
9421 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
9422 .unused,
9423 .unused,
9424 .unused,
9425 .unused,
9426 },
9427 .dst_temps = .{ .mem, .unused },
9428 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9429 .each = .{ .once = &.{
9430 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
9431 .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
9432 .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
9433 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
9434 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9435 .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
9436 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
9437 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9438 } },
9439 }, .{
9440 .required_features = .{ .sse2, null, null, null },
9441 .src_constraints = .{
9442 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
9443 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
9444 .any,
9445 },
9446 .patterns = &.{
9447 .{ .src = .{ .to_mem, .to_mem, .none } },
9448 },
9449 .call_frame = .{ .alignment = .@"16" },
9450 .extra_temps = .{
9451 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9452 .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
9453 .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
9454 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
9455 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
9456 .unused,
9457 .unused,
9458 .unused,
9459 .unused,
9460 },
9461 .dst_temps = .{ .mem, .unused },
9462 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9463 .each = .{ .once = &.{
9464 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
9465 .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
9466 .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
9467 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
9468 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9469 .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
9470 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
9471 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9472 } },
9473 }, .{
9474 .required_features = .{ .sse, null, null, null },
9475 .src_constraints = .{
9476 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
9477 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
9478 .any,
9479 },
9480 .patterns = &.{
9481 .{ .src = .{ .to_mem, .to_mem, .none } },
9482 },
9483 .call_frame = .{ .alignment = .@"16" },
9484 .extra_temps = .{
9485 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
9486 .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
9487 .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
9488 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
9489 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
9490 .unused,
9491 .unused,
9492 .unused,
9493 .unused,
9494 },
9495 .dst_temps = .{ .mem, .unused },
9496 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
9497 .each = .{ .once = &.{
9498 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
9499 .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
9500 .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
9501 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
9502 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
9503 .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
9504 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
9505 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9506 } },
9507 } }) catch |err| switch (err) {
8850 error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{9508 error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
8851 @tagName(air_tag),9509 @tagName(air_tag),
8852 cg.typeOf(bin_op.lhs).fmt(pt),9510 cg.typeOf(bin_op.lhs).fmt(pt),
...@@ -9982,7 +10640,1004 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {...@@ -9982,7 +10640,1004 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
9982 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },10640 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
9983 } },10641 } },
9984 } },10642 } },
9985 }) catch |err| switch (err) {10643 }) catch |err| switch (err) {
10644 error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
10645 @tagName(air_tag),
10646 cg.typeOf(bin_op.lhs).fmt(pt),
10647 ops[0].tracking(cg),
10648 ops[1].tracking(cg),
10649 }),
10650 else => |e| return e,
10651 };
10652 try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
10653 },
10654 .div_floor => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else fallback: {
10655 const bin_op = air_datas[@intFromEnum(inst)].bin_op;
10656 if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airMulDivBinOp(inst, air_tag);
10657 var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
10658 var res: [1]Temp = undefined;
10659 cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
10660 .required_features = .{ .f16c, null, null, null },
10661 .src_constraints = .{
10662 .{ .scalar_float = .{ .of = .word, .is = .word } },
10663 .{ .scalar_float = .{ .of = .word, .is = .word } },
10664 .any,
10665 },
10666 .patterns = &.{
10667 .{ .src = .{ .to_sse, .to_sse, .none } },
10668 },
10669 .extra_temps = .{
10670 .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
10671 .unused,
10672 .unused,
10673 .unused,
10674 .unused,
10675 .unused,
10676 .unused,
10677 .unused,
10678 .unused,
10679 },
10680 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
10681 .each = .{ .once = &.{
10682 .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
10683 .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
10684 .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },
10685 .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
10686 .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
10687 .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .down, .precision = .inexact }) },
10688 .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
10689 } },
10690 }, .{
10691 .required_features = .{ .sse, null, null, null },
10692 .src_constraints = .{
10693 .{ .scalar_float = .{ .of = .word, .is = .word } },
10694 .{ .scalar_float = .{ .of = .word, .is = .word } },
10695 .any,
10696 },
10697 .patterns = &.{
10698 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
10699 },
10700 .call_frame = .{ .alignment = .@"16" },
10701 .extra_temps = .{
10702 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
10703 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
10704 .unused,
10705 .unused,
10706 .unused,
10707 .unused,
10708 .unused,
10709 .unused,
10710 .unused,
10711 },
10712 .dst_temps = .{ .{ .ref = .src0 }, .unused },
10713 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10714 .each = .{ .once = &.{
10715 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
10716 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
10717 } },
10718 }, .{
10719 .required_features = .{ .f16c, null, null, null },
10720 .src_constraints = .{
10721 .{ .scalar_float = .{ .of = .qword, .is = .word } },
10722 .{ .scalar_float = .{ .of = .qword, .is = .word } },
10723 .any,
10724 },
10725 .patterns = &.{
10726 .{ .src = .{ .mem, .mem, .none } },
10727 .{ .src = .{ .to_sse, .mem, .none } },
10728 .{ .src = .{ .mem, .to_sse, .none } },
10729 .{ .src = .{ .to_sse, .to_sse, .none } },
10730 },
10731 .extra_temps = .{
10732 .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
10733 .unused,
10734 .unused,
10735 .unused,
10736 .unused,
10737 .unused,
10738 .unused,
10739 .unused,
10740 .unused,
10741 },
10742 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
10743 .each = .{ .once = &.{
10744 .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
10745 .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
10746 .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },
10747 .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
10748 .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
10749 .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
10750 .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
10751 } },
10752 }, .{
10753 .required_features = .{ .f16c, null, null, null },
10754 .src_constraints = .{
10755 .{ .scalar_float = .{ .of = .xword, .is = .word } },
10756 .{ .scalar_float = .{ .of = .xword, .is = .word } },
10757 .any,
10758 },
10759 .patterns = &.{
10760 .{ .src = .{ .mem, .mem, .none } },
10761 .{ .src = .{ .to_sse, .mem, .none } },
10762 .{ .src = .{ .mem, .to_sse, .none } },
10763 .{ .src = .{ .to_sse, .to_sse, .none } },
10764 },
10765 .extra_temps = .{
10766 .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
10767 .unused,
10768 .unused,
10769 .unused,
10770 .unused,
10771 .unused,
10772 .unused,
10773 .unused,
10774 .unused,
10775 },
10776 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
10777 .each = .{ .once = &.{
10778 .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
10779 .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
10780 .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },
10781 .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
10782 .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
10783 .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
10784 .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
10785 } },
10786 }, .{
10787 .required_features = .{ .f16c, null, null, null },
10788 .src_constraints = .{
10789 .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
10790 .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
10791 .any,
10792 },
10793 .patterns = &.{
10794 .{ .src = .{ .to_mem, .to_mem, .none } },
10795 },
10796 .extra_temps = .{
10797 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10798 .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
10799 .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
10800 .unused,
10801 .unused,
10802 .unused,
10803 .unused,
10804 .unused,
10805 .unused,
10806 },
10807 .dst_temps = .{ .mem, .unused },
10808 .clobbers = .{ .eflags = true },
10809 .each = .{ .once = &.{
10810 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10811 .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
10812 .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
10813 .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },
10814 .{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ },
10815 .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
10816 .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
10817 .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
10818 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
10819 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10820 } },
10821 }, .{
10822 .required_features = .{ .avx, null, null, null },
10823 .src_constraints = .{
10824 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
10825 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
10826 .any,
10827 },
10828 .patterns = &.{
10829 .{ .src = .{ .to_mem, .to_mem, .none } },
10830 },
10831 .call_frame = .{ .alignment = .@"16" },
10832 .extra_temps = .{
10833 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10834 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
10835 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
10836 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
10837 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
10838 .unused,
10839 .unused,
10840 .unused,
10841 .unused,
10842 },
10843 .dst_temps = .{ .mem, .unused },
10844 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10845 .each = .{ .once = &.{
10846 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10847 .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
10848 .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
10849 .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
10850 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
10851 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
10852 .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
10853 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
10854 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10855 } },
10856 }, .{
10857 .required_features = .{ .sse4_1, null, null, null },
10858 .src_constraints = .{
10859 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
10860 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
10861 .any,
10862 },
10863 .patterns = &.{
10864 .{ .src = .{ .to_mem, .to_mem, .none } },
10865 },
10866 .call_frame = .{ .alignment = .@"16" },
10867 .extra_temps = .{
10868 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10869 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
10870 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
10871 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
10872 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
10873 .unused,
10874 .unused,
10875 .unused,
10876 .unused,
10877 },
10878 .dst_temps = .{ .mem, .unused },
10879 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10880 .each = .{ .once = &.{
10881 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10882 .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
10883 .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
10884 .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
10885 .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
10886 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
10887 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
10888 .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
10889 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
10890 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10891 } },
10892 }, .{
10893 .required_features = .{ .sse2, null, null, null },
10894 .src_constraints = .{
10895 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
10896 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
10897 .any,
10898 },
10899 .patterns = &.{
10900 .{ .src = .{ .to_mem, .to_mem, .none } },
10901 },
10902 .call_frame = .{ .alignment = .@"16" },
10903 .extra_temps = .{
10904 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10905 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
10906 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
10907 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
10908 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
10909 .{ .type = .f16, .kind = .{ .reg = .ax } },
10910 .unused,
10911 .unused,
10912 .unused,
10913 },
10914 .dst_temps = .{ .mem, .unused },
10915 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10916 .each = .{ .once = &.{
10917 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10918 .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
10919 .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
10920 .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
10921 .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
10922 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
10923 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
10924 .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
10925 .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
10926 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
10927 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10928 } },
10929 }, .{
10930 .required_features = .{ .sse, null, null, null },
10931 .src_constraints = .{
10932 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
10933 .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
10934 .any,
10935 },
10936 .patterns = &.{
10937 .{ .src = .{ .to_mem, .to_mem, .none } },
10938 },
10939 .call_frame = .{ .alignment = .@"16" },
10940 .extra_temps = .{
10941 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
10942 .{ .type = .f16, .kind = .{ .reg = .ax } },
10943 .{ .type = .f32, .kind = .mem },
10944 .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
10945 .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
10946 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
10947 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
10948 .unused,
10949 .unused,
10950 },
10951 .dst_temps = .{ .mem, .unused },
10952 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
10953 .each = .{ .once = &.{
10954 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
10955 .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
10956 .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
10957 .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
10958 .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
10959 .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
10960 .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
10961 .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
10962 .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
10963 .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
10964 .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
10965 .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
10966 .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
10967 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
10968 } },
10969 }, .{
10970 .required_features = .{ .avx, null, null, null },
10971 .src_constraints = .{
10972 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
10973 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
10974 .any,
10975 },
10976 .patterns = &.{
10977 .{ .src = .{ .to_sse, .mem, .none } },
10978 .{ .src = .{ .to_sse, .to_sse, .none } },
10979 },
10980 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
10981 .each = .{ .once = &.{
10982 .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },
10983 .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .down, .precision = .inexact }) },
10984 } },
10985 }, .{
10986 .required_features = .{ .sse4_1, null, null, null },
10987 .src_constraints = .{
10988 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
10989 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
10990 .any,
10991 },
10992 .patterns = &.{
10993 .{ .src = .{ .to_mut_sse, .mem, .none } },
10994 .{ .src = .{ .to_mut_sse, .to_sse, .none } },
10995 },
10996 .dst_temps = .{ .{ .ref = .src0 }, .unused },
10997 .each = .{ .once = &.{
10998 .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
10999 .{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
11000 } },
11001 }, .{
11002 .required_features = .{ .sse, null, null, null },
11003 .src_constraints = .{
11004 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
11005 .{ .scalar_float = .{ .of = .dword, .is = .dword } },
11006 .any,
11007 },
11008 .patterns = &.{
11009 .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
11010 },
11011 .call_frame = .{ .alignment = .@"16" },
11012 .extra_temps = .{
11013 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorf" } } },
11014 .unused,
11015 .unused,
11016 .unused,
11017 .unused,
11018 .unused,
11019 .unused,
11020 .unused,
11021 .unused,
11022 },
11023 .dst_temps = .{ .{ .ref = .src0 }, .unused },
11024 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
11025 .each = .{ .once = &.{
11026 .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
11027 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
11028 } },
11029 }, .{
11030 .required_features = .{ .avx, null, null, null },
11031 .src_constraints = .{
11032 .{ .scalar_float = .{ .of = .xword, .is = .dword } },
11033 .{ .scalar_float = .{ .of = .xword, .is = .dword } },
11034 .any,
11035 },
11036 .patterns = &.{
11037 .{ .src = .{ .to_sse, .mem, .none } },
11038 .{ .src = .{ .to_sse, .to_sse, .none } },
11039 },
11040 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
11041 .each = .{ .once = &.{
11042 .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
11043 .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
11044 } },
11045 }, .{
11046 .required_features = .{ .sse4_1, null, null, null },
11047 .src_constraints = .{
11048 .{ .scalar_float = .{ .of = .xword, .is = .dword } },
11049 .{ .scalar_float = .{ .of = .xword, .is = .dword } },
11050 .any,
11051 },
11052 .patterns = &.{
11053 .{ .src = .{ .to_mut_sse, .mem, .none } },
11054 .{ .src = .{ .to_mut_sse, .to_sse, .none } },
11055 },
11056 .dst_temps = .{ .{ .ref = .src0 }, .unused },
11057 .each = .{ .once = &.{
11058 .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
11059 .{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
11060 } },
11061 }, .{
11062 .required_features = .{ .sse, null, null, null },
11063 .src_constraints = .{
11064 .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
11065 .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
11066 .any,
11067 },
11068 .patterns = &.{
11069 .{ .src = .{ .to_mem, .to_mem, .none } },
11070 },
11071 .call_frame = .{ .alignment = .@"16" },
11072 .extra_temps = .{
11073 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
11074 .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
11075 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorf" } } },
11076 .unused,
11077 .unused,
11078 .unused,
11079 .unused,
11080 .unused,
11081 .unused,
11082 },
11083 .dst_temps = .{ .mem, .unused },
11084 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
11085 .each = .{ .once = &.{
11086 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
11087 .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
11088 .{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
11089 .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
11090 .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
11091 .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
11092 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
11093 } },
11094 }, .{
11095 .required_features = .{ .avx, null, null, null },
11096 .src_constraints = .{
11097 .{ .scalar_float = .{ .of = .yword, .is = .dword } },
11098 .{ .scalar_float = .{ .of = .yword, .is = .dword } },
11099 .any,
11100 },
11101 .patterns = &.{
11102 .{ .src = .{ .to_sse, .mem, .none } },
11103 .{ .src = .{ .to_sse, .to_sse, .none } },
11104 },
11105 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
11106 .each = .{ .once = &.{
11107 .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
11108 .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
11109 } },
11110 }, .{
11111 .required_features = .{ .avx, null, null, null },
11112 .src_constraints = .{
11113 .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
11114 .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
11115 .any,
11116 },
11117 .patterns = &.{
11118 .{ .src = .{ .to_mem, .to_mem, .none } },
11119 },
11120 .extra_temps = .{
11121 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
11122 .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
11123 .unused,
11124 .unused,
11125 .unused,
11126 .unused,
11127 .unused,
11128 .unused,
11129 .unused,
11130 },
11131 .dst_temps = .{ .mem, .unused },
11132 .clobbers = .{ .eflags = true },
11133 .each = .{ .once = &.{
11134 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
11135 .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
11136 .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
11137 .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
11138 .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
11139 .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
11140 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
11141 } },
11142 }, .{
11143 .required_features = .{ .sse4_1, null, null, null },
11144 .src_constraints = .{
11145 .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
11146 .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
11147 .any,
11148 },
11149 .patterns = &.{
11150 .{ .src = .{ .to_mem, .to_mem, .none } },
11151 },
11152 .extra_temps = .{
11153 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
11154 .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
11155 .unused,
11156 .unused,
11157 .unused,
11158 .unused,
11159 .unused,
11160 .unused,
11161 .unused,
11162 },
11163 .dst_temps = .{ .mem, .unused },
11164 .clobbers = .{ .eflags = true },
11165 .each = .{ .once = &.{
11166 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
11167 .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
11168 .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
11169 .{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
11170 .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
11171 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
11172 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
11173 } },
11174 }, .{
11175 .required_features = .{ .avx, null, null, null },
11176 .src_constraints = .{
11177 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
11178 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
11179 .any,
11180 },
11181 .patterns = &.{
11182 .{ .src = .{ .to_sse, .mem, .none } },
11183 .{ .src = .{ .to_sse, .to_sse, .none } },
11184 },
11185 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
11186 .each = .{ .once = &.{
11187 .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
11188 .{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = .down, .precision = .inexact }) },
11189 } },
11190 }, .{
11191 .required_features = .{ .sse4_1, null, null, null },
11192 .src_constraints = .{
11193 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
11194 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
11195 .any,
11196 },
11197 .patterns = &.{
11198 .{ .src = .{ .to_mut_sse, .mem, .none } },
11199 .{ .src = .{ .to_mut_sse, .to_sse, .none } },
11200 },
11201 .dst_temps = .{ .{ .ref = .src0 }, .unused },
11202 .each = .{ .once = &.{
11203 .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
11204 .{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
11205 } },
11206 }, .{
11207 .required_features = .{ .sse2, null, null, null },
11208 .src_constraints = .{
11209 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
11210 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
11211 .any,
11212 },
11213 .patterns = &.{
11214 .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
11215 },
11216 .call_frame = .{ .alignment = .@"16" },
11217 .extra_temps = .{
11218 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
11219 .unused,
11220 .unused,
11221 .unused,
11222 .unused,
11223 .unused,
11224 .unused,
11225 .unused,
11226 .unused,
11227 },
11228 .dst_temps = .{ .{ .ref = .src0 }, .unused },
11229 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
11230 .each = .{ .once = &.{
11231 .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
11232 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
11233 } },
11234 }, .{
11235 .required_features = .{ .sse, null, null, null },
11236 .src_constraints = .{
11237 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
11238 .{ .scalar_float = .{ .of = .qword, .is = .qword } },
11239 .any,
11240 },
11241 .patterns = &.{
11242 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
11243 },
11244 .call_frame = .{ .alignment = .@"16" },
11245 .extra_temps = .{
11246 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
11247 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
11248 .unused,
11249 .unused,
11250 .unused,
11251 .unused,
11252 .unused,
11253 .unused,
11254 .unused,
11255 },
11256 .dst_temps = .{ .{ .ref = .src0 }, .unused },
11257 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
11258 .each = .{ .once = &.{
11259 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
11260 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
11261 } },
11262 }, .{
11263 .required_features = .{ .avx, null, null, null },
11264 .src_constraints = .{
11265 .{ .scalar_float = .{ .of = .xword, .is = .qword } },
11266 .{ .scalar_float = .{ .of = .xword, .is = .qword } },
11267 .any,
11268 },
11269 .patterns = &.{
11270 .{ .src = .{ .to_sse, .mem, .none } },
11271 .{ .src = .{ .to_sse, .to_sse, .none } },
11272 },
11273 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
11274 .each = .{ .once = &.{
11275 .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
11276 .{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
11277 } },
11278 }, .{
11279 .required_features = .{ .sse4_1, null, null, null },
11280 .src_constraints = .{
11281 .{ .scalar_float = .{ .of = .xword, .is = .qword } },
11282 .{ .scalar_float = .{ .of = .xword, .is = .qword } },
11283 .any,
11284 },
11285 .patterns = &.{
11286 .{ .src = .{ .to_mut_sse, .mem, .none } },
11287 .{ .src = .{ .to_mut_sse, .to_sse, .none } },
11288 },
11289 .dst_temps = .{ .{ .ref = .src0 }, .unused },
11290 .each = .{ .once = &.{
11291 .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
11292 .{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
11293 } },
11294 }, .{
11295 .required_features = .{ .avx, null, null, null },
11296 .src_constraints = .{
11297 .{ .scalar_float = .{ .of = .yword, .is = .qword } },
11298 .{ .scalar_float = .{ .of = .yword, .is = .qword } },
11299 .any,
11300 },
11301 .patterns = &.{
11302 .{ .src = .{ .to_sse, .mem, .none } },
11303 .{ .src = .{ .to_sse, .to_sse, .none } },
11304 },
11305 .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
11306 .each = .{ .once = &.{
11307 .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
11308 .{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
11309 } },
11310 }, .{
11311 .required_features = .{ .avx, null, null, null },
11312 .src_constraints = .{
11313 .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
11314 .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
11315 .any,
11316 },
11317 .patterns = &.{
11318 .{ .src = .{ .to_mem, .to_mem, .none } },
11319 },
11320 .extra_temps = .{
11321 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
11322 .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
11323 .unused,
11324 .unused,
11325 .unused,
11326 .unused,
11327 .unused,
11328 .unused,
11329 .unused,
11330 },
11331 .dst_temps = .{ .mem, .unused },
11332 .clobbers = .{ .eflags = true },
11333 .each = .{ .once = &.{
11334 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
11335 .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
11336 .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
11337 .{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
11338 .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
11339 .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
11340 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
11341 } },
11342 }, .{
11343 .required_features = .{ .sse4_1, null, null, null },
11344 .src_constraints = .{
11345 .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
11346 .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
11347 .any,
11348 },
11349 .patterns = &.{
11350 .{ .src = .{ .to_mem, .to_mem, .none } },
11351 },
11352 .extra_temps = .{
11353 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
11354 .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
11355 .unused,
11356 .unused,
11357 .unused,
11358 .unused,
11359 .unused,
11360 .unused,
11361 .unused,
11362 },
11363 .dst_temps = .{ .mem, .unused },
11364 .clobbers = .{ .eflags = true },
11365 .each = .{ .once = &.{
11366 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
11367 .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
11368 .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
11369 .{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
11370 .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
11371 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
11372 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
11373 } },
11374 }, .{
11375 .required_features = .{ .sse2, null, null, null },
11376 .src_constraints = .{
11377 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
11378 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
11379 .any,
11380 },
11381 .patterns = &.{
11382 .{ .src = .{ .to_mem, .to_mem, .none } },
11383 },
11384 .call_frame = .{ .alignment = .@"16" },
11385 .extra_temps = .{
11386 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
11387 .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
11388 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
11389 .unused,
11390 .unused,
11391 .unused,
11392 .unused,
11393 .unused,
11394 .unused,
11395 },
11396 .dst_temps = .{ .mem, .unused },
11397 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
11398 .each = .{ .once = &.{
11399 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
11400 .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
11401 .{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
11402 .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
11403 .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
11404 .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
11405 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
11406 } },
11407 }, .{
11408 .required_features = .{ .sse, null, null, null },
11409 .src_constraints = .{
11410 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
11411 .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
11412 .any,
11413 },
11414 .patterns = &.{
11415 .{ .src = .{ .to_mem, .to_mem, .none } },
11416 },
11417 .call_frame = .{ .alignment = .@"16" },
11418 .extra_temps = .{
11419 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
11420 .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
11421 .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
11422 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
11423 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
11424 .unused,
11425 .unused,
11426 .unused,
11427 .unused,
11428 },
11429 .dst_temps = .{ .mem, .unused },
11430 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
11431 .each = .{ .once = &.{
11432 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
11433 .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
11434 .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
11435 .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
11436 .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
11437 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
11438 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
11439 .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
11440 .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
11441 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
11442 } },
11443 }, .{
11444 .required_features = .{ .x87, null, null, null },
11445 .src_constraints = .{
11446 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
11447 .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
11448 .any,
11449 },
11450 .patterns = &.{
11451 .{ .src = .{ .to_mem, .to_mem, .none } },
11452 },
11453 .call_frame = .{ .size = 16, .alignment = .@"16" },
11454 .extra_temps = .{
11455 .{ .type = .f80, .kind = .{ .reg = .st6 } },
11456 .{ .type = .f80, .kind = .{ .reg = .st7 } },
11457 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
11458 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorx" } } },
11459 .unused,
11460 .unused,
11461 .unused,
11462 .unused,
11463 .unused,
11464 },
11465 .dst_temps = .{ .{ .reg = .st0 }, .unused },
11466 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
11467 .each = .{ .once = &.{
11468 .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
11469 .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
11470 .{ ._, .f_p, .div, ._, ._, ._, ._ },
11471 .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
11472 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
11473 } },
11474 }, .{
11475 .required_features = .{ .x87, null, null, null },
11476 .src_constraints = .{
11477 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
11478 .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
11479 .any,
11480 },
11481 .patterns = &.{
11482 .{ .src = .{ .to_mem, .to_mem, .none } },
11483 },
11484 .call_frame = .{ .size = 16, .alignment = .@"16" },
11485 .extra_temps = .{
11486 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
11487 .{ .type = .f80, .kind = .{ .reg = .st6 } },
11488 .{ .type = .f80, .kind = .{ .reg = .st7 } },
11489 .{ .type = .f80, .kind = .{ .frame = .call_frame } },
11490 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorx" } } },
11491 .unused,
11492 .unused,
11493 .unused,
11494 .unused,
11495 },
11496 .dst_temps = .{ .mem, .unused },
11497 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
11498 .each = .{ .once = &.{
11499 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
11500 .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
11501 .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
11502 .{ ._, .f_p, .div, ._, ._, ._, ._ },
11503 .{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ },
11504 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
11505 .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
11506 .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
11507 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
11508 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
11509 } },
11510 }, .{
11511 .required_features = .{ .sse, null, null, null },
11512 .src_constraints = .{
11513 .{ .scalar_float = .{ .of = .xword, .is = .xword } },
11514 .{ .scalar_float = .{ .of = .xword, .is = .xword } },
11515 .any,
11516 },
11517 .patterns = &.{
11518 .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
11519 },
11520 .call_frame = .{ .alignment = .@"16" },
11521 .extra_temps = .{
11522 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
11523 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
11524 .unused,
11525 .unused,
11526 .unused,
11527 .unused,
11528 .unused,
11529 .unused,
11530 .unused,
11531 },
11532 .dst_temps = .{ .{ .ref = .src0 }, .unused },
11533 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
11534 .each = .{ .once = &.{
11535 .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
11536 .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
11537 } },
11538 }, .{
11539 .required_features = .{ .avx, null, null, null },
11540 .src_constraints = .{
11541 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
11542 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
11543 .any,
11544 },
11545 .patterns = &.{
11546 .{ .src = .{ .to_mem, .to_mem, .none } },
11547 },
11548 .call_frame = .{ .alignment = .@"16" },
11549 .extra_temps = .{
11550 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
11551 .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
11552 .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
11553 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
11554 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
11555 .unused,
11556 .unused,
11557 .unused,
11558 .unused,
11559 },
11560 .dst_temps = .{ .mem, .unused },
11561 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
11562 .each = .{ .once = &.{
11563 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
11564 .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
11565 .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
11566 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
11567 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
11568 .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
11569 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
11570 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
11571 } },
11572 }, .{
11573 .required_features = .{ .sse2, null, null, null },
11574 .src_constraints = .{
11575 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
11576 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
11577 .any,
11578 },
11579 .patterns = &.{
11580 .{ .src = .{ .to_mem, .to_mem, .none } },
11581 },
11582 .call_frame = .{ .alignment = .@"16" },
11583 .extra_temps = .{
11584 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
11585 .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
11586 .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
11587 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
11588 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
11589 .unused,
11590 .unused,
11591 .unused,
11592 .unused,
11593 },
11594 .dst_temps = .{ .mem, .unused },
11595 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
11596 .each = .{ .once = &.{
11597 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
11598 .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
11599 .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
11600 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
11601 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
11602 .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
11603 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
11604 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
11605 } },
11606 }, .{
11607 .required_features = .{ .sse, null, null, null },
11608 .src_constraints = .{
11609 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
11610 .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
11611 .any,
11612 },
11613 .patterns = &.{
11614 .{ .src = .{ .to_mem, .to_mem, .none } },
11615 },
11616 .call_frame = .{ .alignment = .@"16" },
11617 .extra_temps = .{
11618 .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
11619 .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
11620 .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
11621 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
11622 .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
11623 .unused,
11624 .unused,
11625 .unused,
11626 .unused,
11627 },
11628 .dst_temps = .{ .mem, .unused },
11629 .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
11630 .each = .{ .once = &.{
11631 .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
11632 .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
11633 .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
11634 .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
11635 .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
11636 .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
11637 .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
11638 .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
11639 } },
11640 } }) catch |err| switch (err) {
9986 error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{11641 error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
9987 @tagName(air_tag),11642 @tagName(air_tag),
9988 cg.typeOf(bin_op.lhs).fmt(pt),11643 cg.typeOf(bin_op.lhs).fmt(pt),
...@@ -37825,7 +39480,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {...@@ -37825,7 +39480,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
37825 const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu));39480 const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu));
37826 try cg.spillEflagsIfOccupied();39481 try cg.spillEflagsIfOccupied();
37827 var ops = try cg.tempsFromOperands(inst, .{un_op});39482 var ops = try cg.tempsFromOperands(inst, .{un_op});
37828 while (try ops[0].toBase(cg)) {}39483 while (try ops[0].toBase(false, cg)) {}
37829 try cg.asmMemoryImmediate(39484 try cg.asmMemoryImmediate(
37830 .{ ._, .cmp },39485 .{ ._, .cmp },
37831 try ops[0].tracking(cg).short.mem(cg, .{39486 try ops[0].tracking(cg).short.mem(cg, .{
...@@ -37850,7 +39505,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {...@@ -37850,7 +39505,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
37850 const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu));39505 const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu));
37851 try cg.spillEflagsIfOccupied();39506 try cg.spillEflagsIfOccupied();
37852 var ops = try cg.tempsFromOperands(inst, .{un_op});39507 var ops = try cg.tempsFromOperands(inst, .{un_op});
37853 while (try ops[0].toBase(cg)) {}39508 while (try ops[0].toBase(false, cg)) {}
37854 try cg.asmMemoryImmediate(39509 try cg.asmMemoryImmediate(
37855 .{ ._, .cmp },39510 .{ ._, .cmp },
37856 try ops[0].tracking(cg).short.mem(cg, .{39511 try ops[0].tracking(cg).short.mem(cg, .{
...@@ -37921,7 +39576,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {...@@ -37921,7 +39576,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
37921 const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));39576 const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
37922 try cg.spillEflagsIfOccupied();39577 try cg.spillEflagsIfOccupied();
37923 var ops = try cg.tempsFromOperands(inst, .{un_op});39578 var ops = try cg.tempsFromOperands(inst, .{un_op});
37924 while (try ops[0].toBase(cg)) {}39579 while (try ops[0].toBase(false, cg)) {}
37925 try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{39580 try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{
37926 .size = cg.memSize(eu_err_ty),39581 .size = cg.memSize(eu_err_ty),
37927 .disp = eu_err_off,39582 .disp = eu_err_off,
...@@ -37937,7 +39592,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {...@@ -37937,7 +39592,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
37937 const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));39592 const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
37938 try cg.spillEflagsIfOccupied();39593 try cg.spillEflagsIfOccupied();
37939 var ops = try cg.tempsFromOperands(inst, .{un_op});39594 var ops = try cg.tempsFromOperands(inst, .{un_op});
37940 while (try ops[0].toBase(cg)) {}39595 while (try ops[0].toBase(false, cg)) {}
37941 try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{39596 try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{
37942 .size = cg.memSize(eu_err_ty),39597 .size = cg.memSize(eu_err_ty),
37943 .disp = eu_err_off,39598 .disp = eu_err_off,
...@@ -88424,7 +90079,7 @@ const Temp = struct {...@@ -88424,7 +90079,7 @@ const Temp = struct {
88424 try cg.register_manager.getReg(new_reg, new_temp_index.toIndex());90079 try cg.register_manager.getReg(new_reg, new_temp_index.toIndex());
88425 cg.temp_type[@intFromEnum(new_temp_index)] = ty;90080 cg.temp_type[@intFromEnum(new_temp_index)] = ty;
88426 new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });90081 new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
88427 while (try temp.toBase(cg)) {}90082 while (try temp.toBase(false, cg)) {}
88428 try temp.readTo(ty, .{ .register = new_reg }, .{}, cg);90083 try temp.readTo(ty, .{ .register = new_reg }, .{}, cg);
88429 try temp.die(cg);90084 try temp.die(cg);
88430 temp.* = .{ .index = new_temp_index.toIndex() };90085 temp.* = .{ .index = new_temp_index.toIndex() };
...@@ -88447,7 +90102,7 @@ const Temp = struct {...@@ -88447,7 +90102,7 @@ const Temp = struct {
88447 for (new_regs) |new_reg| try cg.register_manager.getReg(new_reg, new_temp_index.toIndex());90102 for (new_regs) |new_reg| try cg.register_manager.getReg(new_reg, new_temp_index.toIndex());
88448 cg.temp_type[@intFromEnum(new_temp_index)] = ty;90103 cg.temp_type[@intFromEnum(new_temp_index)] = ty;
88449 new_temp_index.tracking(cg).* = .init(.{ .register_pair = new_regs });90104 new_temp_index.tracking(cg).* = .init(.{ .register_pair = new_regs });
88450 while (try temp.toBase(cg)) {}90105 while (try temp.toBase(false, cg)) {}
88451 for (new_regs, 0..) |new_reg, reg_index| try temp.readTo(90106 for (new_regs, 0..) |new_reg, reg_index| try temp.readTo(
88452 .usize,90107 .usize,
88453 .{ .register = new_reg },90108 .{ .register = new_reg },
...@@ -88548,9 +90203,9 @@ const Temp = struct {...@@ -88548,9 +90203,9 @@ const Temp = struct {
88548 }90203 }
88549 }90204 }
8855090205
88551 fn toMemory(temp: *Temp, cg: *CodeGen) InnerError!bool {90206 fn toMemory(temp: *Temp, mut: bool, cg: *CodeGen) InnerError!bool {
88552 const temp_tracking = temp.tracking(cg);90207 const temp_tracking = temp.tracking(cg);
88553 if (temp_tracking.short.isMemory()) return false;90208 if ((!mut or temp.isMut(cg)) and temp_tracking.short.isMemory()) return false;
88554 const new_temp_index = cg.next_temp_index;90209 const new_temp_index = cg.next_temp_index;
88555 const ty = temp.typeOf(cg);90210 const ty = temp.typeOf(cg);
88556 cg.temp_type[@intFromEnum(new_temp_index)] = ty;90211 cg.temp_type[@intFromEnum(new_temp_index)] = ty;
...@@ -88564,10 +90219,10 @@ const Temp = struct {...@@ -88564,10 +90219,10 @@ const Temp = struct {
88564 }90219 }
8856590220
88566 // hack around linker relocation bugs90221 // hack around linker relocation bugs
88567 fn toBase(temp: *Temp, cg: *CodeGen) InnerError!bool {90222 fn toBase(temp: *Temp, mut: bool, cg: *CodeGen) InnerError!bool {
88568 const temp_tracking = temp.tracking(cg);90223 const temp_tracking = temp.tracking(cg);
88569 if (temp_tracking.short.isBase()) return false;90224 if ((!mut or temp.isMut(cg)) and temp_tracking.short.isBase()) return false;
88570 if (try temp.toMemory(cg)) return true;90225 if (try temp.toMemory(mut, cg)) return true;
88571 const new_temp_index = cg.next_temp_index;90226 const new_temp_index = cg.next_temp_index;
88572 cg.temp_type[@intFromEnum(new_temp_index)] = temp.typeOf(cg);90227 cg.temp_type[@intFromEnum(new_temp_index)] = temp.typeOf(cg);
88573 const new_reg =90228 const new_reg =
...@@ -88722,7 +90377,7 @@ const Temp = struct {...@@ -88722,7 +90377,7 @@ const Temp = struct {
8872290377
88723 fn read(src: *Temp, val_ty: Type, opts: AccessOptions, cg: *CodeGen) InnerError!Temp {90378 fn read(src: *Temp, val_ty: Type, opts: AccessOptions, cg: *CodeGen) InnerError!Temp {
88724 var val = try cg.tempAlloc(val_ty);90379 var val = try cg.tempAlloc(val_ty);
88725 while (try src.toBase(cg)) {}90380 while (try src.toBase(false, cg)) {}
88726 try src.readTo(val_ty, val.tracking(cg).short, opts, cg);90381 try src.readTo(val_ty, val.tracking(cg).short, opts, cg);
88727 return val;90382 return val;
88728 }90383 }
...@@ -88763,8 +90418,8 @@ const Temp = struct {...@@ -88763,8 +90418,8 @@ const Temp = struct {
8876390418
88764 fn write(dst: *Temp, val: *Temp, opts: AccessOptions, cg: *CodeGen) InnerError!void {90419 fn write(dst: *Temp, val: *Temp, opts: AccessOptions, cg: *CodeGen) InnerError!void {
88765 const val_ty = val.typeOf(cg);90420 const val_ty = val.typeOf(cg);
88766 while (try dst.toBase(cg)) {}90421 while (try dst.toBase(false, cg)) {}
88767 val_to_gpr: while (true) : (while (try dst.toBase(cg) or90422 val_to_gpr: while (true) : (while (try dst.toBase(false, cg) or
88768 try val.toRegClass(false, .general_purpose, cg))90423 try val.toRegClass(false, .general_purpose, cg))
88769 {}) {90424 {}) {
88770 const val_mcv = val.tracking(cg).short;90425 const val_mcv = val.tracking(cg).short;
...@@ -90770,7 +92425,8 @@ const Select = struct {...@@ -90770,7 +92425,8 @@ const Select = struct {
90770 fn convert(src: Src, temp: *Temp, cg: *CodeGen) InnerError!bool {92425 fn convert(src: Src, temp: *Temp, cg: *CodeGen) InnerError!bool {
90771 return switch (src) {92426 return switch (src) {
90772 .none, .imm8, .imm16, .imm32, .simm32 => false,92427 .none, .imm8, .imm16, .imm32, .simm32 => false,
90773 .mem, .to_mem, .mut_mem, .to_mut_mem => try temp.toBase(cg),92428 .mem, .to_mem => try temp.toBase(false, cg),
92429 .mut_mem, .to_mut_mem => try temp.toBase(true, cg),
90774 .to_reg => |reg| try temp.toReg(reg, cg),92430 .to_reg => |reg| try temp.toReg(reg, cg),
90775 .to_reg_pair => |regs| try temp.toRegPair(regs, cg),92431 .to_reg_pair => |regs| try temp.toRegPair(regs, cg),
90776 .to_param_gpr => |param_spec| try temp.toReg(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index], cg),92432 .to_param_gpr => |param_spec| try temp.toReg(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index], cg),
...@@ -90814,6 +92470,7 @@ const Select = struct {...@@ -90814,6 +92470,7 @@ const Select = struct {
90814 rc_mask: struct { rc: Register.Class, info: MaskInfo },92470 rc_mask: struct { rc: Register.Class, info: MaskInfo },
90815 mut_rc_mask: struct { ref: Select.Operand.Ref, rc: Register.Class, info: MaskInfo },92471 mut_rc_mask: struct { ref: Select.Operand.Ref, rc: Register.Class, info: MaskInfo },
90816 mem,92472 mem,
92473 mem_of_type: Select.Operand.Ref,
90817 smin_mem: ConstSpec,92474 smin_mem: ConstSpec,
90818 smax_mem: ConstSpec,92475 smax_mem: ConstSpec,
90819 umin_mem: ConstSpec,92476 umin_mem: ConstSpec,
...@@ -90835,9 +92492,9 @@ const Select = struct {...@@ -90835,9 +92492,9 @@ const Select = struct {
9083592492
90836 const CallConvRegSpec = struct {92493 const CallConvRegSpec = struct {
90837 cc: Case.CallConv,92494 cc: Case.CallConv,
90838 index: u1,92495 index: u2,
9083992496
90840 fn tag(spec: CallConvRegSpec, cg: *CodeGen) std.builtin.CallingConvention.Tag {92497 fn tag(spec: CallConvRegSpec, cg: *const CodeGen) std.builtin.CallingConvention.Tag {
90841 return switch (spec.cc) {92498 return switch (spec.cc) {
90842 .none => unreachable,92499 .none => unreachable,
90843 .ccc => cg.target.cCallingConvention().?,92500 .ccc => cg.target.cCallingConvention().?,
...@@ -90846,27 +92503,39 @@ const Select = struct {...@@ -90846,27 +92503,39 @@ const Select = struct {
90846 }92503 }
90847 };92504 };
9084892505
90849 fn finish(kind: Kind, temp: Temp, s: *const Select) void {92506 fn lock(kind: Kind, cg: *CodeGen) ![2]?RegisterLock {
90850 switch (kind) {92507 var reg_locks: [2]?RegisterLock = @splat(null);
90851 else => {},92508 const regs: [2]Register = switch (kind) {
90852 inline .rc_mask, .mut_rc_mask, .ref_mask => |mask| temp.asMask(mask.info, s.cg),92509 else => return reg_locks,
92510 .reg => |reg| .{ reg, .none },
92511 .reg_pair => |regs| regs,
92512 .param_gpr => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index..][0..1].* ++ .{.none},
92513 .param_gpr_pair => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index..][0..2].*,
92514 .ret_gpr => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..1].* ++ .{.none},
92515 .ret_gpr_pair => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*,
92516 };
92517 for (regs, &reg_locks) |reg, *reg_lock| {
92518 if (reg == .none) continue;
92519 const reg_index = RegisterManager.indexOfRegIntoTracked(reg) orelse continue;
92520 try cg.register_manager.getRegIndex(reg_index, null);
92521 reg_lock.* = cg.register_manager.lockRegIndex(reg_index);
90853 }92522 }
92523 return reg_locks;
90854 }92524 }
9085592525
90856 fn pass(kind: Kind) u2 {92526 fn finish(kind: Kind, temp: Temp, cg: *CodeGen) void {
90857 return switch (kind) {92527 switch (kind) {
90858 .unused => 0,92528 else => {},
90859 .reg, .reg_pair, .param_gpr, .param_gpr_pair, .ret_gpr, .ret_gpr_pair => 1,92529 inline .rc_mask, .mut_rc_mask, .ref_mask => |mask| temp.asMask(mask.info, cg),
90860 else => 2,92530 }
90861 };
90862 }92531 }
90863 };92532 };
9086492533
90865 fn create(spec: TempSpec, s: *Select) InnerError!struct { Temp, bool } {92534 fn create(spec: TempSpec, s: *const Select) InnerError!struct { Temp, bool } {
90866 const cg = s.cg;92535 const cg = s.cg;
90867 const pt = cg.pt;92536 const pt = cg.pt;
90868 return switch (spec.kind) {92537 return switch (spec.kind) {
90869 .unused => unreachable,92538 .unused => .{ undefined, false },
90870 .any => .{ try cg.tempAlloc(spec.type), true },92539 .any => .{ try cg.tempAlloc(spec.type), true },
90871 .cc => |cc| .{ try cg.tempInit(spec.type, .{ .eflags = cc }), true },92540 .cc => |cc| .{ try cg.tempInit(spec.type, .{ .eflags = cc }), true },
90872 .ref => |ref| .{ ref.tempOf(s), false },92541 .ref => |ref| .{ ref.tempOf(s), false },
...@@ -90882,7 +92551,7 @@ const Select = struct {...@@ -90882,7 +92551,7 @@ const Select = struct {
90882 .register = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index],92551 .register = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index],
90883 }), true },92552 }), true },
90884 .ret_gpr_pair => |ret_spec| .{ try cg.tempInit(spec.type, .{92553 .ret_gpr_pair => |ret_spec| .{ try cg.tempInit(spec.type, .{
90885 .register_pair = abi.getCAbiIntParamRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*,92554 .register_pair = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*,
90886 }), true },92555 }), true },
90887 .rc => |rc| .{ try cg.tempAllocReg(spec.type, regSetForRegClass(rc)), true },92556 .rc => |rc| .{ try cg.tempAllocReg(spec.type, regSetForRegClass(rc)), true },
90888 .rc_pair => |rc| .{ try cg.tempAllocRegPair(spec.type, regSetForRegClass(rc)), true },92557 .rc_pair => |rc| .{ try cg.tempAllocRegPair(spec.type, regSetForRegClass(rc)), true },
...@@ -90907,6 +92576,7 @@ const Select = struct {...@@ -90907,6 +92576,7 @@ const Select = struct {
90907 return .{ try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc_mask.rc)), true };92576 return .{ try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc_mask.rc)), true };
90908 },92577 },
90909 .mem => .{ try cg.tempAllocMem(spec.type), true },92578 .mem => .{ try cg.tempAllocMem(spec.type), true },
92579 .mem_of_type => |ref| .{ try cg.tempAllocMem(ref.typeOf(s)), true },
90910 .smin_mem, .smax_mem, .umin_mem, .umax_mem, .@"0x1p63_mem" => |const_spec| {92580 .smin_mem, .smax_mem, .umin_mem, .umax_mem, .@"0x1p63_mem" => |const_spec| {
90911 const zcu = pt.zcu;92581 const zcu = pt.zcu;
90912 const ip = &zcu.intern_pool;92582 const ip = &zcu.intern_pool;
...@@ -91922,15 +93592,10 @@ fn select(...@@ -91922,15 +93592,10 @@ fn select(
9192293592
91923 @memcpy(s_src_temps[0..src_temps.len], src_temps);93593 @memcpy(s_src_temps[0..src_temps.len], src_temps);
91924 std.mem.swap(Temp, &s_src_temps[pattern.commute[0]], &s_src_temps[pattern.commute[1]]);93594 std.mem.swap(Temp, &s_src_temps[pattern.commute[0]], &s_src_temps[pattern.commute[1]]);
91925 for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) |*dst_temp, dst_ty, dst_kind| {93595 var dst_locks: [s_dst_temps.len][2]?RegisterLock = @splat(@splat(null));
91926 if (dst_kind.pass() != 1) continue;93596 for (dst_locks[0..dst_temps.len], case.dst_temps[0..dst_temps.len]) |*dst_lock, dst_kind| dst_lock.* = try dst_kind.lock(cg);
91927 dst_temp.*, _ = try Select.TempSpec.create(.{ .type = dst_ty, .kind = dst_kind }, &s);93597 var tmp_locks: [s_tmp_temps.len][2]?RegisterLock = @splat(@splat(null));
91928 }93598 for (&tmp_locks, case.extra_temps) |*tmp_lock, tmp_spec| tmp_lock.* = try tmp_spec.kind.lock(cg);
91929 var tmp_owned: [s_tmp_temps.len]bool = @splat(false);
91930 for (1..3) |pass| for (s_tmp_temps, &tmp_owned, case.extra_temps) |*temp, *owned, spec| {
91931 if (spec.kind.pass() != pass) continue;
91932 temp.*, owned.* = try spec.create(&s);
91933 };
9193493599
91935 while (true) for (pattern.src[0..src_temps.len], src_temps) |src_pattern, *src_temp| {93600 while (true) for (pattern.src[0..src_temps.len], src_temps) |src_pattern, *src_temp| {
91936 if (try src_pattern.convert(src_temp, cg)) break;93601 if (try src_pattern.convert(src_temp, cg)) break;
...@@ -91940,10 +93605,9 @@ fn select(...@@ -91940,10 +93605,9 @@ fn select(
9194093605
91941 if (case.clobbers.eflags) try cg.spillEflagsIfOccupied();93606 if (case.clobbers.eflags) try cg.spillEflagsIfOccupied();
9194293607
91943 for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) |*dst_temp, dst_ty, dst_kind| {93608 var tmp_owned: [s_tmp_temps.len]bool = @splat(false);
91944 if (dst_kind.pass() != 2) continue;93609 for (s_tmp_temps, &tmp_owned, case.extra_temps) |*temp, *owned, tmp_spec| temp.*, owned.* = try tmp_spec.create(&s);
91945 dst_temp.*, _ = try Select.TempSpec.create(.{ .type = dst_ty, .kind = dst_kind }, &s);93610 for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) |*dst_temp, dst_ty, tmp_kind| dst_temp.*, _ = try Select.TempSpec.create(.{ .type = dst_ty, .kind = tmp_kind }, &s);
91946 }
91947 @memcpy(s_dst_temps[0..dst_temps.len], dst_temps);93611 @memcpy(s_dst_temps[0..dst_temps.len], dst_temps);
9194893612
91949 switch (case.each) {93613 switch (case.each) {
...@@ -91954,6 +93618,8 @@ fn select(...@@ -91954,6 +93618,8 @@ fn select(
91954 }93618 }
91955 assert(s.top == 0);93619 assert(s.top == 0);
9195693620
93621 for (tmp_locks) |locks| for (locks) |lock| if (lock) |reg| cg.register_manager.unlockReg(reg);
93622 for (dst_locks) |locks| for (locks) |lock| if (lock) |reg| cg.register_manager.unlockReg(reg);
91957 caller_preserved: {93623 caller_preserved: {
91958 const cc = switch (case.clobbers.caller_preserved) {93624 const cc = switch (case.clobbers.caller_preserved) {
91959 .none => break :caller_preserved,93625 .none => break :caller_preserved,
...@@ -91972,7 +93638,7 @@ fn select(...@@ -91972,7 +93638,7 @@ fn select(
91972 },93638 },
91973 }93639 }
91974 }93640 }
91975 for (dst_temps, case.dst_temps[0..dst_temps.len]) |dst_temp, dst_kind| dst_kind.finish(dst_temp, &s);93641 for (dst_temps, case.dst_temps[0..dst_temps.len]) |dst_temp, tmp_kind| tmp_kind.finish(dst_temp, cg);
91976 for (tmp_owned, s_tmp_temps) |owned, temp| if (owned) try temp.die(cg);93642 for (tmp_owned, s_tmp_temps) |owned, temp| if (owned) try temp.die(cg);
91977 return;93643 return;
91978 }93644 }
test/behavior/x86_64/math.zig+41-32
...@@ -17978,8 +17978,8 @@ fn binary(comptime op: anytype, comptime opts: struct { compare: Compare = .rela...@@ -17978,8 +17978,8 @@ fn binary(comptime op: anytype, comptime opts: struct { compare: Compare = .rela
17978 -0x12, -0x1e, 0x18, 0x6e, 0x31, 0x53, -0x6a, -0x34, 0x13, 0x4d, 0x30, -0x7d, -0x31, 0x1e, -0x24, 0x32,17978 -0x12, -0x1e, 0x18, 0x6e, 0x31, 0x53, -0x6a, -0x34, 0x13, 0x4d, 0x30, -0x7d, -0x31, 0x1e, -0x24, 0x32,
17979 -0x1e, -0x01, 0x55, 0x33, -0x75, -0x44, -0x57, 0x2b, -0x66, 0x19, 0x7f, -0x28, -0x3f, -0x7e, -0x5d, -0x06,17979 -0x1e, -0x01, 0x55, 0x33, -0x75, -0x44, -0x57, 0x2b, -0x66, 0x19, 0x7f, -0x28, -0x3f, -0x7e, -0x5d, -0x06,
17980 }, .{17980 }, .{
17981 0x05, -0x23, 0x43, -0x54, -0x41, 0x7f, -0x6a, -0x31, 0x04, 0x15, -0x7a, -0x37, 0x6d, 0x16, 0x00, 0x4a,17981 0x05, -0x23, 0x43, -0x54, -0x41, 0x7f, -0x6a, -0x31, 0x04, 0x15, -0x7a, -0x37, 0x6d, 0x16, 0x01, 0x4a,
17982 0x15, 0x55, -0x4a, 0x16, -0x73, -0x0c, 0x1c, -0x26, -0x14, 0x00, 0x55, 0x7b, 0x16, -0x2e, -0x5f, -0x67,17982 0x15, 0x55, -0x4a, 0x16, -0x73, -0x0c, 0x1c, -0x26, -0x14, -0x01, 0x55, 0x7b, 0x16, -0x2e, -0x5f, -0x67,
17983 });17983 });
17984 try testArgs(@Vector(64, i8), .{17984 try testArgs(@Vector(64, i8), .{
17985 -0x05, 0x76, 0x4e, -0x5c, 0x7b, -0x1a, -0x38, -0x2e, 0x3d, 0x36, 0x01, 0x30, -0x02, -0x71, -0x24, 0x24,17985 -0x05, 0x76, 0x4e, -0x5c, 0x7b, -0x1a, -0x38, -0x2e, 0x3d, 0x36, 0x01, 0x30, -0x02, -0x71, -0x24, 0x24,
...@@ -18008,7 +18008,7 @@ fn binary(comptime op: anytype, comptime opts: struct { compare: Compare = .rela...@@ -18008,7 +18008,7 @@ fn binary(comptime op: anytype, comptime opts: struct { compare: Compare = .rela
18008 0x23, 0x3b, 0x0a, 0x7a, 0x19, 0x14, 0x65, -0x1d, 0x2b, 0x65, 0x33, 0x2a, 0x52, -0x63, 0x57, 0x10,18008 0x23, 0x3b, 0x0a, 0x7a, 0x19, 0x14, 0x65, -0x1d, 0x2b, 0x65, 0x33, 0x2a, 0x52, -0x63, 0x57, 0x10,
18009 -0x1b, 0x26, -0x46, -0x7e, -0x25, 0x79, -0x01, -0x0d, -0x49, -0x4d, 0x74, 0x03, 0x77, 0x16, 0x03, -0x3d,18009 -0x1b, 0x26, -0x46, -0x7e, -0x25, 0x79, -0x01, -0x0d, -0x49, -0x4d, 0x74, 0x03, 0x77, 0x16, 0x03, -0x3d,
18010 0x1c, 0x25, 0x5a, -0x2f, -0x16, -0x5f, -0x36, -0x55, -0x44, -0x0c, -0x0f, 0x7b, -0x15, -0x1d, 0x32, 0x31,18010 0x1c, 0x25, 0x5a, -0x2f, -0x16, -0x5f, -0x36, -0x55, -0x44, -0x0c, -0x0f, 0x7b, -0x15, -0x1d, 0x32, 0x31,
18011 0x6e, -0x44, -0x4a, -0x64, 0x67, 0x04, 0x47, 0x00, 0x3c, -0x0a, -0x79, 0x3d, 0x48, 0x5a, 0x61, -0x2c,18011 0x6e, -0x44, -0x4a, -0x64, 0x67, 0x04, 0x47, -0x02, 0x3c, -0x0a, -0x79, 0x3d, 0x48, 0x5a, 0x61, -0x2c,
18012 0x6d, -0x68, -0x71, -0x6b, -0x11, 0x44, -0x75, -0x55, -0x67, -0x52, 0x64, -0x3d, -0x05, -0x76, -0x6d, -0x44,18012 0x6d, -0x68, -0x71, -0x6b, -0x11, 0x44, -0x75, -0x55, -0x67, -0x52, 0x64, -0x3d, -0x05, -0x76, -0x6d, -0x44,
18013 });18013 });
1801418014
...@@ -18035,7 +18035,7 @@ fn binary(comptime op: anytype, comptime opts: struct { compare: Compare = .rela...@@ -18035,7 +18035,7 @@ fn binary(comptime op: anytype, comptime opts: struct { compare: Compare = .rela
18035 try testArgs(@Vector(16, u8), .{18035 try testArgs(@Vector(16, u8), .{
18036 0xea, 0x80, 0xbb, 0xe8, 0x74, 0x81, 0xc8, 0x66, 0x7b, 0x41, 0x90, 0xcb, 0x30, 0x70, 0x4b, 0x0f,18036 0xea, 0x80, 0xbb, 0xe8, 0x74, 0x81, 0xc8, 0x66, 0x7b, 0x41, 0x90, 0xcb, 0x30, 0x70, 0x4b, 0x0f,
18037 }, .{18037 }, .{
18038 0x61, 0x26, 0xbe, 0x47, 0x00, 0x9c, 0x55, 0xa5, 0x59, 0xf0, 0xb2, 0x20, 0x30, 0xaf, 0x82, 0x3e,18038 0x61, 0x26, 0xbe, 0x47, 0x02, 0x9c, 0x55, 0xa5, 0x59, 0xf0, 0xb2, 0x20, 0x30, 0xaf, 0x82, 0x3e,
18039 });18039 });
18040 try testArgs(@Vector(32, u8), .{18040 try testArgs(@Vector(32, u8), .{
18041 0xa1, 0x88, 0xc4, 0xf4, 0x77, 0x0b, 0xf5, 0xbb, 0x09, 0x03, 0xbf, 0xf5, 0xcc, 0x7f, 0x6b, 0x2a,18041 0xa1, 0x88, 0xc4, 0xf4, 0x77, 0x0b, 0xf5, 0xbb, 0x09, 0x03, 0xbf, 0xf5, 0xcc, 0x7f, 0x6b, 0x2a,
...@@ -18976,12 +18976,12 @@ test addUnsafe {...@@ -18976,12 +18976,12 @@ test addUnsafe {
18976inline fn subUnsafe(comptime Type: type, lhs: Type, rhs: Type) AddOneBit(Type) {18976inline fn subUnsafe(comptime Type: type, lhs: Type, rhs: Type) AddOneBit(Type) {
18977 @setRuntimeSafety(false);18977 @setRuntimeSafety(false);
18978 switch (@typeInfo(Scalar(Type))) {18978 switch (@typeInfo(Scalar(Type))) {
18979 else => @compileError(@typeName(Type)),
18979 .int => |int| switch (int.signedness) {18980 .int => |int| switch (int.signedness) {
18980 .signed => {},18981 .signed => {},
18981 .unsigned => return @as(AddOneBit(Type), @max(lhs, rhs)) - @min(lhs, rhs),18982 .unsigned => return @as(AddOneBit(Type), @max(lhs, rhs)) - @min(lhs, rhs),
18982 },18983 },
18983 .float => {},18984 .float => {},
18984 else => @compileError(@typeName(Type)),
18985 }18985 }
18986 return @as(AddOneBit(Type), lhs) - rhs;18986 return @as(AddOneBit(Type), lhs) - rhs;
18987}18987}
...@@ -19024,42 +19024,51 @@ test divide {...@@ -19024,42 +19024,51 @@ test divide {
19024 try test_divide.testFloatVectors();19024 try test_divide.testFloatVectors();
19025}19025}
1902619026
19027// workaround https://github.com/ziglang/zig/issues/2274819027inline fn divTrunc(comptime Type: type, lhs: Type, rhs: Type) Type {
19028// TODO: @TypeOf(@divTrunc(lhs, rhs))19028 switch (@typeInfo(Scalar(Type))) {
19029inline fn divTrunc(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs / rhs) {19029 else => @compileError(@typeName(Type)),
19030 if (@inComptime()) {19030 .int => return @divTrunc(lhs, rhs),
19031 // workaround https://github.com/ziglang/zig/issues/2274819031 .float => {
19032 return @trunc(lhs / rhs);19032 if (@inComptime()) {
19033 // workaround https://github.com/ziglang/zig/issues/22748
19034 return @trunc(lhs / rhs);
19035 }
19036 // workaround https://github.com/ziglang/zig/issues/22748
19037 // workaround https://github.com/ziglang/zig/issues/22749
19038 // TODO: return @divTrunc(lhs, rhs);
19039 var rt_lhs = lhs;
19040 var rt_rhs = rhs;
19041 _ = .{ &rt_lhs, &rt_rhs };
19042 return @divTrunc(rt_lhs, rt_rhs);
19043 },
19033 }19044 }
19034 // workaround https://github.com/ziglang/zig/issues/22748
19035 // workaround https://github.com/ziglang/zig/issues/22749
19036 // TODO: return @divTrunc(lhs, rhs);
19037 var rt_lhs = lhs;
19038 var rt_rhs = rhs;
19039 _ = .{ &rt_lhs, &rt_rhs };
19040 return @divTrunc(rt_lhs, rt_rhs);
19041}19045}
19042test divTrunc {19046test divTrunc {
19043 const test_div_trunc = binary(divTrunc, .{ .compare = .approx_int });19047 const test_div_trunc = binary(divTrunc, .{ .compare = .approx_int });
19048 try test_div_trunc.testInts();
19049 try test_div_trunc.testIntVectors();
19044 try test_div_trunc.testFloats();19050 try test_div_trunc.testFloats();
19045 try test_div_trunc.testFloatVectors();19051 try test_div_trunc.testFloatVectors();
19046}19052}
1904719053
19048// workaround https://github.com/ziglang/zig/issues/2274819054inline fn divFloor(comptime Type: type, lhs: Type, rhs: Type) Type {
19049// TODO: @TypeOf(@divFloor(lhs, rhs))19055 switch (@typeInfo(Scalar(Type))) {
19050inline fn divFloor(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs / rhs) {19056 else => @compileError(@typeName(Type)),
19051 if (@inComptime()) {19057 .int => return @divFloor(lhs, rhs),
19052 // workaround https://github.com/ziglang/zig/issues/2274819058 .float => {
19053 return @floor(lhs / rhs);19059 if (@inComptime()) {
19060 // workaround https://github.com/ziglang/zig/issues/22748
19061 return @floor(lhs / rhs);
19062 }
19063 // workaround https://github.com/ziglang/zig/issues/22748
19064 // workaround https://github.com/ziglang/zig/issues/22749
19065 // TODO: return @divFloor(lhs, rhs);
19066 var rt_lhs = lhs;
19067 var rt_rhs = rhs;
19068 _ = .{ &rt_lhs, &rt_rhs };
19069 return @divFloor(rt_lhs, rt_rhs);
19070 },
19054 }19071 }
19055 // workaround https://github.com/ziglang/zig/issues/22748
19056 // workaround https://github.com/ziglang/zig/issues/22749
19057 // TODO: return @divFloor(lhs, rhs);
19058 var rt_lhs = lhs;
19059 var rt_rhs = rhs;
19060 _ = &rt_lhs;
19061 _ = &rt_rhs;
19062 return @divFloor(rt_lhs, rt_rhs);
19063}19072}
19064test divFloor {19073test divFloor {
19065 const test_div_floor = binary(divFloor, .{ .compare = .approx_int });19074 const test_div_floor = binary(divFloor, .{ .compare = .approx_int });
test/cases/safety/integer division by zero - vectors.zig +1-1
...@@ -18,5 +18,5 @@ fn div0(a: @Vector(4, i32), b: @Vector(4, i32)) @Vector(4, i32) {...@@ -18,5 +18,5 @@ fn div0(a: @Vector(4, i32), b: @Vector(4, i32)) @Vector(4, i32) {
18 return @divTrunc(a, b);18 return @divTrunc(a, b);
19}19}
20// run20// run
21// backend=llvm21// backend=stage2,llvm
22// target=native22// target=native
test/cases/safety/signed integer division overflow - vectors.zig +1-1
...@@ -19,5 +19,5 @@ fn div(a: @Vector(4, i16), b: @Vector(4, i16)) @Vector(4, i16) {...@@ -19,5 +19,5 @@ fn div(a: @Vector(4, i16), b: @Vector(4, i16)) @Vector(4, i16) {
19 return @divTrunc(a, b);19 return @divTrunc(a, b);
20}20}
21// run21// run
22// backend=llvm22// backend=stage2,llvm
23// target=native23// target=native