Commit 8c48376d64
Changed files (7)
lib
compiler_rt
src
arch
x86_64
test
behavior
x86_64
lib/compiler_rt/divmodei4.zig
@@ -0,0 +1,50 @@
+const std = @import("std");
+const builtin = @import("builtin");
+const common = @import("common.zig");
+const udivmod = @import("udivmodei4.zig").divmod;
+
+comptime {
+ @export(&__divei4, .{ .name = "__divei4", .linkage = common.linkage, .visibility = common.visibility });
+ @export(&__modei4, .{ .name = "__modei4", .linkage = common.linkage, .visibility = common.visibility });
+}
+
+const endian = builtin.cpu.arch.endian();
+
+inline fn limb(x: []u32, i: usize) *u32 {
+ return if (endian == .little) &x[i] else &x[x.len - 1 - i];
+}
+
+inline fn neg(x: []u32) void {
+ var ov: u1 = 1;
+ for (0..x.len) |limb_index| {
+ const l = limb(x, limb_index);
+ l.*, ov = @addWithOverflow(~l.*, ov);
+ }
+}
+
+/// Mutates the arguments!
+fn divmod(q: ?[]u32, r: ?[]u32, u: []u32, v: []u32) !void {
+ const u_sign: i32 = @bitCast(u[u.len - 1]);
+ const v_sign: i32 = @bitCast(v[v.len - 1]);
+ if (u_sign < 0) neg(u);
+ if (v_sign < 0) neg(v);
+ try @call(.always_inline, udivmod, .{ q, r, u, v });
+ if (q) |x| if (u_sign ^ v_sign < 0) neg(x);
+ if (r) |x| if (u_sign < 0) neg(x);
+}
+
+pub fn __divei4(r_q: [*]u32, u_p: [*]u32, v_p: [*]u32, bits: usize) callconv(.C) void {
+ @setRuntimeSafety(builtin.is_test);
+ const u = u_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
+ const v = v_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
+ const q = r_q[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
+ @call(.always_inline, divmod, .{ q, null, u, v }) catch unreachable;
+}
+
+pub fn __modei4(r_p: [*]u32, u_p: [*]u32, v_p: [*]u32, bits: usize) callconv(.C) void {
+ @setRuntimeSafety(builtin.is_test);
+ const u = u_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
+ const v = v_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
+ const r = r_p[0 .. std.math.divCeil(usize, bits, 32) catch unreachable];
+ @call(.always_inline, divmod, .{ null, r, u, v }) catch unreachable;
+}
lib/compiler_rt/udivmodei4.zig
@@ -27,8 +27,8 @@ inline fn limb_set(x: []u32, i: usize, v: u32) void {
}
}
-// Uses Knuth's Algorithm D, 4.3.1, p. 272.
-fn divmod(q: ?[]u32, r: ?[]u32, u: []const u32, v: []const u32) !void {
+/// Uses Knuth's Algorithm D, 4.3.1, p. 272.
+pub fn divmod(q: ?[]u32, r: ?[]u32, u: []const u32, v: []const u32) !void {
if (q) |q_| @memset(q_[0..], 0);
if (r) |r_| @memset(r_[0..], 0);
lib/compiler_rt.zig
@@ -230,6 +230,7 @@ comptime {
_ = @import("compiler_rt/trunc.zig");
// BigInt. Alphabetically sorted.
+ _ = @import("compiler_rt/divmodei4.zig");
_ = @import("compiler_rt/udivmodei4.zig");
_ = @import("compiler_rt/udivmodti4.zig");
src/arch/x86_64/CodeGen.zig
@@ -2418,7 +2418,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
}
fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
- @setEvalBranchQuota(12_200);
+ @setEvalBranchQuota(12_300);
const pt = cg.pt;
const zcu = pt.zcu;
const ip = &zcu.intern_pool;
@@ -7785,1068 +7785,1726 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
};
try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
},
- .div_trunc, .div_floor => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else fallback: {
+ .div_trunc => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else {
const bin_op = air_datas[@intFromEnum(inst)].bin_op;
- if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airMulDivBinOp(inst, air_tag);
var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
var res: [1]Temp = undefined;
- cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, switch (@as(bits.RoundMode.Direction, switch (air_tag) {
- else => unreachable,
- .div_trunc => .zero,
- .div_floor => .down,
- })) {
- else => unreachable,
- inline .zero, .down => |direction| comptime &.{ .{
- .required_features = .{ .f16c, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .word, .is = .word } },
- .{ .scalar_float = .{ .of = .word, .is = .word } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_sse, .to_sse, .none } },
- },
- .extra_temps = .{
- .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
- .each = .{ .once = &.{
- .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
- .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
- .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },
- .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
- .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
- .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) },
- .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
- } },
- }, .{
- .required_features = .{ .sse, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .word, .is = .word } },
- .{ .scalar_float = .{ .of = .word, .is = .word } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
- },
- .call_frame = .{ .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "__trunch",
- .down => "__floorh",
- } } } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .{ .ref = .src0 }, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
- .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .f16c, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .qword, .is = .word } },
- .{ .scalar_float = .{ .of = .qword, .is = .word } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .mem, .mem, .none } },
- .{ .src = .{ .to_sse, .mem, .none } },
- .{ .src = .{ .mem, .to_sse, .none } },
- .{ .src = .{ .to_sse, .to_sse, .none } },
- },
- .extra_temps = .{
- .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
- .each = .{ .once = &.{
- .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
- .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
- .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },
- .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
- .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
- .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
- .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
- } },
- }, .{
- .required_features = .{ .f16c, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .xword, .is = .word } },
- .{ .scalar_float = .{ .of = .xword, .is = .word } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .mem, .mem, .none } },
- .{ .src = .{ .to_sse, .mem, .none } },
- .{ .src = .{ .mem, .to_sse, .none } },
- .{ .src = .{ .to_sse, .to_sse, .none } },
- },
- .extra_temps = .{
- .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
- .each = .{ .once = &.{
- .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
- .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
- .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },
- .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
- .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
- .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
- .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
- } },
- }, .{
- .required_features = .{ .f16c, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
- .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
- .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },
- .{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ },
- .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
- .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
- .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
- .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .avx, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
- .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .call_frame = .{ .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
- .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "__trunch",
- .down => "__floorh",
- } } } },
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
- .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
- .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
- .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
- .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
- .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
- .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .sse4_1, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
- .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .call_frame = .{ .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
- .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "__trunch",
- .down => "__floorh",
- } } } },
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
- .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
- .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
- .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
- .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
- .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
- .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
- .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .sse2, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
- .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .call_frame = .{ .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
- .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "__trunch",
- .down => "__floorh",
- } } } },
- .{ .type = .f16, .kind = .{ .reg = .ax } },
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
- .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
- .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
- .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
- .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
- .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
- .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
- .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
- .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .sse, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
- .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .call_frame = .{ .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .f16, .kind = .{ .reg = .ax } },
- .{ .type = .f32, .kind = .mem },
- .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
- .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "__trunch",
- .down => "__floorh",
- } } } },
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
- .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
- .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
- .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
- .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
- .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
- .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
- .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
- .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
- .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
+ .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
+ .patterns = &.{
+ .{ .src = .{ .mem, .mem, .none } },
+ .{ .src = .{ .to_gpr, .mem, .none } },
+ .{ .src = .{ .mem, .to_gpr, .none } },
+ .{ .src = .{ .to_gpr, .to_gpr, .none } },
+ },
+ .dst_temps = .{ .{ .reg = .al }, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .movsx, .dst0d, .src0b, ._, ._ },
+ .{ ._, .i_, .div, .src1b, ._, ._, ._ },
+ } },
+ }, .{
+ .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
+ .patterns = &.{
+ .{ .src = .{ .mem, .mem, .none } },
+ .{ .src = .{ .to_gpr, .mem, .none } },
+ .{ .src = .{ .mem, .to_gpr, .none } },
+ .{ .src = .{ .to_gpr, .to_gpr, .none } },
+ },
+ .dst_temps = .{ .{ .reg = .al }, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .movzx, .dst0d, .src0b, ._, ._ },
+ .{ ._, ._, .div, .src1b, ._, ._, ._ },
+ } },
+ }, .{
+ .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
+ .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .i16, .kind = .{ .reg = .dx } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .cwd, ._, ._, ._, ._ },
+ .{ ._, .i_, .div, .src1w, ._, ._, ._ },
+ } },
+ }, .{
+ .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } },
+ .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .u16, .kind = .{ .reg = .dx } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
+ .{ ._, ._, .div, .src1w, ._, ._, ._ },
+ } },
+ }, .{
+ .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
+ .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .i32, .kind = .{ .reg = .edx } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .cdq, ._, ._, ._, ._ },
+ .{ ._, .i_, .div, .src1d, ._, ._, ._ },
+ } },
+ }, .{
+ .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } },
+ .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .u32, .kind = .{ .reg = .edx } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ },
+ .{ ._, ._, .div, .src1d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .@"64bit", null, null, null },
+ .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
+ .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .i64, .kind = .{ .reg = .rdx } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .cqo, ._, ._, ._, ._ },
+ .{ ._, .i_, .div, .src1q, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .@"64bit", null, null, null },
+ .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } },
+ .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .u64, .kind = .{ .reg = .rdx } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .xor, .tmp0q, .tmp0q, ._, ._ },
+ .{ ._, ._, .div, .src1q, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .@"64bit", null, null, null },
+ .src_constraints = .{ .{ .signed_int = .xword }, .{ .signed_int = .xword }, .any },
+ .patterns = &.{
+ .{ .src = .{
+ .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 0 } },
+ .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 2 } },
+ .none,
} },
- }, .{
- .required_features = .{ .avx, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .dword, .is = .dword } },
- .{ .scalar_float = .{ .of = .dword, .is = .dword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_sse, .mem, .none } },
- .{ .src = .{ .to_sse, .to_sse, .none } },
- },
- .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
- .each = .{ .once = &.{
- .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },
- .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }) },
- } },
- }, .{
- .required_features = .{ .sse4_1, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .dword, .is = .dword } },
- .{ .scalar_float = .{ .of = .dword, .is = .dword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mut_sse, .mem, .none } },
- .{ .src = .{ .to_mut_sse, .to_sse, .none } },
- },
- .dst_temps = .{ .{ .ref = .src0 }, .unused },
- .each = .{ .once = &.{
- .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
- .{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
- } },
- }, .{
- .required_features = .{ .sse, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .dword, .is = .dword } },
- .{ .scalar_float = .{ .of = .dword, .is = .dword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
- },
- .call_frame = .{ .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "truncf",
- .down => "floorf",
- } } } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .{ .ref = .src0 }, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
- .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .avx, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .xword, .is = .dword } },
- .{ .scalar_float = .{ .of = .xword, .is = .dword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_sse, .mem, .none } },
- .{ .src = .{ .to_sse, .to_sse, .none } },
- },
- .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
- .each = .{ .once = &.{
- .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
- .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
- } },
- }, .{
- .required_features = .{ .sse4_1, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .xword, .is = .dword } },
- .{ .scalar_float = .{ .of = .xword, .is = .dword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mut_sse, .mem, .none } },
- .{ .src = .{ .to_mut_sse, .to_sse, .none } },
- },
- .dst_temps = .{ .{ .ref = .src0 }, .unused },
- .each = .{ .once = &.{
- .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
- .{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
- } },
- }, .{
- .required_features = .{ .sse, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
- .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .call_frame = .{ .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "truncf",
- .down => "floorf",
- } } } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
- .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
- .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .avx, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .yword, .is = .dword } },
- .{ .scalar_float = .{ .of = .yword, .is = .dword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_sse, .mem, .none } },
- .{ .src = .{ .to_sse, .to_sse, .none } },
- },
- .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
- .each = .{ .once = &.{
- .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
- .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
- } },
- }, .{
- .required_features = .{ .avx, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
- .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
- .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
- .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
- .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .sse4_1, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
- .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
- .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
- .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .avx, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .qword, .is = .qword } },
- .{ .scalar_float = .{ .of = .qword, .is = .qword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_sse, .mem, .none } },
- .{ .src = .{ .to_sse, .to_sse, .none } },
- },
- .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
- .each = .{ .once = &.{
- .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
- .{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = direction, .precision = .inexact }) },
- } },
- }, .{
- .required_features = .{ .sse4_1, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .qword, .is = .qword } },
- .{ .scalar_float = .{ .of = .qword, .is = .qword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mut_sse, .mem, .none } },
- .{ .src = .{ .to_mut_sse, .to_sse, .none } },
- },
- .dst_temps = .{ .{ .ref = .src0 }, .unused },
- .each = .{ .once = &.{
- .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
- .{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
- } },
- }, .{
- .required_features = .{ .sse2, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .qword, .is = .qword } },
- .{ .scalar_float = .{ .of = .qword, .is = .qword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
- },
- .call_frame = .{ .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "trunc",
- .down => "floor",
- } } } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .{ .ref = .src0 }, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
- .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .sse, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .qword, .is = .qword } },
- .{ .scalar_float = .{ .of = .qword, .is = .qword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
- },
- .call_frame = .{ .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "trunc",
- .down => "floor",
- } } } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .{ .ref = .src0 }, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
- .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .avx, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .xword, .is = .qword } },
- .{ .scalar_float = .{ .of = .xword, .is = .qword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_sse, .mem, .none } },
- .{ .src = .{ .to_sse, .to_sse, .none } },
- },
- .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
- .each = .{ .once = &.{
- .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
- .{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
- } },
- }, .{
- .required_features = .{ .sse4_1, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .xword, .is = .qword } },
- .{ .scalar_float = .{ .of = .xword, .is = .qword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mut_sse, .mem, .none } },
- .{ .src = .{ .to_mut_sse, .to_sse, .none } },
- },
- .dst_temps = .{ .{ .ref = .src0 }, .unused },
- .each = .{ .once = &.{
- .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
- .{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
- } },
- }, .{
- .required_features = .{ .avx, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .yword, .is = .qword } },
- .{ .scalar_float = .{ .of = .yword, .is = .qword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_sse, .mem, .none } },
- .{ .src = .{ .to_sse, .to_sse, .none } },
- },
- .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
- .each = .{ .once = &.{
- .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
- .{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
- } },
- }, .{
- .required_features = .{ .avx, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
- .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
- .{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
- .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
- .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .sse4_1, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
- .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = direction, .precision = .inexact }), ._ },
- .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
- .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .sse2, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
- .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .call_frame = .{ .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "trunc",
- .down => "floor",
- } } } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
- .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
- .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .sse, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
- .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .call_frame = .{ .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
- .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "trunc",
- .down => "floor",
- } } } },
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
- .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
- .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
- .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
- .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
- .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .x87, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
- .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .call_frame = .{ .size = 16, .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .f80, .kind = .{ .reg = .st6 } },
- .{ .type = .f80, .kind = .{ .reg = .st7 } },
- .{ .type = .f80, .kind = .{ .frame = .call_frame } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "__truncx",
- .down => "__floorx",
- } } } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .{ .reg = .st0 }, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
- .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
- .{ ._, .f_p, .div, ._, ._, ._, ._ },
- .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
- .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .x87, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
- .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .call_frame = .{ .size = 16, .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .f80, .kind = .{ .reg = .st6 } },
- .{ .type = .f80, .kind = .{ .reg = .st7 } },
- .{ .type = .f80, .kind = .{ .frame = .call_frame } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "__truncx",
- .down => "__floorx",
- } } } },
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
- .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
- .{ ._, .f_p, .div, ._, ._, ._, ._ },
- .{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ },
- .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
- .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
- .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
- .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .sse, null, null, null },
- .src_constraints = .{
- .{ .scalar_float = .{ .of = .xword, .is = .xword } },
- .{ .scalar_float = .{ .of = .xword, .is = .xword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
- },
- .call_frame = .{ .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "truncq",
- .down => "floorq",
- } } } },
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .{ .ref = .src0 }, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
- .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .avx, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
- .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .call_frame = .{ .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
- .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "truncq",
- .down => "floorq",
- } } } },
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
- .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
- .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
- .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .sse2, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
- .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .call_frame = .{ .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
- .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "truncq",
- .down => "floorq",
- } } } },
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
- .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
- .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
- .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
- } },
- }, .{
- .required_features = .{ .sse, null, null, null },
- .src_constraints = .{
- .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
- .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
- .any,
- },
- .patterns = &.{
- .{ .src = .{ .to_mem, .to_mem, .none } },
- },
- .call_frame = .{ .alignment = .@"16" },
- .extra_temps = .{
- .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
- .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
- .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
- .{ .type = .usize, .kind = .{ .symbol = &.{ .name = switch (direction) {
- else => unreachable,
- .zero => "truncq",
- .down => "floorq",
- } } } },
- .unused,
- .unused,
- .unused,
- .unused,
- },
- .dst_temps = .{ .mem, .unused },
- .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
- .each = .{ .once = &.{
- .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
- .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
- .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
- .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
- .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
- .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
- .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divti3" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .index = 0 } }, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .@"64bit", null, null, null },
+ .src_constraints = .{ .{ .unsigned_int = .xword }, .{ .unsigned_int = .xword }, .any },
+ .patterns = &.{
+ .{ .src = .{
+ .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 0 } },
+ .{ .to_param_gpr_pair = .{ .cc = .ccc, .index = 2 } },
+ .none,
} },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivti3" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ret_gpr_pair = .{ .cc = .ccc, .index = 0 } }, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .@"64bit", null, null, null },
+ .src_constraints = .{
+ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
+ .{ .remainder_signed_int = .{ .of = .dword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divei4" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+ .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
+ .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
+ .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .@"64bit", null, null, null },
+ .src_constraints = .{
+ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
+ .{ .remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivei4" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ },
+ .{ ._, ._, .lea, .tmp1p, .mem(.src0), ._, ._ },
+ .{ ._, ._, .lea, .tmp2p, .mem(.src1), ._, ._ },
+ .{ ._, ._, .mov, .tmp3d, .sa(.src0, .add_8_size), ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .slow_incdec, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
+ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .i8, .kind = .{ .reg = .al } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .src_constraints = .{
+ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
+ .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .i8, .kind = .{ .reg = .al } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, .i_, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
+ .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
+ .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .slow_incdec, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
+ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .u8, .kind = .{ .reg = .al } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .src_constraints = .{
+ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
+ .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .u8, .kind = .{ .reg = .al } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .div, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
+ .{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
+ .{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .src_constraints = .{
+ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
+ .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .i16, .kind = .{ .reg = .ax } },
+ .{ .type = .i16, .kind = .{ .reg = .dx } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .cwd, ._, ._, ._, ._ },
+ .{ ._, .i_, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .src_constraints = .{
+ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
+ .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .u16, .kind = .{ .reg = .ax } },
+ .{ .type = .u16, .kind = .{ .reg = .dx } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
+ .{ ._, ._, .div, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .src_constraints = .{
+ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
+ .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .i32, .kind = .{ .reg = .eax } },
+ .{ .type = .i32, .kind = .{ .reg = .edx } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .cdq, ._, ._, ._, ._ },
+ .{ ._, .i_, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .src_constraints = .{
+ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
+ .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .u32, .kind = .{ .reg = .eax } },
+ .{ .type = .u32, .kind = .{ .reg = .edx } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
+ .{ ._, ._, .div, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .@"64bit", null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
+ .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .i64, .kind = .{ .reg = .rax } },
+ .{ .type = .i64, .kind = .{ .reg = .rdx } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .cqo, ._, ._, ._, ._ },
+ .{ ._, .i_, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .@"64bit", null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
+ .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .u64, .kind = .{ .reg = .rax } },
+ .{ .type = .u64, .kind = .{ .reg = .rdx } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ },
+ .{ ._, ._, .div, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .@"64bit", null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
+ .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .xword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
+ .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
+ .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
+ .{ .type = .i64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divti3" } } },
+ .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .index = 0 } } },
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
+ .{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
+ .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+ .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ },
+ .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .@"64bit", null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
+ .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .xword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
+ .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
+ .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
+ .{ .type = .u64, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivti3" } } },
+ .{ .type = .u64, .kind = .{ .ret_gpr = .{ .cc = .ccc, .index = 0 } } },
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .mov, .tmp2q, .memiad(.src0q, .tmp0, .add_unaligned_size, 8), ._, ._ },
+ .{ ._, ._, .mov, .tmp3q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .mov, .tmp4q, .memiad(.src1q, .tmp0, .add_unaligned_size, 8), ._, ._ },
+ .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+ .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp6q, ._, ._ },
+ .{ ._, ._, .mov, .memiad(.dst0q, .tmp0, .add_unaligned_size, 8), .tmp3q, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .@"64bit", null, null, null },
+ .src_constraints = .{
+ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } },
+ .{ .scalar_remainder_signed_int = .{ .of = .dword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divei4" } } },
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ },
+ .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .@"64bit", null, null, null },
+ .src_constraints = .{
+ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
+ .{ .scalar_remainder_unsigned_int = .{ .of = .dword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mut_mem, .to_mut_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 0 } } },
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 1 } } },
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 2 } } },
+ .{ .type = .usize, .kind = .{ .param_gpr = .{ .cc = .ccc, .index = 3 } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__udivei4" } } },
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .lea, .tmp1p, .memia(.dst0, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .mov, .tmp4d, .sa(.src0, .add_8_elem_size), ._, ._ },
+ .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .f16c, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .word, .is = .word } },
+ .{ .scalar_float = .{ .of = .word, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
+ .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
+ .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },
+ .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+ .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
+ .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .zero, .precision = .inexact }) },
+ .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .word, .is = .word } },
+ .{ .scalar_float = .{ .of = .word, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .f16c, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .qword, .is = .word } },
+ .{ .scalar_float = .{ .of = .qword, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .mem, .mem, .none } },
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .mem, .to_sse, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
+ .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
+ .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },
+ .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+ .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
+ .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+ .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+ } },
+ }, .{
+ .required_features = .{ .f16c, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .xword, .is = .word } },
+ .{ .scalar_float = .{ .of = .xword, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .mem, .mem, .none } },
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .mem, .to_sse, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
+ .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
+ .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },
+ .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
+ .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
+ .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+ .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
+ } },
+ }, .{
+ .required_features = .{ .f16c, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
+ .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },
+ .{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ },
+ .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
+ .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+ .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
+ .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+ .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
+ .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse4_1, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
+ .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
+ .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+ .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
+ .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse2, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
+ .{ .type = .f16, .kind = .{ .reg = .ax } },
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
+ .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
+ .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+ .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
+ .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f16, .kind = .{ .reg = .ax } },
+ .{ .type = .f32, .kind = .mem },
+ .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__trunch" } } },
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
+ .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
+ .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
+ .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
+ .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
+ .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
+ .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
+ .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+ .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },
+ .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .zero, .precision = .inexact }) },
+ } },
+ }, .{
+ .required_features = .{ .sse4_1, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+ .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mut_sse, .mem, .none } },
+ .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
+ .{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+ .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncf" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
+ .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+ .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
+ .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse4_1, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+ .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mut_sse, .mem, .none } },
+ .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
+ .{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
+ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncf" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+ .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .yword, .is = .dword } },
+ .{ .scalar_float = .{ .of = .yword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
+ .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
} },
- }) catch |err| switch (err) {
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
+ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
+ .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+ .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse4_1, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+ .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
+ .{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = .zero, .precision = .inexact }) },
+ } },
+ }, .{
+ .required_features = .{ .sse4_1, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mut_sse, .mem, .none } },
+ .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
+ .{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse2, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
+ .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+ .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
+ .{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse4_1, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+ .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mut_sse, .mem, .none } },
+ .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
+ .{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .yword, .is = .qword } },
+ .{ .scalar_float = .{ .of = .yword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
+ .{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
+ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
+ .{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+ .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse4_1, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .zero, .precision = .inexact }), ._ },
+ .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse2, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+ .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "trunc" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
+ .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
+ .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .x87, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .size = 16, .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .f80, .kind = .{ .reg = .st6 } },
+ .{ .type = .f80, .kind = .{ .reg = .st7 } },
+ .{ .type = .f80, .kind = .{ .frame = .call_frame } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncx" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .reg = .st0 }, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+ .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
+ .{ ._, .f_p, .div, ._, ._, ._, ._ },
+ .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .x87, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .size = 16, .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f80, .kind = .{ .reg = .st6 } },
+ .{ .type = .f80, .kind = .{ .reg = .st7 } },
+ .{ .type = .f80, .kind = .{ .frame = .call_frame } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__truncx" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, .f_p, .div, ._, ._, ._, ._ },
+ .{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
+ .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .xword, .is = .xword } },
+ .{ .scalar_float = .{ .of = .xword, .is = .xword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse2, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "truncq" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ } }) catch |err| switch (err) {
error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
@tagName(air_tag),
cg.typeOf(bin_op.lhs).fmt(pt),
@@ -9982,7 +10640,1004 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
} },
- }) catch |err| switch (err) {
+ }) catch |err| switch (err) {
+ error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
+ @tagName(air_tag),
+ cg.typeOf(bin_op.lhs).fmt(pt),
+ ops[0].tracking(cg),
+ ops[1].tracking(cg),
+ }),
+ else => |e| return e,
+ };
+ try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
+ },
+ .div_floor => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else fallback: {
+ const bin_op = air_datas[@intFromEnum(inst)].bin_op;
+ if (cg.floatBits(cg.typeOf(bin_op.lhs).scalarType(zcu)) == null) break :fallback try cg.airMulDivBinOp(inst, air_tag);
+ var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
+ var res: [1]Temp = undefined;
+ cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{
+ .required_features = .{ .f16c, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .word, .is = .word } },
+ .{ .scalar_float = .{ .of = .word, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
+ .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
+ .{ ._, .v_ss, .div, .dst0x, .dst0x, .tmp0d, ._ },
+ .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+ .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
+ .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .down, .precision = .inexact }) },
+ .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .word, .is = .word } },
+ .{ .scalar_float = .{ .of = .word, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .f16c, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .qword, .is = .word } },
+ .{ .scalar_float = .{ .of = .qword, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .mem, .mem, .none } },
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .mem, .to_sse, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .vector_4_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_ps, .cvtph2, .dst0x, .src0q, ._, ._ },
+ .{ ._, .v_ps, .cvtph2, .tmp0x, .src1q, ._, ._ },
+ .{ ._, .v_ps, .div, .dst0x, .dst0x, .tmp0x, ._ },
+ .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+ .{ ._, .v_ps, .cvtph2, .dst0x, .dst0q, ._, ._ },
+ .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+ .{ ._, .v_, .cvtps2ph, .dst0q, .dst0x, .rm(.{}), ._ },
+ } },
+ }, .{
+ .required_features = .{ .f16c, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .xword, .is = .word } },
+ .{ .scalar_float = .{ .of = .xword, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .mem, .mem, .none } },
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .mem, .to_sse, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .vector_8_f32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .sse } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_ps, .cvtph2, .dst0y, .src0x, ._, ._ },
+ .{ ._, .v_ps, .cvtph2, .tmp0y, .src1x, ._, ._ },
+ .{ ._, .v_ps, .div, .dst0y, .dst0y, .tmp0y, ._ },
+ .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
+ .{ ._, .v_ps, .cvtph2, .dst0y, .dst0x, ._, ._ },
+ .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+ .{ ._, .v_, .cvtps2ph, .dst0x, .dst0y, .rm(.{}), ._ },
+ } },
+ }, .{
+ .required_features = .{ .f16c, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
+ .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .v_ps, .cvtph2, .tmp1y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, .v_ps, .cvtph2, .tmp2y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .tmp2y, ._ },
+ .{ ._, .v_, .cvtps2ph, .tmp1x, .tmp1y, .rm(.{}), ._ },
+ .{ ._, .v_ps, .cvtph2, .tmp1y, .tmp1x, ._, ._ },
+ .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+ .{ ._, .v_, .cvtps2ph, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1y, .rm(.{}), ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ },
+ .{ ._, .vp_w, .insr, .tmp1x, .tmp2x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0) },
+ .{ ._, .vp_w, .insr, .tmp2x, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0) },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ ._, .vp_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
+ .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse4_1, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
+ .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
+ .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+ .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ ._, .p_w, .extr, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1x, .ui(0), ._ },
+ .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse2, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
+ .{ .type = .f16, .kind = .{ .reg = .ax } },
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .p_, .xor, .tmp1x, .tmp1x, ._, ._ },
+ .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ },
+ .{ ._, .p_w, .insr, .tmp1x, .memia(.src0w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+ .{ ._, .p_w, .insr, .tmp2x, .memia(.src1w, .tmp0, .add_unaligned_size), .ui(0), ._ },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ ._, .p_w, .extr, .tmp5d, .tmp1x, .ui(0), ._ },
+ .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp5w, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .{ .multiple_scalar_float = .{ .of = .word, .is = .word } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f16, .kind = .{ .reg = .ax } },
+ .{ .type = .f32, .kind = .mem },
+ .{ .type = .f16, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f16, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divhf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorh" } } },
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
+ .{ ._, ._ss, .mov, .tmp3x, .mem(.tmp2d), ._, ._ },
+ .{ ._, ._, .movzx, .tmp1d, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .mov, .mem(.tmp2d), .tmp1d, ._, ._ },
+ .{ ._, ._ss, .mov, .tmp4x, .mem(.tmp2d), ._, ._ },
+ .{ ._, ._, .call, .tmp5d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp6d, ._, ._, ._ },
+ .{ ._, ._ss, .mov, .mem(.tmp2d), .tmp3x, ._, ._ },
+ .{ ._, ._, .mov, .tmp1d, .mem(.tmp2d), ._, ._ },
+ .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+ .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_ss, .div, .dst0x, .src0x, .src1d, ._ },
+ .{ ._, .v_ss, .round, .dst0x, .dst0x, .dst0d, .rm(.{ .direction = .down, .precision = .inexact }) },
+ } },
+ }, .{
+ .required_features = .{ .sse4_1, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+ .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mut_sse, .mem, .none } },
+ .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
+ .{ ._, ._ss, .round, .dst0x, .dst0d, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+ .{ .scalar_float = .{ .of = .dword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorf" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._ss, .div, .dst0x, .src1d, ._, ._ },
+ .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+ .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_ps, .div, .dst0x, .src0x, .src1x, ._ },
+ .{ ._, .v_ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse4_1, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+ .{ .scalar_float = .{ .of = .xword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mut_sse, .mem, .none } },
+ .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, ._ps, .div, .dst0x, .src1x, ._, ._ },
+ .{ ._, ._ps, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
+ .{ .multiple_scalar_float = .{ .of = .dword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f32, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorf" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._ss, .mov, .tmp1x, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._ss, .div, .tmp1x, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+ .{ ._, ._ss, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .yword, .is = .dword } },
+ .{ .scalar_float = .{ .of = .yword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_ps, .div, .dst0y, .src0y, .src1y, ._ },
+ .{ ._, .v_ps, .round, .dst0y, .dst0y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
+ .{ .multiple_scalar_float = .{ .of = .yword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .vector_8_f32, .kind = .{ .rc = .sse } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .v_ps, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, .v_ps, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
+ .{ ._, .v_ps, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+ .{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse4_1, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .dword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .vector_4_f32, .kind = .{ .rc = .sse } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._ps, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._ps, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+ .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_sd, .div, .dst0x, .src0x, .src1q, ._ },
+ .{ ._, .v_sd, .round, .dst0x, .dst0x, .dst0q, .rm(.{ .direction = .down, .precision = .inexact }) },
+ } },
+ }, .{
+ .required_features = .{ .sse4_1, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mut_sse, .mem, .none } },
+ .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
+ .{ ._, ._sd, .round, .dst0x, .dst0q, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse2, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .xmm0 }, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._sd, .div, .dst0x, .src1q, ._, ._ },
+ .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .{ .scalar_float = .{ .of = .qword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+ .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_pd, .div, .dst0x, .src0x, .src1x, ._ },
+ .{ ._, .v_pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse4_1, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+ .{ .scalar_float = .{ .of = .xword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mut_sse, .mem, .none } },
+ .{ .src = .{ .to_mut_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, ._pd, .div, .dst0x, .src1x, ._, ._ },
+ .{ ._, ._pd, .round, .dst0x, .dst0x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .yword, .is = .qword } },
+ .{ .scalar_float = .{ .of = .yword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_sse, .mem, .none } },
+ .{ .src = .{ .to_sse, .to_sse, .none } },
+ },
+ .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
+ .each = .{ .once = &.{
+ .{ ._, .v_pd, .div, .dst0y, .src0y, .src1y, ._ },
+ .{ ._, .v_pd, .round, .dst0y, .dst0y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
+ .{ .multiple_scalar_float = .{ .of = .yword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .vector_4_f64, .kind = .{ .rc = .sse } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .v_pd, .mova, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, .v_pd, .div, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
+ .{ ._, .v_pd, .round, .tmp1y, .tmp1y, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+ .{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse4_1, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .vector_2_f64, .kind = .{ .rc = .sse } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._pd, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._pd, .div, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._pd, .round, .tmp1x, .tmp1x, .rm(.{ .direction = .down, .precision = .inexact }), ._ },
+ .{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse2, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._sd, .mov, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._sd, .div, .tmp1x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .call, .tmp2d, ._, ._, ._ },
+ .{ ._, ._sd, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+ .{ .multiple_scalar_float = .{ .of = .qword, .is = .qword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f64, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f64, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divdf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floor" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._ps, .xor, .tmp1x, .tmp1x, ._, ._ },
+ .{ ._, ._ps, .xor, .tmp2x, .tmp2x, ._, ._ },
+ .{ ._, ._ps, .movl, .tmp1x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._ps, .movl, .tmp2x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ ._, ._ps, .movl, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .x87, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+ .{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .size = 16, .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .f80, .kind = .{ .reg = .st6 } },
+ .{ .type = .f80, .kind = .{ .reg = .st7 } },
+ .{ .type = .f80, .kind = .{ .frame = .call_frame } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorx" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .reg = .st0 }, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, .f_, .ld, .src0t, ._, ._, ._ },
+ .{ ._, .f_, .ld, .src1t, ._, ._, ._ },
+ .{ ._, .f_p, .div, ._, ._, ._, ._ },
+ .{ ._, .f_p, .st, .mem(.tmp2t), ._, ._, ._ },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .x87, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .tbyte } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .size = 16, .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f80, .kind = .{ .reg = .st6 } },
+ .{ .type = .f80, .kind = .{ .reg = .st7 } },
+ .{ .type = .f80, .kind = .{ .frame = .call_frame } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__floorx" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .f_, .ld, .memia(.src0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, .f_, .ld, .memia(.src1t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, .f_p, .div, ._, ._, ._, ._ },
+ .{ ._, .f_p, .st, .mem(.tmp3t), ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ .pseudo, .f_cstp, .de, ._, ._, ._, ._ },
+ .{ ._, .f_p, .st, .memia(.dst0t, .tmp0, .add_unaligned_size), ._, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .scalar_float = .{ .of = .xword, .is = .xword } },
+ .{ .scalar_float = .{ .of = .xword, .is = .xword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .{ .to_reg = .xmm0 }, .{ .to_reg = .xmm1 }, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .{ .ref = .src0 }, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .call, .tmp0d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp1d, ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .avx, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse2, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ }, .{
+ .required_features = .{ .sse, null, null, null },
+ .src_constraints = .{
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+ .{ .multiple_scalar_float = .{ .of = .xword, .is = .xword } },
+ .any,
+ },
+ .patterns = &.{
+ .{ .src = .{ .to_mem, .to_mem, .none } },
+ },
+ .call_frame = .{ .alignment = .@"16" },
+ .extra_temps = .{
+ .{ .type = .isize, .kind = .{ .rc = .general_purpose } },
+ .{ .type = .f128, .kind = .{ .reg = .xmm0 } },
+ .{ .type = .f128, .kind = .{ .reg = .xmm1 } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "__divtf3" } } },
+ .{ .type = .usize, .kind = .{ .symbol = &.{ .name = "floorq" } } },
+ .unused,
+ .unused,
+ .unused,
+ .unused,
+ },
+ .dst_temps = .{ .mem, .unused },
+ .clobbers = .{ .eflags = true, .caller_preserved = .ccc },
+ .each = .{ .once = &.{
+ .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
+ .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
+ .{ ._, ._, .call, .tmp3d, ._, ._, ._ },
+ .{ ._, ._, .call, .tmp4d, ._, ._, ._ },
+ .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
+ .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
+ .{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
+ } },
+ } }) catch |err| switch (err) {
error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{
@tagName(air_tag),
cg.typeOf(bin_op.lhs).fmt(pt),
@@ -37825,7 +39480,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu));
try cg.spillEflagsIfOccupied();
var ops = try cg.tempsFromOperands(inst, .{un_op});
- while (try ops[0].toBase(cg)) {}
+ while (try ops[0].toBase(false, cg)) {}
try cg.asmMemoryImmediate(
.{ ._, .cmp },
try ops[0].tracking(cg).short.mem(cg, .{
@@ -37850,7 +39505,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
const opt_child_abi_size: u31 = @intCast(opt_child_ty.abiSize(zcu));
try cg.spillEflagsIfOccupied();
var ops = try cg.tempsFromOperands(inst, .{un_op});
- while (try ops[0].toBase(cg)) {}
+ while (try ops[0].toBase(false, cg)) {}
try cg.asmMemoryImmediate(
.{ ._, .cmp },
try ops[0].tracking(cg).short.mem(cg, .{
@@ -37921,7 +39576,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
try cg.spillEflagsIfOccupied();
var ops = try cg.tempsFromOperands(inst, .{un_op});
- while (try ops[0].toBase(cg)) {}
+ while (try ops[0].toBase(false, cg)) {}
try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{
.size = cg.memSize(eu_err_ty),
.disp = eu_err_off,
@@ -37937,7 +39592,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
const eu_err_off: u31 = @intCast(codegen.errUnionErrorOffset(eu_pl_ty, zcu));
try cg.spillEflagsIfOccupied();
var ops = try cg.tempsFromOperands(inst, .{un_op});
- while (try ops[0].toBase(cg)) {}
+ while (try ops[0].toBase(false, cg)) {}
try cg.asmMemoryImmediate(.{ ._, .cmp }, try ops[0].tracking(cg).short.mem(cg, .{
.size = cg.memSize(eu_err_ty),
.disp = eu_err_off,
@@ -88424,7 +90079,7 @@ const Temp = struct {
try cg.register_manager.getReg(new_reg, new_temp_index.toIndex());
cg.temp_type[@intFromEnum(new_temp_index)] = ty;
new_temp_index.tracking(cg).* = .init(.{ .register = new_reg });
- while (try temp.toBase(cg)) {}
+ while (try temp.toBase(false, cg)) {}
try temp.readTo(ty, .{ .register = new_reg }, .{}, cg);
try temp.die(cg);
temp.* = .{ .index = new_temp_index.toIndex() };
@@ -88447,7 +90102,7 @@ const Temp = struct {
for (new_regs) |new_reg| try cg.register_manager.getReg(new_reg, new_temp_index.toIndex());
cg.temp_type[@intFromEnum(new_temp_index)] = ty;
new_temp_index.tracking(cg).* = .init(.{ .register_pair = new_regs });
- while (try temp.toBase(cg)) {}
+ while (try temp.toBase(false, cg)) {}
for (new_regs, 0..) |new_reg, reg_index| try temp.readTo(
.usize,
.{ .register = new_reg },
@@ -88548,9 +90203,9 @@ const Temp = struct {
}
}
- fn toMemory(temp: *Temp, cg: *CodeGen) InnerError!bool {
+ fn toMemory(temp: *Temp, mut: bool, cg: *CodeGen) InnerError!bool {
const temp_tracking = temp.tracking(cg);
- if (temp_tracking.short.isMemory()) return false;
+ if ((!mut or temp.isMut(cg)) and temp_tracking.short.isMemory()) return false;
const new_temp_index = cg.next_temp_index;
const ty = temp.typeOf(cg);
cg.temp_type[@intFromEnum(new_temp_index)] = ty;
@@ -88564,10 +90219,10 @@ const Temp = struct {
}
// hack around linker relocation bugs
- fn toBase(temp: *Temp, cg: *CodeGen) InnerError!bool {
+ fn toBase(temp: *Temp, mut: bool, cg: *CodeGen) InnerError!bool {
const temp_tracking = temp.tracking(cg);
- if (temp_tracking.short.isBase()) return false;
- if (try temp.toMemory(cg)) return true;
+ if ((!mut or temp.isMut(cg)) and temp_tracking.short.isBase()) return false;
+ if (try temp.toMemory(mut, cg)) return true;
const new_temp_index = cg.next_temp_index;
cg.temp_type[@intFromEnum(new_temp_index)] = temp.typeOf(cg);
const new_reg =
@@ -88722,7 +90377,7 @@ const Temp = struct {
fn read(src: *Temp, val_ty: Type, opts: AccessOptions, cg: *CodeGen) InnerError!Temp {
var val = try cg.tempAlloc(val_ty);
- while (try src.toBase(cg)) {}
+ while (try src.toBase(false, cg)) {}
try src.readTo(val_ty, val.tracking(cg).short, opts, cg);
return val;
}
@@ -88763,8 +90418,8 @@ const Temp = struct {
fn write(dst: *Temp, val: *Temp, opts: AccessOptions, cg: *CodeGen) InnerError!void {
const val_ty = val.typeOf(cg);
- while (try dst.toBase(cg)) {}
- val_to_gpr: while (true) : (while (try dst.toBase(cg) or
+ while (try dst.toBase(false, cg)) {}
+ val_to_gpr: while (true) : (while (try dst.toBase(false, cg) or
try val.toRegClass(false, .general_purpose, cg))
{}) {
const val_mcv = val.tracking(cg).short;
@@ -90770,7 +92425,8 @@ const Select = struct {
fn convert(src: Src, temp: *Temp, cg: *CodeGen) InnerError!bool {
return switch (src) {
.none, .imm8, .imm16, .imm32, .simm32 => false,
- .mem, .to_mem, .mut_mem, .to_mut_mem => try temp.toBase(cg),
+ .mem, .to_mem => try temp.toBase(false, cg),
+ .mut_mem, .to_mut_mem => try temp.toBase(true, cg),
.to_reg => |reg| try temp.toReg(reg, cg),
.to_reg_pair => |regs| try temp.toRegPair(regs, cg),
.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 {
rc_mask: struct { rc: Register.Class, info: MaskInfo },
mut_rc_mask: struct { ref: Select.Operand.Ref, rc: Register.Class, info: MaskInfo },
mem,
+ mem_of_type: Select.Operand.Ref,
smin_mem: ConstSpec,
smax_mem: ConstSpec,
umin_mem: ConstSpec,
@@ -90835,9 +92492,9 @@ const Select = struct {
const CallConvRegSpec = struct {
cc: Case.CallConv,
- index: u1,
+ index: u2,
- fn tag(spec: CallConvRegSpec, cg: *CodeGen) std.builtin.CallingConvention.Tag {
+ fn tag(spec: CallConvRegSpec, cg: *const CodeGen) std.builtin.CallingConvention.Tag {
return switch (spec.cc) {
.none => unreachable,
.ccc => cg.target.cCallingConvention().?,
@@ -90846,27 +92503,39 @@ const Select = struct {
}
};
- fn finish(kind: Kind, temp: Temp, s: *const Select) void {
- switch (kind) {
- else => {},
- inline .rc_mask, .mut_rc_mask, .ref_mask => |mask| temp.asMask(mask.info, s.cg),
+ fn lock(kind: Kind, cg: *CodeGen) ![2]?RegisterLock {
+ var reg_locks: [2]?RegisterLock = @splat(null);
+ const regs: [2]Register = switch (kind) {
+ else => return reg_locks,
+ .reg => |reg| .{ reg, .none },
+ .reg_pair => |regs| regs,
+ .param_gpr => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index..][0..1].* ++ .{.none},
+ .param_gpr_pair => |param_spec| abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index..][0..2].*,
+ .ret_gpr => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..1].* ++ .{.none},
+ .ret_gpr_pair => |ret_spec| abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*,
+ };
+ for (regs, ®_locks) |reg, *reg_lock| {
+ if (reg == .none) continue;
+ const reg_index = RegisterManager.indexOfRegIntoTracked(reg) orelse continue;
+ try cg.register_manager.getRegIndex(reg_index, null);
+ reg_lock.* = cg.register_manager.lockRegIndex(reg_index);
}
+ return reg_locks;
}
- fn pass(kind: Kind) u2 {
- return switch (kind) {
- .unused => 0,
- .reg, .reg_pair, .param_gpr, .param_gpr_pair, .ret_gpr, .ret_gpr_pair => 1,
- else => 2,
- };
+ fn finish(kind: Kind, temp: Temp, cg: *CodeGen) void {
+ switch (kind) {
+ else => {},
+ inline .rc_mask, .mut_rc_mask, .ref_mask => |mask| temp.asMask(mask.info, cg),
+ }
}
};
- fn create(spec: TempSpec, s: *Select) InnerError!struct { Temp, bool } {
+ fn create(spec: TempSpec, s: *const Select) InnerError!struct { Temp, bool } {
const cg = s.cg;
const pt = cg.pt;
return switch (spec.kind) {
- .unused => unreachable,
+ .unused => .{ undefined, false },
.any => .{ try cg.tempAlloc(spec.type), true },
.cc => |cc| .{ try cg.tempInit(spec.type, .{ .eflags = cc }), true },
.ref => |ref| .{ ref.tempOf(s), false },
@@ -90882,7 +92551,7 @@ const Select = struct {
.register = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index],
}), true },
.ret_gpr_pair => |ret_spec| .{ try cg.tempInit(spec.type, .{
- .register_pair = abi.getCAbiIntParamRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*,
+ .register_pair = abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*,
}), true },
.rc => |rc| .{ try cg.tempAllocReg(spec.type, regSetForRegClass(rc)), true },
.rc_pair => |rc| .{ try cg.tempAllocRegPair(spec.type, regSetForRegClass(rc)), true },
@@ -90907,6 +92576,7 @@ const Select = struct {
return .{ try cg.tempAllocReg(spec.type, regSetForRegClass(ref_rc_mask.rc)), true };
},
.mem => .{ try cg.tempAllocMem(spec.type), true },
+ .mem_of_type => |ref| .{ try cg.tempAllocMem(ref.typeOf(s)), true },
.smin_mem, .smax_mem, .umin_mem, .umax_mem, .@"0x1p63_mem" => |const_spec| {
const zcu = pt.zcu;
const ip = &zcu.intern_pool;
@@ -91922,15 +93592,10 @@ fn select(
@memcpy(s_src_temps[0..src_temps.len], src_temps);
std.mem.swap(Temp, &s_src_temps[pattern.commute[0]], &s_src_temps[pattern.commute[1]]);
- for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) |*dst_temp, dst_ty, dst_kind| {
- if (dst_kind.pass() != 1) continue;
- dst_temp.*, _ = try Select.TempSpec.create(.{ .type = dst_ty, .kind = dst_kind }, &s);
- }
- var tmp_owned: [s_tmp_temps.len]bool = @splat(false);
- for (1..3) |pass| for (s_tmp_temps, &tmp_owned, case.extra_temps) |*temp, *owned, spec| {
- if (spec.kind.pass() != pass) continue;
- temp.*, owned.* = try spec.create(&s);
- };
+ var dst_locks: [s_dst_temps.len][2]?RegisterLock = @splat(@splat(null));
+ 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);
+ var tmp_locks: [s_tmp_temps.len][2]?RegisterLock = @splat(@splat(null));
+ for (&tmp_locks, case.extra_temps) |*tmp_lock, tmp_spec| tmp_lock.* = try tmp_spec.kind.lock(cg);
while (true) for (pattern.src[0..src_temps.len], src_temps) |src_pattern, *src_temp| {
if (try src_pattern.convert(src_temp, cg)) break;
@@ -91940,10 +93605,9 @@ fn select(
if (case.clobbers.eflags) try cg.spillEflagsIfOccupied();
- for (dst_temps, dst_tys, case.dst_temps[0..dst_temps.len]) |*dst_temp, dst_ty, dst_kind| {
- if (dst_kind.pass() != 2) continue;
- dst_temp.*, _ = try Select.TempSpec.create(.{ .type = dst_ty, .kind = dst_kind }, &s);
- }
+ var tmp_owned: [s_tmp_temps.len]bool = @splat(false);
+ for (s_tmp_temps, &tmp_owned, case.extra_temps) |*temp, *owned, tmp_spec| temp.*, owned.* = try tmp_spec.create(&s);
+ 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);
@memcpy(s_dst_temps[0..dst_temps.len], dst_temps);
switch (case.each) {
@@ -91954,6 +93618,8 @@ fn select(
}
assert(s.top == 0);
+ for (tmp_locks) |locks| for (locks) |lock| if (lock) |reg| cg.register_manager.unlockReg(reg);
+ for (dst_locks) |locks| for (locks) |lock| if (lock) |reg| cg.register_manager.unlockReg(reg);
caller_preserved: {
const cc = switch (case.clobbers.caller_preserved) {
.none => break :caller_preserved,
@@ -91972,7 +93638,7 @@ fn select(
},
}
}
- for (dst_temps, case.dst_temps[0..dst_temps.len]) |dst_temp, dst_kind| dst_kind.finish(dst_temp, &s);
+ for (dst_temps, case.dst_temps[0..dst_temps.len]) |dst_temp, tmp_kind| tmp_kind.finish(dst_temp, cg);
for (tmp_owned, s_tmp_temps) |owned, temp| if (owned) try temp.die(cg);
return;
}
test/behavior/x86_64/math.zig
@@ -17978,8 +17978,8 @@ fn binary(comptime op: anytype, comptime opts: struct { compare: Compare = .rela
-0x12, -0x1e, 0x18, 0x6e, 0x31, 0x53, -0x6a, -0x34, 0x13, 0x4d, 0x30, -0x7d, -0x31, 0x1e, -0x24, 0x32,
-0x1e, -0x01, 0x55, 0x33, -0x75, -0x44, -0x57, 0x2b, -0x66, 0x19, 0x7f, -0x28, -0x3f, -0x7e, -0x5d, -0x06,
}, .{
- 0x05, -0x23, 0x43, -0x54, -0x41, 0x7f, -0x6a, -0x31, 0x04, 0x15, -0x7a, -0x37, 0x6d, 0x16, 0x00, 0x4a,
- 0x15, 0x55, -0x4a, 0x16, -0x73, -0x0c, 0x1c, -0x26, -0x14, 0x00, 0x55, 0x7b, 0x16, -0x2e, -0x5f, -0x67,
+ 0x05, -0x23, 0x43, -0x54, -0x41, 0x7f, -0x6a, -0x31, 0x04, 0x15, -0x7a, -0x37, 0x6d, 0x16, 0x01, 0x4a,
+ 0x15, 0x55, -0x4a, 0x16, -0x73, -0x0c, 0x1c, -0x26, -0x14, -0x01, 0x55, 0x7b, 0x16, -0x2e, -0x5f, -0x67,
});
try testArgs(@Vector(64, i8), .{
-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
0x23, 0x3b, 0x0a, 0x7a, 0x19, 0x14, 0x65, -0x1d, 0x2b, 0x65, 0x33, 0x2a, 0x52, -0x63, 0x57, 0x10,
-0x1b, 0x26, -0x46, -0x7e, -0x25, 0x79, -0x01, -0x0d, -0x49, -0x4d, 0x74, 0x03, 0x77, 0x16, 0x03, -0x3d,
0x1c, 0x25, 0x5a, -0x2f, -0x16, -0x5f, -0x36, -0x55, -0x44, -0x0c, -0x0f, 0x7b, -0x15, -0x1d, 0x32, 0x31,
- 0x6e, -0x44, -0x4a, -0x64, 0x67, 0x04, 0x47, 0x00, 0x3c, -0x0a, -0x79, 0x3d, 0x48, 0x5a, 0x61, -0x2c,
+ 0x6e, -0x44, -0x4a, -0x64, 0x67, 0x04, 0x47, -0x02, 0x3c, -0x0a, -0x79, 0x3d, 0x48, 0x5a, 0x61, -0x2c,
0x6d, -0x68, -0x71, -0x6b, -0x11, 0x44, -0x75, -0x55, -0x67, -0x52, 0x64, -0x3d, -0x05, -0x76, -0x6d, -0x44,
});
@@ -18035,7 +18035,7 @@ fn binary(comptime op: anytype, comptime opts: struct { compare: Compare = .rela
try testArgs(@Vector(16, u8), .{
0xea, 0x80, 0xbb, 0xe8, 0x74, 0x81, 0xc8, 0x66, 0x7b, 0x41, 0x90, 0xcb, 0x30, 0x70, 0x4b, 0x0f,
}, .{
- 0x61, 0x26, 0xbe, 0x47, 0x00, 0x9c, 0x55, 0xa5, 0x59, 0xf0, 0xb2, 0x20, 0x30, 0xaf, 0x82, 0x3e,
+ 0x61, 0x26, 0xbe, 0x47, 0x02, 0x9c, 0x55, 0xa5, 0x59, 0xf0, 0xb2, 0x20, 0x30, 0xaf, 0x82, 0x3e,
});
try testArgs(@Vector(32, u8), .{
0xa1, 0x88, 0xc4, 0xf4, 0x77, 0x0b, 0xf5, 0xbb, 0x09, 0x03, 0xbf, 0xf5, 0xcc, 0x7f, 0x6b, 0x2a,
@@ -18976,12 +18976,12 @@ test addUnsafe {
inline fn subUnsafe(comptime Type: type, lhs: Type, rhs: Type) AddOneBit(Type) {
@setRuntimeSafety(false);
switch (@typeInfo(Scalar(Type))) {
+ else => @compileError(@typeName(Type)),
.int => |int| switch (int.signedness) {
.signed => {},
.unsigned => return @as(AddOneBit(Type), @max(lhs, rhs)) - @min(lhs, rhs),
},
.float => {},
- else => @compileError(@typeName(Type)),
}
return @as(AddOneBit(Type), lhs) - rhs;
}
@@ -19024,42 +19024,51 @@ test divide {
try test_divide.testFloatVectors();
}
-// workaround https://github.com/ziglang/zig/issues/22748
-// TODO: @TypeOf(@divTrunc(lhs, rhs))
-inline fn divTrunc(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs / rhs) {
- if (@inComptime()) {
- // workaround https://github.com/ziglang/zig/issues/22748
- return @trunc(lhs / rhs);
+inline fn divTrunc(comptime Type: type, lhs: Type, rhs: Type) Type {
+ switch (@typeInfo(Scalar(Type))) {
+ else => @compileError(@typeName(Type)),
+ .int => return @divTrunc(lhs, rhs),
+ .float => {
+ if (@inComptime()) {
+ // workaround https://github.com/ziglang/zig/issues/22748
+ return @trunc(lhs / rhs);
+ }
+ // workaround https://github.com/ziglang/zig/issues/22748
+ // workaround https://github.com/ziglang/zig/issues/22749
+ // TODO: return @divTrunc(lhs, rhs);
+ var rt_lhs = lhs;
+ var rt_rhs = rhs;
+ _ = .{ &rt_lhs, &rt_rhs };
+ return @divTrunc(rt_lhs, rt_rhs);
+ },
}
- // workaround https://github.com/ziglang/zig/issues/22748
- // workaround https://github.com/ziglang/zig/issues/22749
- // TODO: return @divTrunc(lhs, rhs);
- var rt_lhs = lhs;
- var rt_rhs = rhs;
- _ = .{ &rt_lhs, &rt_rhs };
- return @divTrunc(rt_lhs, rt_rhs);
}
test divTrunc {
const test_div_trunc = binary(divTrunc, .{ .compare = .approx_int });
+ try test_div_trunc.testInts();
+ try test_div_trunc.testIntVectors();
try test_div_trunc.testFloats();
try test_div_trunc.testFloatVectors();
}
-// workaround https://github.com/ziglang/zig/issues/22748
-// TODO: @TypeOf(@divFloor(lhs, rhs))
-inline fn divFloor(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs / rhs) {
- if (@inComptime()) {
- // workaround https://github.com/ziglang/zig/issues/22748
- return @floor(lhs / rhs);
+inline fn divFloor(comptime Type: type, lhs: Type, rhs: Type) Type {
+ switch (@typeInfo(Scalar(Type))) {
+ else => @compileError(@typeName(Type)),
+ .int => return @divFloor(lhs, rhs),
+ .float => {
+ if (@inComptime()) {
+ // workaround https://github.com/ziglang/zig/issues/22748
+ return @floor(lhs / rhs);
+ }
+ // workaround https://github.com/ziglang/zig/issues/22748
+ // workaround https://github.com/ziglang/zig/issues/22749
+ // TODO: return @divFloor(lhs, rhs);
+ var rt_lhs = lhs;
+ var rt_rhs = rhs;
+ _ = .{ &rt_lhs, &rt_rhs };
+ return @divFloor(rt_lhs, rt_rhs);
+ },
}
- // workaround https://github.com/ziglang/zig/issues/22748
- // workaround https://github.com/ziglang/zig/issues/22749
- // TODO: return @divFloor(lhs, rhs);
- var rt_lhs = lhs;
- var rt_rhs = rhs;
- _ = &rt_lhs;
- _ = &rt_rhs;
- return @divFloor(rt_lhs, rt_rhs);
}
test divFloor {
const test_div_floor = binary(divFloor, .{ .compare = .approx_int });
test/cases/safety/integer division by zero - vectors.zig
@@ -18,5 +18,5 @@ fn div0(a: @Vector(4, i32), b: @Vector(4, i32)) @Vector(4, i32) {
return @divTrunc(a, b);
}
// run
-// backend=llvm
+// backend=stage2,llvm
// target=native
test/cases/safety/signed integer division overflow - vectors.zig
@@ -19,5 +19,5 @@ fn div(a: @Vector(4, i16), b: @Vector(4, i16)) @Vector(4, i16) {
return @divTrunc(a, b);
}
// run
-// backend=llvm
+// backend=stage2,llvm
// target=native