diff --git a/lib/std/zig/Zir.zig b/lib/std/zig/Zir.zig index 638d734107..089bc5e2ae 100644 --- a/lib/std/zig/Zir.zig +++ b/lib/std/zig/Zir.zig @@ -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, diff --git a/src/Air.zig b/src/Air.zig index e323259cbe..a4567c8c0d 100644 --- a/src/Air.zig +++ b/src/Air.zig @@ -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), diff --git a/src/InternPool.zig b/src/InternPool.zig index ab264d0e86..04eb4854e7 100644 --- a/src/InternPool.zig +++ b/src/InternPool.zig @@ -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, diff --git a/src/Sema.zig b/src/Sema.zig index 99e23e6f5a..2a914adcb5 100644 --- a/src/Sema.zig +++ b/src/Sema.zig @@ -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, diff --git a/src/Type.zig b/src/Type.zig index 925f65106d..3b31337587 100644 --- a/src/Type.zig +++ b/src/Type.zig @@ -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 }; diff --git a/src/arch/x86_64/CodeGen.zig b/src/arch/x86_64/CodeGen.zig index 2a9e25500c..77b4c46e1e 100644 --- a/src/arch/x86_64/CodeGen.zig +++ b/src/arch/x86_64/CodeGen.zig @@ -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(), diff --git a/src/arch/x86_64/Lower.zig b/src/arch/x86_64/Lower.zig index 6a8b5efcf8..ae0e3dc48d 100644 --- a/src/arch/x86_64/Lower.zig +++ b/src/arch/x86_64/Lower.zig @@ -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, diff --git a/src/codegen/c/Type.zig b/src/codegen/c/Type.zig index ec1bf40e0c..451bbc7818 100644 --- a/src/codegen/c/Type.zig +++ b/src/codegen/c/Type.zig @@ -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, diff --git a/test/behavior/x86_64/math.zig b/test/behavior/x86_64/math.zig index 36b0717bf0..515cb3b922 100644 --- a/test/behavior/x86_64/math.zig +++ b/test/behavior/x86_64/math.zig @@ -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; } diff --git a/test/cases/compile_errors/@import_zon_bad_type.zig b/test/cases/compile_errors/@import_zon_bad_type.zig index 93529f4951..edbacf7cb1 100644 --- a/test/cases/compile_errors/@import_zon_bad_type.zig +++ b/test/cases/compile_errors/@import_zon_bad_type.zig @@ -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 diff --git a/test/cases/compile_errors/anytype_param_requires_comptime.zig b/test/cases/compile_errors/anytype_param_requires_comptime.zig index abe4d95790..637bdb9be2 100644 --- a/test/cases/compile_errors/anytype_param_requires_comptime.zig +++ b/test/cases/compile_errors/anytype_param_requires_comptime.zig @@ -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 diff --git a/test/cases/compile_errors/bogus_method_call_on_slice.zig b/test/cases/compile_errors/bogus_method_call_on_slice.zig index bfc1c48893..ee758f2755 100644 --- a/test/cases/compile_errors/bogus_method_call_on_slice.zig +++ b/test/cases/compile_errors/bogus_method_call_on_slice.zig @@ -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 diff --git a/test/cases/compile_errors/coerce_anon_struct.zig b/test/cases/compile_errors/coerce_anon_struct.zig index 596f7c13ec..af8d949500 100644 --- a/test/cases/compile_errors/coerce_anon_struct.zig +++ b/test/cases/compile_errors/coerce_anon_struct.zig @@ -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 diff --git a/test/cases/compile_errors/redundant_try.zig b/test/cases/compile_errors/redundant_try.zig index 832ef24894..4127a36a1d 100644 --- a/test/cases/compile_errors/redundant_try.zig +++ b/test/cases/compile_errors/redundant_try.zig @@ -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'