mirror of
https://codeberg.org/ziglang/zig.git
synced 2026-04-27 19:09:47 +03:00
x86_64: rewrite scalar and vector int @divTrunc
This commit is contained in:
Jacob Young
@@ -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");
|
||||
|
||||
|
||||
@@ -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;
|
||||
}
|
||||
@@ -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);
|
||||
|
||||
|
||||
+2769
-1103
@@ -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", ._, ._, ._ },
|
||||
} },
|
||||
}, .{
|
||||
.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", ._, ._, ._ },
|
||||
} },
|
||||
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, ._, ._, ._ },
|
||||
} },
|
||||
}) catch |err| switch (err) {
|
||||
}, .{
|
||||
.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,
|
||||
} },
|
||||
},
|
||||
.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 }), ._ },
|
||||
} },
|
||||
}, .{
|
||||
.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),
|
||||
@@ -9993,6 +10651,1003 @@ 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_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),
|
||||
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);
|
||||
},
|
||||
.rem, .rem_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, .rem) 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, .rem);
|
||||
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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 });
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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
|
||||
|
||||
Reference in New Issue
Block a user