Mirrors/zig
1
0
Fork 0
mirror of https://codeberg.org/ziglang/zig.git synced 2026-04-27 19:09:47 +03:00
Code Issues Packages Projects Releases Wiki Activity

x86_64: rewrite wrapping multiplication

Browse Source
This commit is contained in:
Jacob Young
2025-03-11 18:24:37 -04:00
parent ed284c1f98
commit c5c1c8538d
14 changed files with 2917 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lib/std/zig/Zir.zig
+5 -1
View File
@@ -2136,7 +2136,7 @@ pub const Inst = struct {
ref_start_index = static_len,
_,
pub const static_len = 93;
pub const static_len = 97;
pub fn toRef(i: Index) Inst.Ref {
return @enumFromInt(@intFromEnum(Index.ref_start_index) + @intFromEnum(i));
@@ -2221,6 +2221,10 @@ pub const Inst = struct {
slice_const_u8_sentinel_0_type,
vector_16_i8_type,
vector_32_i8_type,
vector_1_u8_type,
vector_2_u8_type,
vector_4_u8_type,
vector_8_u8_type,
vector_16_u8_type,
vector_32_u8_type,
vector_8_i16_type,
src/Air.zig
+4
View File
@@ -985,6 +985,10 @@ pub const Inst = struct {
slice_const_u8_sentinel_0_type = @intFromEnum(InternPool.Index.slice_const_u8_sentinel_0_type),
vector_16_i8_type = @intFromEnum(InternPool.Index.vector_16_i8_type),
vector_32_i8_type = @intFromEnum(InternPool.Index.vector_32_i8_type),
vector_1_u8_type = @intFromEnum(InternPool.Index.vector_1_u8_type),
vector_2_u8_type = @intFromEnum(InternPool.Index.vector_2_u8_type),
vector_4_u8_type = @intFromEnum(InternPool.Index.vector_4_u8_type),
vector_8_u8_type = @intFromEnum(InternPool.Index.vector_8_u8_type),
vector_16_u8_type = @intFromEnum(InternPool.Index.vector_16_u8_type),
vector_32_u8_type = @intFromEnum(InternPool.Index.vector_32_u8_type),
vector_8_i16_type = @intFromEnum(InternPool.Index.vector_8_i16_type),
src/InternPool.zig
+20
View File
@@ -4573,6 +4573,10 @@ pub const Index = enum(u32) {
vector_16_i8_type,
vector_32_i8_type,
vector_1_u8_type,
vector_2_u8_type,
vector_4_u8_type,
vector_8_u8_type,
vector_16_u8_type,
vector_32_u8_type,
vector_8_i16_type,
@@ -5089,6 +5093,14 @@ pub const static_keys = [_]Key{
.{ .vector_type = .{ .len = 16, .child = .i8_type } },
// @Vector(32, i8)
.{ .vector_type = .{ .len = 32, .child = .i8_type } },
// @Vector(1, u8)
.{ .vector_type = .{ .len = 1, .child = .u8_type } },
// @Vector(2, u8)
.{ .vector_type = .{ .len = 2, .child = .u8_type } },
// @Vector(4, u8)
.{ .vector_type = .{ .len = 4, .child = .u8_type } },
// @Vector(8, u8)
.{ .vector_type = .{ .len = 8, .child = .u8_type } },
// @Vector(16, u8)
.{ .vector_type = .{ .len = 16, .child = .u8_type } },
// @Vector(32, u8)
@@ -11766,6 +11778,10 @@ pub fn typeOf(ip: *const InternPool, index: Index) Index {
.slice_const_u8_sentinel_0_type,
.vector_16_i8_type,
.vector_32_i8_type,
.vector_1_u8_type,
.vector_2_u8_type,
.vector_4_u8_type,
.vector_8_u8_type,
.vector_16_u8_type,
.vector_32_u8_type,
.vector_8_i16_type,
@@ -12106,6 +12122,10 @@ pub fn zigTypeTag(ip: *const InternPool, index: Index) std.builtin.TypeId {
.vector_16_i8_type,
.vector_32_i8_type,
.vector_1_u8_type,
.vector_2_u8_type,
.vector_4_u8_type,
.vector_8_u8_type,
.vector_16_u8_type,
.vector_32_u8_type,
.vector_8_i16_type,
src/Sema.zig
+4
View File
@@ -36377,6 +36377,10 @@ pub fn typeHasOnePossibleValue(sema: *Sema, ty: Type) CompileError!?Value {
.slice_const_u8_sentinel_0_type,
.vector_16_i8_type,
.vector_32_i8_type,
.vector_1_u8_type,
.vector_2_u8_type,
.vector_4_u8_type,
.vector_8_u8_type,
.vector_16_u8_type,
.vector_32_u8_type,
.vector_8_i16_type,
src/Type.zig
+4
View File
@@ -4201,6 +4201,10 @@ pub const slice_const_u8_sentinel_0: Type = .{ .ip_index = .slice_const_u8_senti
pub const vector_16_i8: Type = .{ .ip_index = .vector_16_i8_type };
pub const vector_32_i8: Type = .{ .ip_index = .vector_32_i8_type };
pub const vector_1_u8: Type = .{ .ip_index = .vector_1_u8_type };
pub const vector_2_u8: Type = .{ .ip_index = .vector_2_u8_type };
pub const vector_4_u8: Type = .{ .ip_index = .vector_4_u8_type };
pub const vector_8_u8: Type = .{ .ip_index = .vector_8_u8_type };
pub const vector_16_u8: Type = .{ .ip_index = .vector_16_u8_type };
pub const vector_32_u8: Type = .{ .ip_index = .vector_32_u8_type };
pub const vector_8_i16: Type = .{ .ip_index = .vector_8_i16_type };
src/arch/x86_64/CodeGen.zig
+2802 -84
View File
@@ -2069,7 +2069,7 @@ fn asmRegisterMemoryImmediate(
} else {
const payload = try self.addExtra(Mir.Imm32{ .imm = switch (imm) {
.signed => |s| @bitCast(s),
.unsigned => unreachable,
.unsigned => |u| @as(u32, @intCast(u)),
.reloc => unreachable,
} });
assert(payload + 1 == try self.addExtra(Mir.Memory.encode(m)));
@@ -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(13_600);
@setEvalBranchQuota(13_800);
const pt = cg.pt;
const zcu = pt.zcu;
const ip = &zcu.intern_pool;
@@ -2457,9 +2457,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.shr, .shr_exact => try cg.airShlShrBinOp(inst),
.shl, .shl_exact => try cg.airShlShrBinOp(inst),
.mul_wrap,
=> |air_tag| try cg.airMulDivBinOp(inst, air_tag),
.add_sat => try cg.airAddSat(inst),
.sub_sat => try cg.airSubSat(inst),
.mul_sat => try cg.airMulSat(inst),
@@ -8896,6 +8893,2703 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
},
.mul_safe => unreachable,
.mul_wrap => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, air_tag) else {
const bin_op = air_datas[@intFromEnum(inst)].bin_op;
const ty = cg.typeOf(bin_op.lhs);
var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs });
var res: [1]Temp = undefined;
cg.select(&res, &.{ty}, &ops, comptime &.{ .{
.src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any },
.patterns = &.{
.{ .src = .{ .{ .to_reg = .al }, .mem, .none } },
.{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } },
},
.dst_temps = .{ .{ .ref = .src0 }, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, .i_, .mul, .src1b, ._, ._, ._ },
} },
}, .{
.src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any },
.patterns = &.{
.{ .src = .{ .{ .to_reg = .al }, .mem, .none } },
.{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } },
},
.dst_temps = .{ .{ .ref = .src0 }, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .mul, .src1b, ._, ._, ._ },
} },
}, .{
.src_constraints = .{ .{ .int = .word }, .{ .int = .word }, .any },
.patterns = &.{
.{ .src = .{ .mem, .imm16, .none } },
.{ .src = .{ .imm16, .mem, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_gpr, .imm16, .none } },
.{ .src = .{ .imm16, .to_gpr, .none }, .commute = .{ 0, 1 } },
},
.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, .i_, .mul, .dst0w, .src0w, .src1w, ._ },
} },
}, .{
.src_constraints = .{ .{ .int = .word }, .{ .int = .word }, .any },
.patterns = &.{
.{ .src = .{ .to_mut_gpr, .mem, .none } },
.{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
},
.dst_temps = .{ .{ .ref = .src0 }, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, .i_, .mul, .dst0w, .src1w, ._, ._ },
} },
}, .{
.src_constraints = .{ .{ .int = .dword }, .{ .int = .dword }, .any },
.patterns = &.{
.{ .src = .{ .mem, .imm32, .none } },
.{ .src = .{ .imm32, .mem, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_gpr, .imm32, .none } },
.{ .src = .{ .imm32, .to_gpr, .none }, .commute = .{ 0, 1 } },
},
.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, .i_, .mul, .dst0d, .src0d, .src1d, ._ },
} },
}, .{
.src_constraints = .{ .{ .int = .dword }, .{ .int = .dword }, .any },
.patterns = &.{
.{ .src = .{ .to_mut_gpr, .mem, .none } },
.{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
},
.dst_temps = .{ .{ .ref = .src0 }, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, .i_, .mul, .dst0d, .src1d, ._, ._ },
} },
}, .{
.required_features = .{ .@"64bit", null, null, null },
.src_constraints = .{ .{ .int = .qword }, .{ .int = .qword }, .any },
.patterns = &.{
.{ .src = .{ .mem, .simm32, .none } },
.{ .src = .{ .simm32, .mem, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_gpr, .simm32, .none } },
.{ .src = .{ .simm32, .to_gpr, .none }, .commute = .{ 0, 1 } },
},
.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, .i_, .mul, .dst0q, .src0q, .src1q, ._ },
} },
}, .{
.required_features = .{ .@"64bit", null, null, null },
.src_constraints = .{ .{ .int = .qword }, .{ .int = .qword }, .any },
.patterns = &.{
.{ .src = .{ .to_mut_gpr, .mem, .none } },
.{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_mut_gpr, .to_gpr, .none } },
},
.dst_temps = .{ .{ .ref = .src0 }, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, .i_, .mul, .dst0q, .src1q, ._, ._ },
} },
}, .{
.required_features = .{ .@"64bit", null, null, null },
.src_constraints = .{ .{ .int = .xword }, .{ .int = .xword }, .any },
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .u64, .kind = .{ .reg = .rax } },
.{ .type = .u64, .kind = .{ .reg = .rdx } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
.{ ._, ._, .mul, .src1q, ._, ._, ._ },
.{ ._, ._, .mov, .dst0q, .tmp0q, ._, ._ },
.{ ._, ._, .mov, .tmp0q, .src0q, ._, ._ },
.{ ._, .i_, .mul, .tmp0q, .memd(.src1q, 8), ._, ._ },
.{ ._, ._, .add, .tmp1q, .tmp0q, ._, ._ },
.{ ._, ._, .mov, .tmp0q, .src1q, ._, ._ },
.{ ._, .i_, .mul, .tmp0q, .memd(.src0q, 8), ._, ._ },
.{ ._, ._, .add, .tmp1q, .tmp0q, ._, ._ },
.{ ._, ._, .mov, .memd(.dst0q, 8), .tmp1q, ._, ._ },
} },
}, .{
.required_features = .{ .@"64bit", .bmi2, .adx, null },
.src_constraints = .{
.{ .remainder_int = .{ .of = .qword, .is = .qword } },
.{ .remainder_int = .{ .of = .qword, .is = .qword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .reg = .rdx } },
.{ .type = .isize, .kind = .{ .reg = .rcx } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ },
.{ .@"0:", ._, .xor, .tmp2d, .tmp2d, ._, ._ },
.{ ._, ._, .@"or", .tmp2q, .memi(.src0q, .tmp0), ._, ._ },
.{ ._, ._z, .j, .@"2f", ._, ._, ._ },
.{ ._, ._, .lea, .tmp3p, .leaad(.tmp0, .sub_src0_size, 8), ._, ._ },
.{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
.{ .@"1:", ._x, .mul, .tmp6q, .tmp5q, .leai(.tmp1q, .tmp3), ._ },
.{ ._, ._x, .adc, .tmp5q, .tmp4q, ._, ._ },
.{ ._, ._, .mov, .memiad(.dst0q, .tmp3, .add_size, -8), .tmp5q, ._, ._ },
.{ ._, ._rcxz, .j, .@"1f", ._, ._, ._ },
.{ ._, ._x, .ado, .tmp6q, .memia(.dst0q, .tmp3, .add_size), ._, ._ },
.{ ._, ._, .mov, .tmp4q, .tmp6q, ._, ._ },
.{ ._, ._, .lea, .tmp3p, .lead(.tmp3, 8), ._, ._ },
.{ ._, ._mp, .j, .@"1b", ._, ._, ._ },
.{ .@"2:", ._, .mov, .memi(.dst0q, .tmp0), .tmp2q, ._, ._ },
.{ .@"1:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
.{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ },
.{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
.src_constraints = .{
.{ .remainder_int = .{ .of = .qword, .is = .qword } },
.{ .remainder_int = .{ .of = .qword, .is = .qword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .reg = .rdx } },
.{ .type = .u8, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
.{ .@"0:", ._, .lea, .tmp2p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
.{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
.{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
.{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
.{ ._, ._, .@"or", .tmp3q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
.{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
.{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
.{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
.{ .@"1:", ._, .adc, .tmp7q, .memsia(.dst0q, .@"8", .tmp2, .add_size), ._, ._ },
.{ ._, ._, .adc, .tmp4b, .si(0), ._, ._ },
.{ ._, ._, .mov, .tmp5q, .tmp7q, ._, ._ },
.{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
.{ .@"2:", ._x, .mul, .tmp7q, .tmp6q, .leasi(.tmp1q, .@"8", .tmp2), ._ },
.{ ._, ._, .adc, .tmp6q, .tmp5q, ._, ._ },
.{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp2, .add_size), .tmp6q, ._, ._ },
.{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
.{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
.{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
.{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
.{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .@"64bit", .bmi2, null, null },
.src_constraints = .{
.{ .remainder_int = .{ .of = .qword, .is = .qword } },
.{ .remainder_int = .{ .of = .qword, .is = .qword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .reg = .rdx } },
.{ .type = .u8, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
.{ .@"0:", ._, .lea, .tmp2p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
.{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
.{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
.{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
.{ ._, ._, .@"or", .tmp3q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
.{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
.{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
.{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
.{ .@"1:", ._, .adc, .tmp7q, .memsia(.dst0q, .@"8", .tmp2, .add_size), ._, ._ },
.{ ._, ._, .adc, .tmp4b, .si(0), ._, ._ },
.{ ._, ._, .mov, .tmp5q, .tmp7q, ._, ._ },
.{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
.{ .@"2:", ._x, .mul, .tmp7q, .tmp6q, .leasi(.tmp1q, .@"8", .tmp2), ._ },
.{ ._, ._, .adc, .tmp6q, .tmp5q, ._, ._ },
.{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp2, .add_size), .tmp6q, ._, ._ },
.{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
.{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
.{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
.{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
.{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .@"64bit", .slow_incdec, null, null },
.src_constraints = .{
.{ .remainder_int = .{ .of = .qword, .is = .qword } },
.{ .remainder_int = .{ .of = .qword, .is = .qword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u8, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .reg = .rax } },
.{ .type = .u64, .kind = .{ .reg = .rdx } },
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
.{ .@"0:", ._, .lea, .tmp2p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
.{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
.{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
.{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
.{ ._, ._, .@"or", .tmp3q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
.{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
.{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
.{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
.{ .@"1:", ._, .adc, .tmp7q, .memsia(.dst0q, .@"8", .tmp2, .add_size), ._, ._ },
.{ ._, ._, .adc, .tmp4b, .si(0), ._, ._ },
.{ ._, ._, .mov, .tmp5q, .tmp7q, ._, ._ },
.{ .@"2:", ._, .mov, .tmp6q, .tmp3q, ._, ._ },
.{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp2), ._, ._, ._ },
.{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
.{ ._, ._, .adc, .tmp6q, .tmp5q, ._, ._ },
.{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp2, .add_size), .tmp6q, ._, ._ },
.{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
.{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
.{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
.{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ },
.{ ._, ._ae, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .@"64bit", null, null, null },
.src_constraints = .{
.{ .remainder_int = .{ .of = .qword, .is = .qword } },
.{ .remainder_int = .{ .of = .qword, .is = .qword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u8, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .reg = .rax } },
.{ .type = .u64, .kind = .{ .reg = .rdx } },
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ },
.{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ },
.{ .@"0:", ._, .lea, .tmp2p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ },
.{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ },
.{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ },
.{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ },
.{ ._, ._, .@"or", .tmp3q, .memsi(.src0q, .@"8", .tmp0), ._, ._ },
.{ ._, ._nz, .j, .@"2f", ._, ._, ._ },
.{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp3q, ._, ._ },
.{ ._, ._mp, .j, .@"3f", ._, ._, ._ },
.{ .@"1:", ._, .adc, .tmp7q, .memsia(.dst0q, .@"8", .tmp2, .add_size), ._, ._ },
.{ ._, ._, .adc, .tmp4b, .si(0), ._, ._ },
.{ ._, ._, .mov, .tmp5q, .tmp7q, ._, ._ },
.{ .@"2:", ._, .mov, .tmp6q, .tmp3q, ._, ._ },
.{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp2), ._, ._, ._ },
.{ ._, ._l, .sh, .tmp4b, .ui(4), ._, ._ },
.{ ._, ._, .adc, .tmp6q, .tmp5q, ._, ._ },
.{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp2, .add_size), .tmp6q, ._, ._ },
.{ ._, ._c, .in, .tmp2p, ._, ._, ._ },
.{ ._, ._nz, .j, .@"1b", ._, ._, ._ },
.{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ },
.{ ._, ._c, .de, .tmp0d, ._, ._, ._ },
.{ ._, ._ns, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .avx, null, null, null },
.src_constraints = .{
.{ .scalar_signed_int = .{ .of = .qword, .is = .byte } },
.{ .scalar_signed_int = .{ .of = .qword, .is = .byte } },
.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_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .word, .to = .byte } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_8_i16, .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 = &.{
.{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
.{ ._, .vp_w, .movsxb, .dst0x, .src0q, ._, ._ },
.{ ._, .vp_w, .movsxb, .tmp2x, .src1q, ._, ._ },
.{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
.{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp1x), ._ },
} },
}, .{
.required_features = .{ .sse4_1, null, null, null },
.src_constraints = .{
.{ .scalar_signed_int = .{ .of = .qword, .is = .byte } },
.{ .scalar_signed_int = .{ .of = .qword, .is = .byte } },
.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_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .word, .to = .byte } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_8_i16, .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 = &.{
.{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
.{ ._, .p_w, .movsxb, .dst0x, .src0q, ._, ._ },
.{ ._, .p_w, .movsxb, .tmp2x, .src1q, ._, ._ },
.{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
.{ ._, .p_b, .shuf, .dst0x, .lea(.tmp1x), ._, ._ },
} },
}, .{
.required_features = .{ .sse2, null, null, null },
.src_constraints = .{
.{ .scalar_int = .{ .of = .qword, .is = .byte } },
.{ .scalar_int = .{ .of = .qword, .is = .byte } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mut_sse, .to_mut_sse, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .{ .pand_trunc_mem = .{ .from = .word, .to = .byte } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .{ .ref = .src0 }, .unused },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
.{ ._, .p_, .unpcklbw, .dst0x, .dst0x, ._, ._ },
.{ ._, .p_, .unpcklbw, .src1x, .src1x, ._, ._ },
.{ ._, .p_w, .mull, .dst0x, .src1x, ._, ._ },
.{ ._, .p_, .@"and", .dst0x, .lea(.tmp1x), ._, ._ },
.{ ._, .p_b, .ackusw, .dst0x, .dst0x, ._, ._ },
} },
}, .{
.required_features = .{ .avx2, null, null, null },
.src_constraints = .{
.{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
.{ .scalar_signed_int = .{ .of = .xword, .is = .byte } },
.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_32_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .word, .to = .byte } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_16_i16, .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 = &.{
.{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
.{ ._, .vp_w, .movsxb, .dst0y, .src0x, ._, ._ },
.{ ._, .vp_w, .movsxb, .tmp2y, .src1x, ._, ._ },
.{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp2y, ._ },
.{ ._, .vp_b, .shuf, .dst0y, .dst0y, .lea(.tmp1y), ._ },
.{ ._, .v_q, .perm, .dst0y, .dst0y, .ui(0b10_00_10_00), ._ },
} },
}, .{
.required_features = .{ .avx, null, null, null },
.src_constraints = .{
.{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
.{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
.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_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .word, .to = .byte } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_8_u16, .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 = &.{
.{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
.{ ._, .vp_w, .movzxb, .dst0x, .src0q, ._, ._ },
.{ ._, .vp_w, .movzxb, .tmp2x, .src1q, ._, ._ },
.{ ._, .vp_w, .mull, .dst0x, .dst0x, .tmp2x, ._ },
.{ ._, .vp_b, .shuf, .dst0x, .dst0x, .lea(.tmp1x), ._ },
} },
}, .{
.required_features = .{ .sse4_1, null, null, null },
.src_constraints = .{
.{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
.{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
.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_16_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .word, .to = .byte } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_8_u16, .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 = &.{
.{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
.{ ._, .p_w, .movzxb, .dst0x, .src0q, ._, ._ },
.{ ._, .p_w, .movzxb, .tmp2x, .src1q, ._, ._ },
.{ ._, .p_w, .mull, .dst0x, .tmp2x, ._, ._ },
.{ ._, .p_b, .shuf, .dst0x, .lea(.tmp1x), ._, ._ },
} },
}, .{
.required_features = .{ .avx2, null, null, null },
.src_constraints = .{
.{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
.{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
.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_32_u8, .kind = .{ .pshufb_trunc_mem = .{ .from = .word, .to = .byte } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_16_u16, .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 = &.{
.{ ._, ._, .lea, .tmp1p, .mem(.tmp0), ._, ._ },
.{ ._, .vp_w, .movzxb, .dst0y, .src0x, ._, ._ },
.{ ._, .vp_w, .movzxb, .tmp2y, .src1x, ._, ._ },
.{ ._, .vp_w, .mull, .dst0y, .dst0y, .tmp2y, ._ },
.{ ._, .vp_b, .shuf, .dst0y, .dst0y, .lea(.tmp1y), ._ },
.{ ._, .v_q, .perm, .dst0y, .dst0y, .ui(0b10_00_10_00), ._ },
} },
}, .{
.required_features = .{ .avx2, null, null, null },
.src_constraints = .{
.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
.{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_8_u8, .kind = .{ .pshufb_trunc_mem = .{ .of = .xword, .from = .word, .to = .byte } } },
.{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
.{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
.{ .type = .vector_16_i16, .kind = .{ .rc = .sse } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
.{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", .vp_w, .movsxb, .tmp3y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .vp_w, .movsxb, .tmp4y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .vp_w, .mull, .tmp3y, .tmp3y, .tmp4y, ._ },
.{ ._, .vp_b, .shuf, .tmp3y, .tmp3y, .tmp2y, ._ },
.{ ._, .v_q, .perm, .tmp3y, .tmp3y, .ui(0b10_00_10_00), ._ },
.{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .avx, null, null, null },
.src_constraints = .{
.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } },
.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_8_u8, .kind = .{ .pshufb_trunc_mem = .{ .of = .xword, .from = .word, .to = .byte } } },
.{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
.{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
.{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
.{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", .vp_w, .movsxb, .tmp3x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .vp_w, .movsxb, .tmp4x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .vp_w, .mull, .tmp3x, .tmp3x, .tmp4x, ._ },
.{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ },
.{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .sse4_1, null, null, null },
.src_constraints = .{
.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } },
.{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .byte } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_8_u8, .kind = .{ .pshufb_trunc_mem = .{ .of = .xword, .from = .word, .to = .byte } } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
.{ .type = .vector_8_i16, .kind = .{ .rc = .sse } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
.{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", .p_w, .movsxb, .tmp3x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .p_w, .movsxb, .tmp4x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .p_w, .mull, .tmp3x, .tmp4x, ._, ._ },
.{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ },
.{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .ssse3, null, null, null },
.src_constraints = .{
.{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } },
.{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_8_u8, .kind = .{ .pshufb_trunc_mem = .{ .of = .xword, .from = .word, .to = .byte } } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
.{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._q, .mov, .tmp3x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .p_, .unpcklbw, .tmp3x, .tmp3x, ._, ._ },
.{ ._, ._q, .mov, .tmp4x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .p_, .unpcklbw, .tmp4x, .tmp4x, ._, ._ },
.{ ._, .p_w, .mull, .tmp3x, .tmp4x, ._, ._ },
.{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ },
.{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .sse3, null, null, null },
.src_constraints = .{
.{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } },
.{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_8_u8, .kind = .{ .pand_trunc_mem = .{ .from = .word, .to = .byte } } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
.{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._q, .mov, .tmp3x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .p_, .unpcklbw, .tmp3x, .tmp3x, ._, ._ },
.{ ._, ._q, .mov, .tmp4x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .p_, .unpcklbw, .tmp4x, .tmp4x, ._, ._ },
.{ ._, .p_w, .mull, .tmp3x, .tmp4x, ._, ._ },
.{ ._, .p_, .@"and", .tmp3x, .tmp2x, ._, ._ },
.{ ._, .p_b, .ackusw, .tmp3x, .tmp3x, ._, ._ },
.{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .sse2, null, null, null },
.src_constraints = .{
.{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } },
.{ .multiple_scalar_int = .{ .of = .qword, .is = .byte } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_16_u8, .kind = .{ .pand_trunc_mem = .{ .from = .word, .to = .byte } } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
.{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ },
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._q, .mov, .tmp3x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .p_, .unpcklbw, .tmp3x, .tmp3x, ._, ._ },
.{ ._, ._q, .mov, .tmp4x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .p_, .unpcklbw, .tmp4x, .tmp4x, ._, ._ },
.{ ._, .p_w, .mull, .tmp3x, .tmp4x, ._, ._ },
.{ ._, .p_, .@"and", .tmp3x, .tmp2x, ._, ._ },
.{ ._, .p_b, .ackusw, .tmp3x, .tmp3x, ._, ._ },
.{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.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,
.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_, .mul, .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,
.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_, .mul, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
.{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
.{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
.{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .avx2, null, null, null },
.src_constraints = .{
.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
.{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_8_u8, .kind = .{ .pshufb_trunc_mem = .{ .of = .xword, .from = .word, .to = .byte } } },
.{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
.{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
.{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
.{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ },
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", .vp_w, .movzxb, .tmp3y, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .vp_w, .movzxb, .tmp4y, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .vp_w, .mull, .tmp3y, .tmp3y, .tmp4y, ._ },
.{ ._, .vp_b, .shuf, .tmp3y, .tmp3y, .tmp2y, ._ },
.{ ._, .v_q, .perm, .tmp3y, .tmp3y, .ui(0b10_00_10_00), ._ },
.{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .avx, null, null, null },
.src_constraints = .{
.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_8_u8, .kind = .{ .pshufb_trunc_mem = .{ .of = .xword, .from = .word, .to = .byte } } },
.{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
.{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", .vp_w, .movzxb, .tmp3x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .vp_w, .movzxb, .tmp4x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .vp_w, .mull, .tmp3x, .tmp3x, .tmp4x, ._ },
.{ ._, .vp_b, .shuf, .tmp3x, .tmp3x, .tmp2x, ._ },
.{ ._, .v_q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .sse4_1, null, null, null },
.src_constraints = .{
.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
.{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_8_u8, .kind = .{ .pshufb_trunc_mem = .{ .of = .xword, .from = .word, .to = .byte } } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ },
.{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ },
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", .p_w, .movzxb, .tmp3x, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .p_w, .movzxb, .tmp4x, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .p_w, .mull, .tmp3x, .tmp4x, ._, ._ },
.{ ._, .p_b, .shuf, .tmp3x, .tmp2x, ._, ._ },
.{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
.{ ._, ._nc, .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,
.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), ._, ._ },
.{ ._, ._, .mul, .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,
.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), ._, ._ },
.{ ._, ._, .mul, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._, ._ },
.{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ },
.{ ._, ._c, .in, .tmp0p, ._, ._, ._ },
.{ ._, ._nz, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .avx, null, null, null },
.src_constraints = .{
.{ .scalar_int = .{ .of = .xword, .is = .word } },
.{ .scalar_int = .{ .of = .xword, .is = .word } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_sse, .mem, .none } },
.{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
.each = .{ .once = &.{
.{ ._, .vp_w, .mull, .dst0x, .src0x, .src1x, ._ },
} },
}, .{
.required_features = .{ .sse2, null, null, null },
.src_constraints = .{
.{ .scalar_int = .{ .of = .xword, .is = .word } },
.{ .scalar_int = .{ .of = .xword, .is = .word } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mut_sse, .mem, .none } },
.{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_mut_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .ref = .src0 }, .unused },
.each = .{ .once = &.{
.{ ._, .p_w, .mull, .dst0x, .src1x, ._, ._ },
} },
}, .{
.required_features = .{ .avx2, null, null, null },
.src_constraints = .{
.{ .scalar_int = .{ .of = .yword, .is = .word } },
.{ .scalar_int = .{ .of = .yword, .is = .word } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_sse, .mem, .none } },
.{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
.each = .{ .once = &.{
.{ ._, .vp_w, .mull, .dst0y, .src0y, .src1y, ._ },
} },
}, .{
.required_features = .{ .avx2, null, null, null },
.src_constraints = .{
.{ .multiple_scalar_int = .{ .of = .yword, .is = .word } },
.{ .multiple_scalar_int = .{ .of = .yword, .is = .word } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_16_u16, .kind = .{ .rc = .sse } },
.unused,
.unused,
.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_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .vp_w, .mull, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
.{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .avx, null, null, null },
.src_constraints = .{
.{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
.{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
.unused,
.unused,
.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_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .vp_w, .mull, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
.{ ._, .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_int = .{ .of = .xword, .is = .word } },
.{ .multiple_scalar_int = .{ .of = .xword, .is = .word } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_8_u16, .kind = .{ .rc = .sse } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .p_w, .mull, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
.{ ._, ._nc, .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 = .{ .rc = .general_purpose } },
.unused,
.unused,
.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(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .i_, .mul, .tmp1w, .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 = .{ .rc = .general_purpose } },
.unused,
.unused,
.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(.src0w, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .i_, .mul, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(2), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .avx, null, null, null },
.src_constraints = .{
.{ .scalar_int = .{ .of = .xword, .is = .dword } },
.{ .scalar_int = .{ .of = .xword, .is = .dword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_sse, .mem, .none } },
.{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
.each = .{ .once = &.{
.{ ._, .vp_d, .mull, .dst0x, .src0x, .src1x, ._ },
} },
}, .{
.required_features = .{ .sse4_1, null, null, null },
.src_constraints = .{
.{ .scalar_int = .{ .of = .xword, .is = .dword } },
.{ .scalar_int = .{ .of = .xword, .is = .dword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mut_sse, .mem, .none } },
.{ .src = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_mut_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .ref = .src0 }, .unused },
.each = .{ .once = &.{
.{ ._, .p_d, .mull, .dst0x, .src1x, ._, ._ },
} },
}, .{
.required_features = .{ .avx2, null, null, null },
.src_constraints = .{
.{ .scalar_int = .{ .of = .yword, .is = .dword } },
.{ .scalar_int = .{ .of = .yword, .is = .dword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_sse, .mem, .none } },
.{ .src = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
.each = .{ .once = &.{
.{ ._, .vp_d, .mull, .dst0y, .src0y, .src1y, ._ },
} },
}, .{
.required_features = .{ .avx2, null, null, null },
.src_constraints = .{
.{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } },
.{ .multiple_scalar_int = .{ .of = .yword, .is = .dword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_8_u32, .kind = .{ .rc = .sse } },
.unused,
.unused,
.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_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .vp_d, .mull, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
.{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .avx, null, null, null },
.src_constraints = .{
.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
.unused,
.unused,
.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_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .vp_d, .mull, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ },
.{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .sse4_1, null, null, null },
.src_constraints = .{
.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
.{ .multiple_scalar_int = .{ .of = .xword, .is = .dword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_4_u32, .kind = .{ .rc = .sse } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .p_d, .mull, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.src_constraints = .{
.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } },
.{ .multiple_scalar_int = .{ .of = .dword, .is = .dword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .u32, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
.unused,
.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), ._, ._ },
.{ ._, .i_, .mul, .tmp1d, .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_int = .{ .of = .qword, .is = .qword } },
.{ .multiple_scalar_int = .{ .of = .qword, .is = .qword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
.unused,
.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), ._, ._ },
.{ ._, .i_, .mul, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(8), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .@"64bit", .bmi2, .adx, null },
.src_constraints = .{
.{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
.{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .reg = .rdx } },
.{ .type = .isize, .kind = .{ .reg = .rcx } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.unused,
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
.{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_size), ._, ._ },
.{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_size), ._, ._ },
.{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_size), ._, ._ },
.{ ._, ._, .mov, .tmp4d, .sia(-8, .src0, .add_elem_size), ._, ._ },
.{ .@"1:", ._, .xor, .tmp5d, .tmp5d, ._, ._ },
.{ ._, ._, .@"or", .tmp5q, .leai(.tmp1q, .tmp4), ._, ._ },
.{ ._, ._z, .j, .@"3f", ._, ._, ._ },
.{ ._, ._, .lea, .tmp6p, .leaad(.tmp4, .sub_src0_elem_size, 8), ._, ._ },
.{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
.{ .@"2:", ._x, .mul, .tmp9q, .tmp8q, .leai(.tmp2q, .tmp6), ._ },
.{ ._, ._x, .adc, .tmp8q, .tmp7q, ._, ._ },
.{ ._, ._, .mov, .leaiad(.tmp3q, .tmp6, .add_dst0_elem_size, -8), .tmp8q, ._, ._ },
.{ ._, ._rcxz, .j, .@"2f", ._, ._, ._ },
.{ ._, ._x, .ado, .tmp9q, .leaia(.tmp3q, .tmp6, .add_dst0_elem_size), ._, ._ },
.{ ._, ._, .mov, .tmp7q, .tmp9q, ._, ._ },
.{ ._, ._, .lea, .tmp6p, .lead(.tmp6, 8), ._, ._ },
.{ ._, ._mp, .j, .@"2b", ._, ._, ._ },
.{ .@"3:", ._, .mov, .leai(.tmp3q, .tmp4), .tmp5q, ._, ._ },
.{ .@"2:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
.{ ._, ._, .sub, .tmp4d, .si(8), ._, ._ },
.{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
.{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .@"64bit", .bmi2, .slow_incdec, null },
.src_constraints = .{
.{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
.{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .reg = .rdx } },
.{ .type = .u8, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
.{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_size), ._, ._ },
.{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_size, 8), ._, ._ },
.{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_size), ._, ._ },
.{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
.{ .@"1:", ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size_div_8), ._, ._ },
.{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
.{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
.{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
.{ ._, ._, .@"or", .tmp6q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
.{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
.{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp6q, ._, ._ },
.{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
.{ .@"2:", ._, .adc, .tmp10q, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), ._, ._ },
.{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
.{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
.{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
.{ .@"3:", ._x, .mul, .tmp10q, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._ },
.{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
.{ ._, ._, .mov, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), .tmp9q, ._, ._ },
.{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
.{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
.{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
.{ ._, ._, .sub, .tmp4d, .si(1), ._, ._ },
.{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
.{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .@"64bit", .bmi2, null, null },
.src_constraints = .{
.{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
.{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .reg = .rdx } },
.{ .type = .u8, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
.{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_size), ._, ._ },
.{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_size, 8), ._, ._ },
.{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_size), ._, ._ },
.{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
.{ .@"1:", ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size_div_8), ._, ._ },
.{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
.{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
.{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
.{ ._, ._, .@"or", .tmp6q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
.{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
.{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp6q, ._, ._ },
.{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
.{ .@"2:", ._, .adc, .tmp10q, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), ._, ._ },
.{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
.{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
.{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
.{ .@"3:", ._x, .mul, .tmp10q, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._ },
.{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
.{ ._, ._, .mov, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), .tmp9q, ._, ._ },
.{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
.{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
.{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
.{ ._, ._c, .de, .tmp4d, ._, ._, ._ },
.{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
.{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .@"64bit", .slow_incdec, null, null },
.src_constraints = .{
.{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
.{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u8, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .reg = .rax } },
.{ .type = .u64, .kind = .{ .reg = .rdx } },
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
.{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_size), ._, ._ },
.{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_size, 8), ._, ._ },
.{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_size), ._, ._ },
.{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
.{ .@"1:", ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size_div_8), ._, ._ },
.{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
.{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
.{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
.{ ._, ._, .@"or", .tmp6q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
.{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
.{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp6q, ._, ._ },
.{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
.{ .@"2:", ._, .adc, .tmp10q, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), ._, ._ },
.{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
.{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
.{ .@"3:", ._, .mov, .tmp9q, .tmp6q, ._, ._ },
.{ ._, ._, .mul, .leasi(.tmp2q, .@"8", .tmp5), ._, ._, ._ },
.{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
.{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
.{ ._, ._, .mov, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), .tmp9q, ._, ._ },
.{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
.{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
.{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
.{ ._, ._, .sub, .tmp4d, .si(1), ._, ._ },
.{ ._, ._ae, .j, .@"1b", ._, ._, ._ },
.{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .@"64bit", null, null, null },
.src_constraints = .{
.{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
.{ .scalar_remainder_int = .{ .of = .qword, .is = .qword } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_mem, .to_mem, .none } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u8, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .reg = .rax } },
.{ .type = .u64, .kind = .{ .reg = .rdx } },
},
.dst_temps = .{ .mem, .unused },
.clobbers = .{ .eflags = true },
.each = .{ .once = &.{
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size), ._, ._ },
.{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_size), ._, ._ },
.{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_size, 8), ._, ._ },
.{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_size), ._, ._ },
.{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ },
.{ .@"1:", ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size_div_8), ._, ._ },
.{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ },
.{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ },
.{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ },
.{ ._, ._, .@"or", .tmp6q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ },
.{ ._, ._nz, .j, .@"3f", ._, ._, ._ },
.{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp6q, ._, ._ },
.{ ._, ._mp, .j, .@"4f", ._, ._, ._ },
.{ .@"2:", ._, .adc, .tmp10q, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), ._, ._ },
.{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ },
.{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ },
.{ .@"3:", ._, .mov, .tmp9q, .tmp6q, ._, ._ },
.{ ._, ._, .mul, .leasi(.tmp2q, .@"8", .tmp5), ._, ._, ._ },
.{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ },
.{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ },
.{ ._, ._, .mov, .leasia(.tmp3q, .@"8", .tmp5, .add_src0_elem_size), .tmp9q, ._, ._ },
.{ ._, ._c, .in, .tmp5p, ._, ._, ._ },
.{ ._, ._nz, .j, .@"2b", ._, ._, ._ },
.{ .@"4:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ },
.{ ._, ._c, .de, .tmp4d, ._, ._, ._ },
.{ ._, ._ns, .j, .@"1b", ._, ._, ._ },
.{ ._, ._, .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,
.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, .mul, .dst0x, .dst0x, .tmp0d, ._ },
.{ ._, .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 = "__mulhf3" } } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .{ .ref = .src0 }, .unused },
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
} },
}, .{
.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,
.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, .mul, .dst0x, .dst0x, .tmp0x, ._ },
.{ ._, .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,
.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, .mul, .dst0y, .dst0y, .tmp0y, ._ },
.{ ._, .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,
.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, .mul, .tmp1y, .tmp1y, .tmp2y, ._ },
.{ ._, .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 = "__mulhf3" } } },
.unused,
.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:", .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, ._, ._, ._ },
.{ ._, .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 = "__mulhf3" } } },
.unused,
.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:", .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, ._, ._, ._ },
.{ ._, .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 = "__mulhf3" } } },
.{ .type = .f16, .kind = .{ .reg = .ax } },
.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:", .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, ._, ._, ._ },
.{ ._, .p_w, .extr, .tmp4d, .tmp1x, .ui(0), ._ },
.{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp4w, ._, ._ },
.{ ._, ._, .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 = "__mulhf3" } } },
.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:", ._, .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, ._, ._, ._ },
.{ ._, ._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 = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
.each = .{ .once = &.{
.{ ._, .v_ss, .mul, .dst0x, .src0x, .src1d, ._ },
} },
}, .{
.required_features = .{ .sse, 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 = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_mut_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .ref = .src0 }, .unused },
.each = .{ .once = &.{
.{ ._, ._ss, .mul, .dst0x, .src1d, ._, ._ },
} },
}, .{
.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 = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
.each = .{ .once = &.{
.{ ._, .v_ps, .mul, .dst0x, .src0x, .src1x, ._ },
} },
}, .{
.required_features = .{ .sse, 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 = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_mut_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .ref = .src0 }, .unused },
.each = .{ .once = &.{
.{ ._, ._ps, .mul, .dst0x, .src1x, ._, ._ },
} },
}, .{
.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 = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
.each = .{ .once = &.{
.{ ._, .v_ps, .mul, .dst0y, .src0y, .src1y, ._ },
} },
}, .{
.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,
.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, .mul, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
.{ ._, .v_ps, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .sse, 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,
.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, .mul, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._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 = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
.each = .{ .once = &.{
.{ ._, .v_sd, .mul, .dst0x, .src0x, .src1q, ._ },
} },
}, .{
.required_features = .{ .sse2, 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 = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_mut_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .ref = .src0 }, .unused },
.each = .{ .once = &.{
.{ ._, ._sd, .mul, .dst0x, .src1q, ._, ._ },
} },
}, .{
.required_features = .{ .x87, null, null, null },
.src_constraints = .{
.{ .scalar_float = .{ .of = .qword, .is = .qword } },
.{ .scalar_float = .{ .of = .qword, .is = .qword } },
.any,
},
.patterns = &.{
.{ .src = .{ .mem, .mem, .none } },
},
.extra_temps = .{
.{ .type = .f64, .kind = .{ .reg = .st6 } },
.{ .type = .f64, .kind = .{ .reg = .st7 } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.each = .{ .once = &.{
.{ ._, .f_, .ld, .src0q, ._, ._, ._ },
.{ ._, .f_, .mul, .src1q, ._, ._, ._ },
.{ ._, .f_p, .st, .dst0q, ._, ._, ._ },
} },
}, .{
.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 = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
.each = .{ .once = &.{
.{ ._, .v_pd, .mul, .dst0x, .src0x, .src1x, ._ },
} },
}, .{
.required_features = .{ .sse2, 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 = .{ .mem, .to_mut_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_mut_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .ref = .src0 }, .unused },
.each = .{ .once = &.{
.{ ._, ._pd, .mul, .dst0x, .src1x, ._, ._ },
} },
}, .{
.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 = .{ .mem, .to_sse, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .to_sse, .to_sse, .none } },
},
.dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused },
.each = .{ .once = &.{
.{ ._, .v_pd, .mul, .dst0y, .src0y, .src1y, ._ },
} },
}, .{
.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,
.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, .mul, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ },
.{ ._, .v_pd, .mova, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(32), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .sse2, 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,
.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, .mul, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._pd, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ },
.{ ._, ._, .add, .tmp0p, .si(16), ._, ._ },
.{ ._, ._nc, .j, .@"0b", ._, ._, ._ },
} },
}, .{
.required_features = .{ .x87, 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 } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .f64, .kind = .{ .reg = .st6 } },
.{ .type = .f64, .kind = .{ .reg = .st7 } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.each = .{ .once = &.{
.{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ },
.{ .@"0:", .f_, .ld, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
.{ ._, .f_, .mul, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._, ._ },
.{ ._, .f_p, .st, .memia(.dst0q, .tmp0, .add_unaligned_size), ._, ._, ._ },
.{ ._, ._, .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 = .{ .mem, .mem, .none } },
},
.extra_temps = .{
.{ .type = .f80, .kind = .{ .reg = .st6 } },
.{ .type = .f80, .kind = .{ .reg = .st7 } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .{ .rc = .x87 }, .unused },
.each = .{ .once = &.{
.{ ._, .f_, .ld, .src0t, ._, ._, ._ },
.{ ._, .f_, .ld, .src1t, ._, ._, ._ },
.{ ._, .f_p, .mul, ._, ._, ._, ._ },
.{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
} },
}, .{
.required_features = .{ .x87, null, null, null },
.src_constraints = .{
.{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
.{ .scalar_float = .{ .of = .xword, .is = .tbyte } },
.any,
},
.patterns = &.{
.{ .src = .{ .to_x87, .mem, .none }, .commute = .{ 0, 1 } },
.{ .src = .{ .mem, .to_x87, .none } },
.{ .src = .{ .to_x87, .to_x87, .none } },
},
.extra_temps = .{
.{ .type = .f80, .kind = .{ .reg = .st7 } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .{ .rc = .x87 }, .unused },
.each = .{ .once = &.{
.{ ._, .f_, .ld, .src0t, ._, ._, ._ },
.{ ._, .f_, .mul, .tmp0t, .src1t, ._, ._ },
.{ ._, .f_p, .st, .dst0t, ._, ._, ._ },
} },
}, .{
.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 } },
},
.extra_temps = .{
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .f80, .kind = .{ .reg = .st6 } },
.{ .type = .f80, .kind = .{ .reg = .st7 } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .mem, .unused },
.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, .mul, ._, ._, ._, ._ },
.{ ._, .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 = "__multf3" } } },
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
.unused,
},
.dst_temps = .{ .{ .ref = .src0 }, .unused },
.clobbers = .{ .eflags = true, .caller_preserved = .ccc },
.each = .{ .once = &.{
.{ ._, ._, .call, .tmp0d, ._, ._, ._ },
} },
}, .{
.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 = "__multf3" } } },
.unused,
.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:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, .v_dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
.{ ._, .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 = "__multf3" } } },
.unused,
.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:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._dqa, .mov, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
.{ ._, ._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 = "__multf3" } } },
.unused,
.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:", ._ps, .mova, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._ps, .mova, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ },
.{ ._, ._, .call, .tmp3d, ._, ._, ._ },
.{ ._, ._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),
ty.fmt(pt),
ops[0].tracking(cg),
ops[1].tracking(cg),
}),
else => |e| return e,
};
res[0].wrapInt(cg) catch |err| switch (err) {
error.SelectFailed => return cg.fail("failed to select wrap {} {} {}", .{
cg.typeOf(bin_op.lhs).fmt(pt),
ops[0].tracking(cg),
ops[1].tracking(cg),
}),
else => |e| return e,
};
try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg);
},
.div_float, .div_float_optimized, .div_exact, .div_exact_optimized => |air_tag| if (use_old) try cg.airMulDivBinOp(inst, switch (air_tag) {
else => unreachable,
.div_float, .div_float_optimized => .div_float,
@@ -32065,7 +34759,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
@@ -32089,7 +34783,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
@@ -32113,7 +34807,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
@@ -32141,7 +34835,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
@@ -32170,7 +34864,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
.unused,
@@ -32199,7 +34893,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
.unused,
@@ -32266,7 +34960,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
@@ -32292,7 +34986,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
@@ -32318,7 +35012,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
@@ -32348,7 +35042,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
@@ -32379,7 +35073,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
.unused,
@@ -32410,7 +35104,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
.unused,
@@ -32480,7 +35174,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
@@ -32506,7 +35200,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
@@ -32532,7 +35226,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
@@ -32562,7 +35256,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
@@ -32593,7 +35287,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
.unused,
@@ -32624,7 +35318,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
.unused,
@@ -32694,7 +35388,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -32720,7 +35414,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -32746,7 +35440,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
@@ -32773,7 +35467,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } },
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
@@ -32802,7 +35496,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } },
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
.unused,
@@ -32871,7 +35565,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -32898,7 +35592,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -32925,7 +35619,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
@@ -32953,7 +35647,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } },
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
@@ -32984,7 +35678,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } },
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
.unused,
@@ -33056,7 +35750,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -33083,7 +35777,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -33110,7 +35804,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
@@ -33139,7 +35833,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } },
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
@@ -33170,7 +35864,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .word, .smear = 8 } } },
.{ .type = .vector_16_u8, .kind = .reverse_bits },
.{ .type = .vector_16_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.unused,
.unused,
@@ -33242,7 +35936,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -33268,7 +35962,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -33294,7 +35988,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
@@ -33322,7 +36016,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
},
.extra_temps = .{
.{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword, .smear = 8 } } },
.{ .type = .vector_32_u8, .kind = .reverse_bits },
.{ .type = .vector_32_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_32_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
.{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
.unused,
@@ -33392,7 +36086,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -33419,7 +36113,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -33446,7 +36140,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
@@ -33475,7 +36169,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
},
.extra_temps = .{
.{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword, .smear = 8 } } },
.{ .type = .vector_32_u8, .kind = .reverse_bits },
.{ .type = .vector_32_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_32_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
.{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
.unused,
@@ -33548,7 +36242,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -33575,7 +36269,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -33602,7 +36296,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
.unused,
@@ -33631,7 +36325,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
},
.extra_temps = .{
.{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .dword, .smear = 8 } } },
.{ .type = .vector_32_u8, .kind = .reverse_bits },
.{ .type = .vector_32_u8, .kind = .reverse_bits_mem },
.{ .type = .vector_32_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
.{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
.unused,
@@ -33704,7 +36398,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -33730,7 +36424,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -33756,7 +36450,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.unused,
.unused,
.unused,
@@ -33827,7 +36521,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
.unused,
.unused,
@@ -33855,7 +36549,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.unused,
.unused,
.unused,
@@ -33929,7 +36623,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -33956,7 +36650,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .qword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -33983,7 +36677,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.unused,
.unused,
.unused,
@@ -34057,7 +36751,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -34083,7 +36777,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -34109,7 +36803,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
@@ -34142,7 +36836,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
@@ -34175,7 +36869,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_16_u8, .kind = .{ .mut_rc = .{ .ref = .src0, .rc = .sse } } },
@@ -34208,7 +36902,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_mut_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .u64, .kind = .{ .rc = .general_purpose } },
@@ -34241,7 +36935,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_32_u8, .kind = .forward_bits },
.{ .type = .vector_32_u8, .kind = .forward_bits_mem },
.{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .repeat = 2, .size = .xword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -34268,7 +36962,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.{ .src = .{ .to_sse, .none, .none } },
},
.extra_temps = .{
.{ .type = .vector_32_u8, .kind = .forward_bits },
.{ .type = .vector_32_u8, .kind = .forward_bits_mem },
.{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .repeat = 2, .size = .xword } } },
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.unused,
@@ -34297,7 +36991,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.extra_temps = .{
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_32_u8, .kind = .forward_bits },
.{ .type = .vector_32_u8, .kind = .forward_bits_mem },
.{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .repeat = 2, .size = .xword } } },
.{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
.{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
@@ -34333,7 +37027,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.extra_temps = .{
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_32_u8, .kind = .forward_bits },
.{ .type = .vector_32_u8, .kind = .forward_bits_mem },
.{ .type = .vector_32_u8, .kind = .{ .pshufb_bswap_mem = .{ .repeat = 2, .size = .xword } } },
.{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
.{ .type = .vector_32_u8, .kind = .{ .rc = .sse } },
@@ -34369,7 +37063,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void {
.extra_temps = .{
.{ .type = .usize, .kind = .{ .rc = .general_purpose } },
.{ .type = .isize, .kind = .{ .rc = .general_purpose } },
.{ .type = .vector_16_u8, .kind = .forward_bits },
.{ .type = .vector_16_u8, .kind = .forward_bits_mem },
.{ .type = .vector_16_u8, .kind = .{ .pshufb_bswap_mem = .{ .size = .xword } } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
.{ .type = .vector_16_u8, .kind = .{ .rc = .sse } },
@@ -106842,10 +109536,11 @@ const Select = struct {
f64_0x1p52_0x1p84_mem,
u32_0x1p52_hi_0x1p84_hi_0_0_mem,
f32_0_0x1p64_mem,
pshufb_trunc_mem: struct { from: Memory.Size, to: Memory.Size },
pshufb_trunc_mem: struct { of: Memory.Size = .none, from: Memory.Size, to: Memory.Size },
pand_trunc_mem: struct { from: Memory.Size, to: Memory.Size },
pshufb_bswap_mem: struct { repeat: u4 = 1, size: Memory.Size, smear: u4 = 1 },
forward_bits,
reverse_bits,
forward_bits_mem,
reverse_bits_mem,
frame: FrameIndex,
lazy_symbol: struct { kind: link.File.LazySymbol.Kind, ref: Select.Operand.Ref = .none },
symbol: *const struct { lib: ?[]const u8 = null, name: []const u8 },
@@ -107061,17 +109756,40 @@ const Select = struct {
const zcu = pt.zcu;
assert(spec.type.isVector(zcu));
assert(spec.type.childType(zcu).toIntern() == .u8_type);
var bytes: [16]u8 = @splat(1 << 7);
var elem_buf: [32]u8 = @splat(1 << 7);
const elems = elem_buf[0..spec.type.vectorLen(zcu)];
const of_bytes: u32 = @intCast(switch (trunc_spec.of) {
.none => elems.len,
else => |of| @divExact(of.bitSize(cg.target), 8),
});
const from_bytes: u32 = @intCast(@divExact(trunc_spec.from.bitSize(cg.target), 8));
const to_bytes: u32 = @intCast(@divExact(trunc_spec.to.bitSize(cg.target), 8));
var from_index: u32 = 0;
var to_index: u32 = 0;
while (from_index < bytes.len) {
for (0..to_bytes) |byte_off| bytes[to_index + byte_off] = @intCast(from_index + byte_off);
while (from_index < of_bytes) : ({
from_index += from_bytes;
to_index += to_bytes;
}
const elems = bytes[0..spec.type.vectorLen(zcu)];
switch (from_index % 16) {
0 => to_index = from_index,
else => to_index += to_bytes,
}
}) for (0..to_bytes) |byte_off| {
elems[to_index + byte_off] = @as(u4, @truncate(from_index + byte_off));
};
return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{
.ty = spec.type.toIntern(),
.storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) },
} }))), true };
},
.pand_trunc_mem => |trunc_spec| {
const zcu = pt.zcu;
assert(spec.type.isVector(zcu));
assert(spec.type.childType(zcu).toIntern() == .u8_type);
var elem_buf: [32]u8 = @splat(0);
const elems = elem_buf[0..spec.type.vectorLen(zcu)];
const from_bytes: u32 = @intCast(@divExact(trunc_spec.from.bitSize(cg.target), 8));
const to_bytes: u32 = @intCast(@divExact(trunc_spec.to.bitSize(cg.target), 8));
var index: u32 = 0;
while (index < elems.len) : (index += from_bytes) @memset(elems[index..][0..to_bytes], std.math.maxInt(u8));
return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{
.ty = spec.type.toIntern(),
.storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) },
@@ -107081,20 +109799,20 @@ const Select = struct {
const zcu = pt.zcu;
assert(spec.type.isVector(zcu));
assert(spec.type.childType(zcu).toIntern() == .u8_type);
var bytes: [32]u8 = @splat(1 << 7);
var elem_buf: [32]u8 = @splat(1 << 7);
const elems = elem_buf[0..spec.type.vectorLen(zcu)];
const len: usize = @intCast(@divExact(bswap_spec.size.bitSize(cg.target), 8));
var to_index: u32 = 0;
for (0..bswap_spec.repeat) |_| for (0..len) |from_index| {
@memset(bytes[to_index..][0..bswap_spec.smear], @intCast(len - 1 - from_index));
@memset(elems[to_index..][0..bswap_spec.smear], @intCast(len - 1 - from_index));
to_index += bswap_spec.smear;
};
const elems = bytes[0..spec.type.vectorLen(zcu)];
return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{
.ty = spec.type.toIntern(),
.storage = .{ .bytes = try zcu.intern_pool.getOrPutString(zcu.gpa, pt.tid, elems, .maybe_embedded_nulls) },
} }))), true };
},
.forward_bits, .reverse_bits => {
.forward_bits_mem, .reverse_bits_mem => {
const zcu = pt.zcu;
assert(spec.type.isVector(zcu));
assert(spec.type.childType(zcu).toIntern() == .u8_type);
@@ -107102,8 +109820,8 @@ const Select = struct {
const elems = bytes[0..spec.type.vectorLen(zcu)];
for (elems, 0..) |*elem, index| elem.* = switch (spec.kind) {
else => unreachable,
.forward_bits => @as(u8, 1 << 0) << @truncate(index),
.reverse_bits => @as(u8, 1 << 7) >> @truncate(index),
.forward_bits_mem => @as(u8, 1 << 0) << @truncate(index),
.reverse_bits_mem => @as(u8, 1 << 7) >> @truncate(index),
};
return .{ try cg.tempMemFromValue(.fromInterned(try pt.intern(.{ .aggregate = .{
.ty = spec.type.toIntern(),
src/arch/x86_64/Lower.zig
+1 -1
View File
@@ -579,7 +579,7 @@ fn generic(lower: *Lower, inst: Mir.Inst) Error!void {
.rrri => inst.data.rrri.fixes,
.rri_s, .rri_u => inst.data.rri.fixes,
.ri_s, .ri_u, .ri_64, .ir => inst.data.ri.fixes,
.rm, .rmi_s, .mr => inst.data.rx.fixes,
.rm, .rmi_s, .rmi_u, .mr => inst.data.rx.fixes,
.mrr, .rrm, .rmr => inst.data.rrx.fixes,
.rmi, .mri => inst.data.rix.fixes,
.rrmr => inst.data.rrrx.fixes,
src/codegen/c/Type.zig
+60
View File
@@ -1474,6 +1474,66 @@ pub const Pool = struct {
};
return pool.fromFields(allocator, .@"struct", &fields, kind);
},
.vector_1_u8_type => {
const vector_ctype = try pool.getVector(allocator, .{
.elem_ctype = .u8,
.len = 1,
});
if (!kind.isParameter()) return vector_ctype;
var fields = [_]Info.Field{
.{
.name = .{ .index = .array },
.ctype = vector_ctype,
.alignas = AlignAs.fromAbiAlignment(Type.u8.abiAlignment(zcu)),
},
};
return pool.fromFields(allocator, .@"struct", &fields, kind);
},
.vector_2_u8_type => {
const vector_ctype = try pool.getVector(allocator, .{
.elem_ctype = .u8,
.len = 2,
});
if (!kind.isParameter()) return vector_ctype;
var fields = [_]Info.Field{
.{
.name = .{ .index = .array },
.ctype = vector_ctype,
.alignas = AlignAs.fromAbiAlignment(Type.u8.abiAlignment(zcu)),
},
};
return pool.fromFields(allocator, .@"struct", &fields, kind);
},
.vector_4_u8_type => {
const vector_ctype = try pool.getVector(allocator, .{
.elem_ctype = .u8,
.len = 4,
});
if (!kind.isParameter()) return vector_ctype;
var fields = [_]Info.Field{
.{
.name = .{ .index = .array },
.ctype = vector_ctype,
.alignas = AlignAs.fromAbiAlignment(Type.u8.abiAlignment(zcu)),
},
};
return pool.fromFields(allocator, .@"struct", &fields, kind);
},
.vector_8_u8_type => {
const vector_ctype = try pool.getVector(allocator, .{
.elem_ctype = .u8,
.len = 8,
});
if (!kind.isParameter()) return vector_ctype;
var fields = [_]Info.Field{
.{
.name = .{ .index = .array },
.ctype = vector_ctype,
.alignas = AlignAs.fromAbiAlignment(Type.u8.abiAlignment(zcu)),
},
};
return pool.fromFields(allocator, .@"struct", &fields, kind);
},
.vector_16_u8_type => {
const vector_ctype = try pool.getVector(allocator, .{
.elem_ctype = .u8,
test/behavior/x86_64/math.zig
+9
View File
@@ -21684,6 +21684,15 @@ test mulUnsafe {
try test_mul_unsafe.testIntVectors();
}
inline fn mulWrap(comptime Type: type, lhs: Type, rhs: Type) Type {
return lhs *% rhs;
}
test mulWrap {
const test_mul_wrap = binary(mulWrap, .{});
try test_mul_wrap.testInts();
try test_mul_wrap.testIntVectors();
}
inline fn multiply(comptime Type: type, lhs: Type, rhs: Type) @TypeOf(lhs * rhs) {
return lhs * rhs;
}
test/cases/compile_errors/@import_zon_bad_type.zig
+3 -3
View File
@@ -117,9 +117,9 @@ export fn testMutablePointer() void {
// tmp.zig:37:38: note: imported here
// neg_inf.zon:1:1: error: expected type '?u8'
// tmp.zig:57:28: note: imported here
// neg_inf.zon:1:1: error: expected type 'tmp.testNonExhaustiveEnum__enum_487'
// neg_inf.zon:1:1: error: expected type 'tmp.testNonExhaustiveEnum__enum_491'
// tmp.zig:62:39: note: imported here
// neg_inf.zon:1:1: error: expected type 'tmp.testUntaggedUnion__union_489'
// neg_inf.zon:1:1: error: expected type 'tmp.testUntaggedUnion__union_493'
// tmp.zig:67:44: note: imported here
// neg_inf.zon:1:1: error: expected type 'tmp.testTaggedUnionVoid__union_492'
// neg_inf.zon:1:1: error: expected type 'tmp.testTaggedUnionVoid__union_496'
// tmp.zig:72:50: note: imported here
test/cases/compile_errors/anytype_param_requires_comptime.zig
+1 -1
View File
@@ -15,6 +15,6 @@ pub export fn entry() void {
// error
//
// :7:25: error: unable to resolve comptime value
// :7:25: note: initializer of comptime-only struct 'tmp.S.foo__anon_461.C' must be comptime-known
// :7:25: note: initializer of comptime-only struct 'tmp.S.foo__anon_465.C' must be comptime-known
// :4:16: note: struct requires comptime because of this field
// :4:16: note: types are not available at runtime
test/cases/compile_errors/bogus_method_call_on_slice.zig
+1 -1
View File
@@ -16,5 +16,5 @@ pub export fn entry2() void {
//
// :3:6: error: no field or member function named 'copy' in '[]const u8'
// :9:8: error: no field or member function named 'bar' in '@TypeOf(.{})'
// :12:18: error: no field or member function named 'bar' in 'tmp.entry2__struct_465'
// :12:18: error: no field or member function named 'bar' in 'tmp.entry2__struct_469'
// :12:6: note: struct declared here
test/cases/compile_errors/coerce_anon_struct.zig
+1 -1
View File
@@ -6,6 +6,6 @@ export fn foo() void {
// error
//
// :4:16: error: expected type 'tmp.T', found 'tmp.foo__struct_454'
// :4:16: error: expected type 'tmp.T', found 'tmp.foo__struct_458'
// :3:16: note: struct declared here
// :1:11: note: struct declared here
test/cases/compile_errors/redundant_try.zig
+2 -2
View File
@@ -44,9 +44,9 @@ comptime {
//
// :5:23: error: expected error union type, found 'comptime_int'
// :10:23: error: expected error union type, found '@TypeOf(.{})'
// :15:23: error: expected error union type, found 'tmp.test2__struct_491'
// :15:23: error: expected error union type, found 'tmp.test2__struct_495'
// :15:23: note: struct declared here
// :20:27: error: expected error union type, found 'tmp.test3__struct_493'
// :20:27: error: expected error union type, found 'tmp.test3__struct_497'
// :20:27: note: struct declared here
// :25:23: error: expected error union type, found 'struct { comptime *const [5:0]u8 = "hello" }'
// :31:13: error: expected error union type, found 'u32'