| ... | @@ -2408,7 +2408,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2408,7 +2408,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2408 | } | 2408 | } |
| 2409 | | 2409 | |
| 2410 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | 2410 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2411 | @setEvalBranchQuota(17_100); | 2411 | @setEvalBranchQuota(18_100); |
| 2412 | const pt = cg.pt; | 2412 | const pt = cg.pt; |
| 2413 | const zcu = pt.zcu; | 2413 | const zcu = pt.zcu; |
| 2414 | const ip = &zcu.intern_pool; | 2414 | const ip = &zcu.intern_pool; |
| ... | @@ -6430,7 +6430,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6430,7 +6430,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6430 | .patterns = &.{ | 6430 | .patterns = &.{ |
| 6431 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, | 6431 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| 6432 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, | 6432 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| 6433 | .{ .src = .{ .to_mut_mmx, .to_sse, .none } }, | 6433 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| 6434 | }, | 6434 | }, |
| 6435 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 6435 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 6436 | .each = .{ .once = &.{ | 6436 | .each = .{ .once = &.{ |
| ... | @@ -6510,7 +6510,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6510,7 +6510,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6510 | .patterns = &.{ | 6510 | .patterns = &.{ |
| 6511 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, | 6511 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| 6512 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, | 6512 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| 6513 | .{ .src = .{ .to_mut_mmx, .to_sse, .none } }, | 6513 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| 6514 | }, | 6514 | }, |
| 6515 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 6515 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 6516 | .each = .{ .once = &.{ | 6516 | .each = .{ .once = &.{ |
| ... | @@ -6708,7 +6708,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6708,7 +6708,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6708 | .patterns = &.{ | 6708 | .patterns = &.{ |
| 6709 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, | 6709 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| 6710 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, | 6710 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| 6711 | .{ .src = .{ .to_mut_mmx, .to_sse, .none } }, | 6711 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| 6712 | }, | 6712 | }, |
| 6713 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 6713 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 6714 | .each = .{ .once = &.{ | 6714 | .each = .{ .once = &.{ |
| ... | @@ -6896,7 +6896,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -6896,7 +6896,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 6896 | .patterns = &.{ | 6896 | .patterns = &.{ |
| 6897 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, | 6897 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| 6898 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, | 6898 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| 6899 | .{ .src = .{ .to_mut_mmx, .to_sse, .none } }, | 6899 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| 6900 | }, | 6900 | }, |
| 6901 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 6901 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 6902 | .each = .{ .once = &.{ | 6902 | .each = .{ .once = &.{ |
| ... | @@ -7092,7 +7092,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -7092,7 +7092,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 7092 | .patterns = &.{ | 7092 | .patterns = &.{ |
| 7093 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, | 7093 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| 7094 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, | 7094 | .{ .src = .{ .mem, .to_mut_mmx, .none }, .commute = .{ 0, 1 } }, |
| 7095 | .{ .src = .{ .to_mut_mmx, .to_sse, .none } }, | 7095 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| 7096 | }, | 7096 | }, |
| 7097 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 7097 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 7098 | .each = .{ .once = &.{ | 7098 | .each = .{ .once = &.{ |
| ... | @@ -10996,8 +10996,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -10996,8 +10996,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 10996 | }, .{ | 10996 | }, .{ |
| 10997 | .required_features = .{ .sse4_1, null, null, null }, | 10997 | .required_features = .{ .sse4_1, null, null, null }, |
| 10998 | .src_constraints = .{ | 10998 | .src_constraints = .{ |
| 10999 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, | 10999 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 11000 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, | 11000 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| 11001 | .any, | 11001 | .any, |
| 11002 | }, | 11002 | }, |
| 11003 | .patterns = &.{ | 11003 | .patterns = &.{ |
| ... | @@ -12539,12 +12539,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12539,12 +12539,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12539 | }, | 12539 | }, |
| 12540 | .extra_temps = .{ | 12540 | .extra_temps = .{ |
| 12541 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 12541 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12542 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 12542 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 12543 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 12543 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 12544 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 12544 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 12545 | .{ .type = .isize, .kind = .{ .reg = .rcx } }, |
| 12545 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, | | |
| 12546 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 12546 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 12547 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 12547 | .unused, |
| 12548 | .unused, | 12548 | .unused, |
| 12549 | .unused, | 12549 | .unused, |
| 12550 | .unused, | 12550 | .unused, |
| ... | @@ -12567,12 +12567,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12567,12 +12567,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12567 | .{ ._, ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ }, | 12567 | .{ ._, ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ }, |
| 12568 | .{ ._, ._, .adc, .tmp5q, .lea(.tmp2q), ._, ._ }, | 12568 | .{ ._, ._, .adc, .tmp5q, .lea(.tmp2q), ._, ._ }, |
| 12569 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, | 12569 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| 12570 | .{ ._, ._, .lea, .tmp4p, .leaad(.tmp3, .sub_src0_elem_size, 8), ._, ._ }, | 12570 | .{ ._, ._, .lea, .tmp1p, .leaad(.tmp3, .sub_src0_elem_size, 8), ._, ._ }, |
| | 12571 | .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, |
| 12571 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, | 12572 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| 12572 | .{ ._, ._, .mov, .tmp6d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, | | |
| 12573 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 12573 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 12574 | .{ ._, ._, .mov, .tmp6q, .ua(.src0, .add_smin), ._, ._ }, | 12574 | .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ }, |
| 12575 | .{ ._, ._, .xor, .tmp5q, .tmp6q, ._, ._ }, | 12575 | .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ }, |
| 12576 | .{ .@"1:", ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ }, | 12576 | .{ .@"1:", ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ }, |
| 12577 | .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, | 12577 | .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| 12578 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 12578 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| ... | @@ -12634,12 +12634,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12634,12 +12634,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12634 | }, | 12634 | }, |
| 12635 | .extra_temps = .{ | 12635 | .extra_temps = .{ |
| 12636 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 12636 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12637 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 12637 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 12638 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 12638 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 12639 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 12639 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 12640 | .{ .type = .isize, .kind = .{ .reg = .rcx } }, |
| 12640 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, | | |
| 12641 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 12641 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 12642 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 12642 | .unused, |
| 12643 | .unused, | 12643 | .unused, |
| 12644 | .unused, | 12644 | .unused, |
| 12645 | .unused, | 12645 | .unused, |
| ... | @@ -12662,12 +12662,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12662,12 +12662,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12662 | .{ ._, ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ }, | 12662 | .{ ._, ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ }, |
| 12663 | .{ ._, ._, .adc, .tmp5q, .lea(.tmp2q), ._, ._ }, | 12663 | .{ ._, ._, .adc, .tmp5q, .lea(.tmp2q), ._, ._ }, |
| 12664 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, | 12664 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| 12665 | .{ ._, ._, .lea, .tmp4p, .leaad(.tmp3, .sub_src0_elem_size, 16), ._, ._ }, | 12665 | .{ ._, ._, .lea, .tmp1p, .leaad(.tmp3, .sub_src0_elem_size, 16), ._, ._ }, |
| | 12666 | .{ ._, ._, .mov, .tmp4d, .sia(-2, .src0, .add_elem_size_div_8), ._, ._ }, |
| 12666 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, | 12667 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| 12667 | .{ ._, ._, .mov, .tmp6d, .sia(-2, .src0, .add_elem_size_div_8), ._, ._ }, | | |
| 12668 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 12668 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 12669 | .{ ._, ._, .mov, .tmp6q, .ua(.src0, .add_smin), ._, ._ }, | 12669 | .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ }, |
| 12670 | .{ ._, ._, .xor, .tmp5q, .tmp6q, ._, ._ }, | 12670 | .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ }, |
| 12671 | .{ .@"1:", ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ }, | 12671 | .{ .@"1:", ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ }, |
| 12672 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, | 12672 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| 12673 | .{ ._, ._, .mov, .lead(.tmp3q, 8), .tmp5q, ._, ._ }, | 12673 | .{ ._, ._, .mov, .lead(.tmp3q, 8), .tmp5q, ._, ._ }, |
| ... | @@ -12732,12 +12732,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12732,12 +12732,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12732 | }, | 12732 | }, |
| 12733 | .extra_temps = .{ | 12733 | .extra_temps = .{ |
| 12734 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 12734 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12735 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 12735 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 12736 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 12736 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 12737 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 12737 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 12738 | .{ .type = .isize, .kind = .{ .reg = .rcx } }, |
| 12738 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, | | |
| 12739 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 12739 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 12740 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 12740 | .unused, |
| 12741 | .unused, | 12741 | .unused, |
| 12742 | .unused, | 12742 | .unused, |
| 12743 | .unused, | 12743 | .unused, |
| ... | @@ -12760,12 +12760,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12760,12 +12760,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12760 | .{ ._, ._l, .sa, .tmp5q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ }, | 12760 | .{ ._, ._l, .sa, .tmp5q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| 12761 | .{ ._, ._, .add, .tmp5q, .tmp5q, ._, ._ }, | 12761 | .{ ._, ._, .add, .tmp5q, .tmp5q, ._, ._ }, |
| 12762 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, | 12762 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| 12763 | .{ ._, ._, .lea, .tmp4p, .leaad(.tmp3, .sub_src0_elem_size, 8), ._, ._ }, | 12763 | .{ ._, ._, .lea, .tmp1p, .leaad(.tmp3, .sub_src0_elem_size, 8), ._, ._ }, |
| | 12764 | .{ ._, ._, .mov, .tmp4d, .sia(-2, .src0, .add_elem_size_div_8), ._, ._ }, |
| 12764 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, | 12765 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| 12765 | .{ ._, ._, .mov, .tmp6d, .sia(-2, .src0, .add_elem_size_div_8), ._, ._ }, | | |
| 12766 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 12766 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 12767 | .{ ._, ._, .mov, .tmp6q, .ua(.src0, .add_smin), ._, ._ }, | 12767 | .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ }, |
| 12768 | .{ ._, ._, .xor, .tmp5q, .tmp6q, ._, ._ }, | 12768 | .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ }, |
| 12769 | .{ ._, ._, .mov, .lead(.tmp3q, -8), .tmp5q, ._, ._ }, | 12769 | .{ ._, ._, .mov, .lead(.tmp3q, -8), .tmp5q, ._, ._ }, |
| 12770 | .{ .@"1:", ._r, .sa, .tmp5q, .ui(63), ._, ._ }, | 12770 | .{ .@"1:", ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| 12771 | .{ ._, ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ }, | 12771 | .{ ._, ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ }, |
| ... | @@ -12833,12 +12833,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12833,12 +12833,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12833 | }, | 12833 | }, |
| 12834 | .extra_temps = .{ | 12834 | .extra_temps = .{ |
| 12835 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, | 12835 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 12836 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| 12836 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 12837 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 12837 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 12838 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| 12838 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, | 12839 | .{ .type = .isize, .kind = .{ .reg = .rcx } }, |
| 12839 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, | | |
| 12840 | .{ .type = .i64, .kind = .{ .reg = .rax } }, | 12840 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 12841 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, | 12841 | .unused, |
| 12842 | .unused, | 12842 | .unused, |
| 12843 | .unused, | 12843 | .unused, |
| 12844 | .unused, | 12844 | .unused, |
| ... | @@ -12861,12 +12861,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -12861,12 +12861,12 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 12861 | .{ ._, ._l, .sa, .tmp5q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ }, | 12861 | .{ ._, ._l, .sa, .tmp5q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| 12862 | .{ ._, ._, .add, .tmp5q, .tmp5q, ._, ._ }, | 12862 | .{ ._, ._, .add, .tmp5q, .tmp5q, ._, ._ }, |
| 12863 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, | 12863 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| 12864 | .{ ._, ._, .lea, .tmp4p, .leaa(.tmp3, .sub_src0_elem_size), ._, ._ }, | 12864 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp3, .sub_src0_elem_size), ._, ._ }, |
| | 12865 | .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, |
| 12865 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, | 12866 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| 12866 | .{ ._, ._, .mov, .tmp6d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, | | |
| 12867 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 12867 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 12868 | .{ ._, ._, .mov, .tmp6q, .ua(.src0, .add_smin), ._, ._ }, | 12868 | .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ }, |
| 12869 | .{ ._, ._, .xor, .tmp5q, .tmp6q, ._, ._ }, | 12869 | .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ }, |
| 12870 | .{ ._, ._, .mov, .lead(.tmp3q, -8), .tmp5q, ._, ._ }, | 12870 | .{ ._, ._, .mov, .lead(.tmp3q, -8), .tmp5q, ._, ._ }, |
| 12871 | .{ .@"1:", ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, | 12871 | .{ .@"1:", ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| 12872 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, | 12872 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| ... | @@ -14814,9 +14814,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14814,9 +14814,8 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14814 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); | 14814 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 14815 | }, | 14815 | }, |
| 14816 | .sub_safe => unreachable, | 14816 | .sub_safe => unreachable, |
| 14817 | .sub_sat => |air_tag| if (use_old) try cg.airSubSat(inst) else fallback: { | 14817 | .sub_sat => |air_tag| if (use_old) try cg.airSubSat(inst) else { |
| 14818 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; | 14818 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 14819 | if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airSubSat(inst); | | |
| 14820 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); | 14819 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 14821 | var res: [1]Temp = undefined; | 14820 | var res: [1]Temp = undefined; |
| 14822 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ | 14821 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| ... | @@ -14829,6 +14828,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -14829,6 +14828,7 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 14829 | }, .{ | 14828 | }, .{ |
| 14830 | .src_constraints = .{ .{ .exact_int = 1 }, .{ .exact_int = 1 }, .any }, | 14829 | .src_constraints = .{ .{ .exact_int = 1 }, .{ .exact_int = 1 }, .any }, |
| 14831 | .patterns = &.{ | 14830 | .patterns = &.{ |
| | 14831 | .{ .src = .{ .{ .imm = 0 }, .to_mut_gpr, .none } }, |
| 14832 | .{ .src = .{ .any, .imm8, .none } }, | 14832 | .{ .src = .{ .any, .imm8, .none } }, |
| 14833 | }, | 14833 | }, |
| 14834 | .dst_temps = .{ .{ .imm = 0 }, .unused }, | 14834 | .dst_temps = .{ .{ .imm = 0 }, .unused }, |
| ... | @@ -16517,6 +16517,5125 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -16517,6 +16517,5125 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 16517 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, | 16517 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 16518 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, | 16518 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 16519 | } }, | 16519 | } }, |
| | 16520 | }, .{ |
| | 16521 | .required_features = .{ .mmx, null, null, null }, |
| | 16522 | .src_constraints = .{ |
| | 16523 | .{ .scalar_exact_int = .{ .of = .qword, .is = 1 } }, |
| | 16524 | .{ .scalar_exact_int = .{ .of = .qword, .is = 1 } }, |
| | 16525 | .any, |
| | 16526 | }, |
| | 16527 | .patterns = &.{ |
| | 16528 | .{ .src = .{ .mem, .to_mut_mmx, .none } }, |
| | 16529 | .{ .src = .{ .to_mmx, .to_mut_mmx, .none } }, |
| | 16530 | }, |
| | 16531 | .dst_temps = .{ .{ .ref = .src1 }, .unused }, |
| | 16532 | .each = .{ .once = &.{ |
| | 16533 | .{ ._, .p_, .andn, .dst0q, .src0q, ._, ._ }, |
| | 16534 | } }, |
| | 16535 | }, .{ |
| | 16536 | .required_features = .{ .avx, null, null, null }, |
| | 16537 | .src_constraints = .{ |
| | 16538 | .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 16539 | .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 16540 | .any, |
| | 16541 | }, |
| | 16542 | .patterns = &.{ |
| | 16543 | .{ .src = .{ .mem, .to_sse, .none } }, |
| | 16544 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 16545 | }, |
| | 16546 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 16547 | .each = .{ .once = &.{ |
| | 16548 | .{ ._, .vp_, .andn, .dst0x, .src1x, .src0x, ._ }, |
| | 16549 | } }, |
| | 16550 | }, .{ |
| | 16551 | .required_features = .{ .sse2, null, null, null }, |
| | 16552 | .src_constraints = .{ |
| | 16553 | .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 16554 | .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 16555 | .any, |
| | 16556 | }, |
| | 16557 | .patterns = &.{ |
| | 16558 | .{ .src = .{ .mem, .to_mut_sse, .none } }, |
| | 16559 | .{ .src = .{ .to_sse, .to_mut_sse, .none } }, |
| | 16560 | }, |
| | 16561 | .dst_temps = .{ .{ .ref = .src1 }, .unused }, |
| | 16562 | .each = .{ .once = &.{ |
| | 16563 | .{ ._, .p_, .andn, .dst0x, .src0x, ._, ._ }, |
| | 16564 | } }, |
| | 16565 | }, .{ |
| | 16566 | .required_features = .{ .sse, null, null, null }, |
| | 16567 | .src_constraints = .{ |
| | 16568 | .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 16569 | .{ .scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 16570 | .any, |
| | 16571 | }, |
| | 16572 | .patterns = &.{ |
| | 16573 | .{ .src = .{ .mem, .to_mut_sse, .none } }, |
| | 16574 | .{ .src = .{ .to_sse, .to_mut_sse, .none } }, |
| | 16575 | }, |
| | 16576 | .dst_temps = .{ .{ .ref = .src1 }, .unused }, |
| | 16577 | .each = .{ .once = &.{ |
| | 16578 | .{ ._, ._ps, .andn, .dst0x, .src0x, ._, ._ }, |
| | 16579 | } }, |
| | 16580 | }, .{ |
| | 16581 | .required_features = .{ .avx2, null, null, null }, |
| | 16582 | .src_constraints = .{ |
| | 16583 | .{ .scalar_exact_int = .{ .of = .yword, .is = 1 } }, |
| | 16584 | .{ .scalar_exact_int = .{ .of = .yword, .is = 1 } }, |
| | 16585 | .any, |
| | 16586 | }, |
| | 16587 | .patterns = &.{ |
| | 16588 | .{ .src = .{ .mem, .to_sse, .none } }, |
| | 16589 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 16590 | }, |
| | 16591 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 16592 | .each = .{ .once = &.{ |
| | 16593 | .{ ._, .vp_, .andn, .dst0y, .src1y, .src0y, ._ }, |
| | 16594 | } }, |
| | 16595 | }, .{ |
| | 16596 | .required_features = .{ .mmx, null, null, null }, |
| | 16597 | .src_constraints = .{ |
| | 16598 | .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 8 } }, |
| | 16599 | .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 8 } }, |
| | 16600 | .any, |
| | 16601 | }, |
| | 16602 | .patterns = &.{ |
| | 16603 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| | 16604 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| | 16605 | }, |
| | 16606 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 16607 | .each = .{ .once = &.{ |
| | 16608 | .{ ._, .p_b, .subs, .dst0q, .src1q, ._, ._ }, |
| | 16609 | } }, |
| | 16610 | }, .{ |
| | 16611 | .required_features = .{ .avx, null, null, null }, |
| | 16612 | .src_constraints = .{ |
| | 16613 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 16614 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 16615 | .any, |
| | 16616 | }, |
| | 16617 | .patterns = &.{ |
| | 16618 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 16619 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 16620 | }, |
| | 16621 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 16622 | .each = .{ .once = &.{ |
| | 16623 | .{ ._, .vp_b, .subs, .dst0x, .src0x, .src1x, ._ }, |
| | 16624 | } }, |
| | 16625 | }, .{ |
| | 16626 | .required_features = .{ .sse2, null, null, null }, |
| | 16627 | .src_constraints = .{ |
| | 16628 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 16629 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 16630 | .any, |
| | 16631 | }, |
| | 16632 | .patterns = &.{ |
| | 16633 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 16634 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 16635 | }, |
| | 16636 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 16637 | .each = .{ .once = &.{ |
| | 16638 | .{ ._, .p_b, .subs, .dst0x, .src1x, ._, ._ }, |
| | 16639 | } }, |
| | 16640 | }, .{ |
| | 16641 | .required_features = .{ .avx2, null, null, null }, |
| | 16642 | .src_constraints = .{ |
| | 16643 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 8 } }, |
| | 16644 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 8 } }, |
| | 16645 | .any, |
| | 16646 | }, |
| | 16647 | .patterns = &.{ |
| | 16648 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 16649 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 16650 | }, |
| | 16651 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 16652 | .each = .{ .once = &.{ |
| | 16653 | .{ ._, .vp_b, .subs, .dst0y, .src0y, .src1y, ._ }, |
| | 16654 | } }, |
| | 16655 | }, .{ |
| | 16656 | .required_features = .{ .avx, null, null, null }, |
| | 16657 | .src_constraints = .{ |
| | 16658 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 16659 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 16660 | .any, |
| | 16661 | }, |
| | 16662 | .patterns = &.{ |
| | 16663 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 16664 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 16665 | }, |
| | 16666 | .extra_temps = .{ |
| | 16667 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 16668 | .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 16669 | .{ .type = .vector_16_i8, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 16670 | .unused, |
| | 16671 | .unused, |
| | 16672 | .unused, |
| | 16673 | .unused, |
| | 16674 | .unused, |
| | 16675 | .unused, |
| | 16676 | .unused, |
| | 16677 | .unused, |
| | 16678 | }, |
| | 16679 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 16680 | .each = .{ .once = &.{ |
| | 16681 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 16682 | .{ ._, .vp_b, .sub, .dst0x, .src0x, .src1x, ._ }, |
| | 16683 | .{ ._, .vp_b, .maxs, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| | 16684 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 16685 | .{ ._, .vp_b, .mins, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| | 16686 | } }, |
| | 16687 | }, .{ |
| | 16688 | .required_features = .{ .sse4_1, null, null, null }, |
| | 16689 | .src_constraints = .{ |
| | 16690 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 16691 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 16692 | .any, |
| | 16693 | }, |
| | 16694 | .patterns = &.{ |
| | 16695 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 16696 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 16697 | }, |
| | 16698 | .extra_temps = .{ |
| | 16699 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 16700 | .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 16701 | .{ .type = .vector_16_i8, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 16702 | .unused, |
| | 16703 | .unused, |
| | 16704 | .unused, |
| | 16705 | .unused, |
| | 16706 | .unused, |
| | 16707 | .unused, |
| | 16708 | .unused, |
| | 16709 | .unused, |
| | 16710 | }, |
| | 16711 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 16712 | .each = .{ .once = &.{ |
| | 16713 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 16714 | .{ ._, .p_b, .sub, .dst0x, .src1x, ._, ._ }, |
| | 16715 | .{ ._, .p_b, .maxs, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 16716 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 16717 | .{ ._, .p_b, .mins, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 16718 | } }, |
| | 16719 | }, .{ |
| | 16720 | .required_features = .{ .sse2, null, null, null }, |
| | 16721 | .src_constraints = .{ |
| | 16722 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 16723 | .{ .scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 16724 | .any, |
| | 16725 | }, |
| | 16726 | .patterns = &.{ |
| | 16727 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 16728 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 16729 | }, |
| | 16730 | .extra_temps = .{ |
| | 16731 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 16732 | .{ .type = .vector_16_i8, .kind = .{ .slimit_delta_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 16733 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 16734 | .unused, |
| | 16735 | .unused, |
| | 16736 | .unused, |
| | 16737 | .unused, |
| | 16738 | .unused, |
| | 16739 | .unused, |
| | 16740 | .unused, |
| | 16741 | .unused, |
| | 16742 | }, |
| | 16743 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 16744 | .each = .{ .once = &.{ |
| | 16745 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 16746 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 16747 | .{ ._, .p_b, .sub, .dst0x, .tmp2x, ._, ._ }, |
| | 16748 | .{ ._, .p_b, .subs, .dst0x, .src1x, ._, ._ }, |
| | 16749 | .{ ._, .p_b, .add, .dst0x, .tmp2x, ._, ._ }, |
| | 16750 | .{ ._, .p_b, .adds, .dst0x, .tmp2x, ._, ._ }, |
| | 16751 | .{ ._, .p_b, .sub, .dst0x, .tmp2x, ._, ._ }, |
| | 16752 | } }, |
| | 16753 | }, .{ |
| | 16754 | .required_features = .{ .avx2, null, null, null }, |
| | 16755 | .src_constraints = .{ |
| | 16756 | .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| | 16757 | .{ .scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| | 16758 | .any, |
| | 16759 | }, |
| | 16760 | .patterns = &.{ |
| | 16761 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 16762 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 16763 | }, |
| | 16764 | .extra_temps = .{ |
| | 16765 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 16766 | .{ .type = .vector_32_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 16767 | .{ .type = .vector_32_i8, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 16768 | .unused, |
| | 16769 | .unused, |
| | 16770 | .unused, |
| | 16771 | .unused, |
| | 16772 | .unused, |
| | 16773 | .unused, |
| | 16774 | .unused, |
| | 16775 | .unused, |
| | 16776 | }, |
| | 16777 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 16778 | .each = .{ .once = &.{ |
| | 16779 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 16780 | .{ ._, .vp_b, .sub, .dst0y, .src0y, .src1y, ._ }, |
| | 16781 | .{ ._, .vp_b, .maxs, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 16782 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 16783 | .{ ._, .vp_b, .mins, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 16784 | } }, |
| | 16785 | }, .{ |
| | 16786 | .required_features = .{ .mmx, null, null, null }, |
| | 16787 | .src_constraints = .{ |
| | 16788 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, |
| | 16789 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, |
| | 16790 | .any, |
| | 16791 | }, |
| | 16792 | .patterns = &.{ |
| | 16793 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| | 16794 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| | 16795 | }, |
| | 16796 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 16797 | .each = .{ .once = &.{ |
| | 16798 | .{ ._, .p_b, .subus, .dst0q, .src1q, ._, ._ }, |
| | 16799 | } }, |
| | 16800 | }, .{ |
| | 16801 | .required_features = .{ .avx, null, null, null }, |
| | 16802 | .src_constraints = .{ |
| | 16803 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 16804 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 16805 | .any, |
| | 16806 | }, |
| | 16807 | .patterns = &.{ |
| | 16808 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 16809 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 16810 | }, |
| | 16811 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 16812 | .each = .{ .once = &.{ |
| | 16813 | .{ ._, .vp_b, .subus, .dst0x, .src0x, .src1x, ._ }, |
| | 16814 | } }, |
| | 16815 | }, .{ |
| | 16816 | .required_features = .{ .sse2, null, null, null }, |
| | 16817 | .src_constraints = .{ |
| | 16818 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 16819 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 16820 | .any, |
| | 16821 | }, |
| | 16822 | .patterns = &.{ |
| | 16823 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 16824 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 16825 | }, |
| | 16826 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 16827 | .each = .{ .once = &.{ |
| | 16828 | .{ ._, .p_b, .subus, .dst0x, .src1x, ._, ._ }, |
| | 16829 | } }, |
| | 16830 | }, .{ |
| | 16831 | .required_features = .{ .avx2, null, null, null }, |
| | 16832 | .src_constraints = .{ |
| | 16833 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| | 16834 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| | 16835 | .any, |
| | 16836 | }, |
| | 16837 | .patterns = &.{ |
| | 16838 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 16839 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 16840 | }, |
| | 16841 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 16842 | .each = .{ .once = &.{ |
| | 16843 | .{ ._, .vp_b, .subus, .dst0y, .src0y, .src1y, ._ }, |
| | 16844 | } }, |
| | 16845 | }, .{ |
| | 16846 | .required_features = .{ .mmx, null, null, null }, |
| | 16847 | .src_constraints = .{ |
| | 16848 | .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 16 } }, |
| | 16849 | .{ .scalar_exact_signed_int = .{ .of = .qword, .is = 16 } }, |
| | 16850 | .any, |
| | 16851 | }, |
| | 16852 | .patterns = &.{ |
| | 16853 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| | 16854 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| | 16855 | }, |
| | 16856 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 16857 | .each = .{ .once = &.{ |
| | 16858 | .{ ._, .p_w, .subs, .dst0q, .src1q, ._, ._ }, |
| | 16859 | } }, |
| | 16860 | }, .{ |
| | 16861 | .required_features = .{ .avx, null, null, null }, |
| | 16862 | .src_constraints = .{ |
| | 16863 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 16864 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 16865 | .any, |
| | 16866 | }, |
| | 16867 | .patterns = &.{ |
| | 16868 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 16869 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 16870 | }, |
| | 16871 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 16872 | .each = .{ .once = &.{ |
| | 16873 | .{ ._, .vp_w, .subs, .dst0x, .src0x, .src1x, ._ }, |
| | 16874 | } }, |
| | 16875 | }, .{ |
| | 16876 | .required_features = .{ .sse2, null, null, null }, |
| | 16877 | .src_constraints = .{ |
| | 16878 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 16879 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 16880 | .any, |
| | 16881 | }, |
| | 16882 | .patterns = &.{ |
| | 16883 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 16884 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 16885 | }, |
| | 16886 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 16887 | .each = .{ .once = &.{ |
| | 16888 | .{ ._, .p_w, .subs, .dst0x, .src1x, ._, ._ }, |
| | 16889 | } }, |
| | 16890 | }, .{ |
| | 16891 | .required_features = .{ .avx2, null, null, null }, |
| | 16892 | .src_constraints = .{ |
| | 16893 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 16 } }, |
| | 16894 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 16 } }, |
| | 16895 | .any, |
| | 16896 | }, |
| | 16897 | .patterns = &.{ |
| | 16898 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 16899 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 16900 | }, |
| | 16901 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 16902 | .each = .{ .once = &.{ |
| | 16903 | .{ ._, .vp_w, .subs, .dst0y, .src0y, .src1y, ._ }, |
| | 16904 | } }, |
| | 16905 | }, .{ |
| | 16906 | .required_features = .{ .sse, .mmx, null, null }, |
| | 16907 | .src_constraints = .{ |
| | 16908 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 16909 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 16910 | .any, |
| | 16911 | }, |
| | 16912 | .patterns = &.{ |
| | 16913 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| | 16914 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| | 16915 | }, |
| | 16916 | .extra_temps = .{ |
| | 16917 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 16918 | .{ .type = .vector_4_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .qword } } }, |
| | 16919 | .{ .type = .vector_4_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .qword } } }, |
| | 16920 | .unused, |
| | 16921 | .unused, |
| | 16922 | .unused, |
| | 16923 | .unused, |
| | 16924 | .unused, |
| | 16925 | .unused, |
| | 16926 | .unused, |
| | 16927 | .unused, |
| | 16928 | }, |
| | 16929 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 16930 | .each = .{ .once = &.{ |
| | 16931 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 16932 | .{ ._, .p_w, .sub, .dst0q, .src1q, ._, ._ }, |
| | 16933 | .{ ._, .p_w, .maxs, .dst0q, .lea(.tmp0q), ._, ._ }, |
| | 16934 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 16935 | .{ ._, .p_w, .mins, .dst0q, .lea(.tmp0q), ._, ._ }, |
| | 16936 | } }, |
| | 16937 | }, .{ |
| | 16938 | .required_features = .{ .avx, null, null, null }, |
| | 16939 | .src_constraints = .{ |
| | 16940 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 16941 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 16942 | .any, |
| | 16943 | }, |
| | 16944 | .patterns = &.{ |
| | 16945 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 16946 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 16947 | }, |
| | 16948 | .extra_temps = .{ |
| | 16949 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 16950 | .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 16951 | .{ .type = .vector_8_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 16952 | .unused, |
| | 16953 | .unused, |
| | 16954 | .unused, |
| | 16955 | .unused, |
| | 16956 | .unused, |
| | 16957 | .unused, |
| | 16958 | .unused, |
| | 16959 | .unused, |
| | 16960 | }, |
| | 16961 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 16962 | .each = .{ .once = &.{ |
| | 16963 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 16964 | .{ ._, .vp_w, .sub, .dst0x, .src0x, .src1x, ._ }, |
| | 16965 | .{ ._, .vp_w, .maxs, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| | 16966 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 16967 | .{ ._, .vp_w, .mins, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| | 16968 | } }, |
| | 16969 | }, .{ |
| | 16970 | .required_features = .{ .sse4_1, null, null, null }, |
| | 16971 | .src_constraints = .{ |
| | 16972 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 16973 | .{ .scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 16974 | .any, |
| | 16975 | }, |
| | 16976 | .patterns = &.{ |
| | 16977 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 16978 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 16979 | }, |
| | 16980 | .extra_temps = .{ |
| | 16981 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 16982 | .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 16983 | .{ .type = .vector_8_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 16984 | .unused, |
| | 16985 | .unused, |
| | 16986 | .unused, |
| | 16987 | .unused, |
| | 16988 | .unused, |
| | 16989 | .unused, |
| | 16990 | .unused, |
| | 16991 | .unused, |
| | 16992 | }, |
| | 16993 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 16994 | .each = .{ .once = &.{ |
| | 16995 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 16996 | .{ ._, .p_w, .sub, .dst0x, .src1x, ._, ._ }, |
| | 16997 | .{ ._, .p_w, .maxs, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 16998 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 16999 | .{ ._, .p_w, .mins, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 17000 | } }, |
| | 17001 | }, .{ |
| | 17002 | .required_features = .{ .avx2, null, null, null }, |
| | 17003 | .src_constraints = .{ |
| | 17004 | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| | 17005 | .{ .scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| | 17006 | .any, |
| | 17007 | }, |
| | 17008 | .patterns = &.{ |
| | 17009 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 17010 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17011 | }, |
| | 17012 | .extra_temps = .{ |
| | 17013 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17014 | .{ .type = .vector_16_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 17015 | .{ .type = .vector_16_i16, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 17016 | .unused, |
| | 17017 | .unused, |
| | 17018 | .unused, |
| | 17019 | .unused, |
| | 17020 | .unused, |
| | 17021 | .unused, |
| | 17022 | .unused, |
| | 17023 | .unused, |
| | 17024 | }, |
| | 17025 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 17026 | .each = .{ .once = &.{ |
| | 17027 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17028 | .{ ._, .vp_w, .sub, .dst0y, .src0y, .src1y, ._ }, |
| | 17029 | .{ ._, .vp_w, .maxs, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 17030 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 17031 | .{ ._, .vp_w, .mins, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 17032 | } }, |
| | 17033 | }, .{ |
| | 17034 | .required_features = .{ .mmx, null, null, null }, |
| | 17035 | .src_constraints = .{ |
| | 17036 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, |
| | 17037 | .{ .scalar_unsigned_int = .{ .of = .qword, .is = .word } }, |
| | 17038 | .any, |
| | 17039 | }, |
| | 17040 | .patterns = &.{ |
| | 17041 | .{ .src = .{ .to_mut_mmx, .mem, .none } }, |
| | 17042 | .{ .src = .{ .to_mut_mmx, .to_mmx, .none } }, |
| | 17043 | }, |
| | 17044 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 17045 | .each = .{ .once = &.{ |
| | 17046 | .{ ._, .p_w, .subus, .dst0q, .src1q, ._, ._ }, |
| | 17047 | } }, |
| | 17048 | }, .{ |
| | 17049 | .required_features = .{ .avx, null, null, null }, |
| | 17050 | .src_constraints = .{ |
| | 17051 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 17052 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 17053 | .any, |
| | 17054 | }, |
| | 17055 | .patterns = &.{ |
| | 17056 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 17057 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17058 | }, |
| | 17059 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 17060 | .each = .{ .once = &.{ |
| | 17061 | .{ ._, .vp_w, .subus, .dst0x, .src0x, .src1x, ._ }, |
| | 17062 | } }, |
| | 17063 | }, .{ |
| | 17064 | .required_features = .{ .sse2, null, null, null }, |
| | 17065 | .src_constraints = .{ |
| | 17066 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 17067 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 17068 | .any, |
| | 17069 | }, |
| | 17070 | .patterns = &.{ |
| | 17071 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 17072 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 17073 | }, |
| | 17074 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 17075 | .each = .{ .once = &.{ |
| | 17076 | .{ ._, .p_w, .subus, .dst0x, .src1x, ._, ._ }, |
| | 17077 | } }, |
| | 17078 | }, .{ |
| | 17079 | .required_features = .{ .avx2, null, null, null }, |
| | 17080 | .src_constraints = .{ |
| | 17081 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| | 17082 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| | 17083 | .any, |
| | 17084 | }, |
| | 17085 | .patterns = &.{ |
| | 17086 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 17087 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17088 | }, |
| | 17089 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 17090 | .each = .{ .once = &.{ |
| | 17091 | .{ ._, .vp_w, .subus, .dst0y, .src0y, .src1y, ._ }, |
| | 17092 | } }, |
| | 17093 | }, .{ |
| | 17094 | .required_features = .{ .avx, null, null, null }, |
| | 17095 | .src_constraints = .{ |
| | 17096 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 17097 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 17098 | .any, |
| | 17099 | }, |
| | 17100 | .patterns = &.{ |
| | 17101 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17102 | }, |
| | 17103 | .extra_temps = .{ |
| | 17104 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17105 | .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 17106 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 17107 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 17108 | .unused, |
| | 17109 | .unused, |
| | 17110 | .unused, |
| | 17111 | .unused, |
| | 17112 | .unused, |
| | 17113 | .unused, |
| | 17114 | .unused, |
| | 17115 | }, |
| | 17116 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 17117 | .each = .{ .once = &.{ |
| | 17118 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17119 | .{ ._, .vp_d, .sub, .dst0x, .src0x, .src1x, ._ }, |
| | 17120 | .{ ._, .vp_d, .sra, .tmp2x, .src0x, .ui(31), ._ }, |
| | 17121 | .{ ._, .vp_d, .cmpgt, .tmp3x, .dst0x, .src0x, ._ }, |
| | 17122 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .lea(.tmp0x), ._ }, |
| | 17123 | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .src1x, ._ }, |
| | 17124 | .{ ._, .v_ps, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, |
| | 17125 | } }, |
| | 17126 | }, .{ |
| | 17127 | .required_features = .{ .sse4_1, null, null, null }, |
| | 17128 | .src_constraints = .{ |
| | 17129 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 17130 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 17131 | .any, |
| | 17132 | }, |
| | 17133 | .patterns = &.{ |
| | 17134 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17135 | }, |
| | 17136 | .extra_temps = .{ |
| | 17137 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17138 | .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 17139 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 17140 | .{ .type = .vector_4_i32, .kind = .{ .reg = .xmm0 } }, |
| | 17141 | .unused, |
| | 17142 | .unused, |
| | 17143 | .unused, |
| | 17144 | .unused, |
| | 17145 | .unused, |
| | 17146 | .unused, |
| | 17147 | .unused, |
| | 17148 | }, |
| | 17149 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 17150 | .each = .{ .once = &.{ |
| | 17151 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17152 | .{ ._, ._dqa, .mov, .dst0x, .src0x, ._, ._ }, |
| | 17153 | .{ ._, .p_d, .sub, .dst0x, .src1x, ._, ._ }, |
| | 17154 | .{ ._, ._dqa, .mov, .tmp2x, .src0x, ._, ._ }, |
| | 17155 | .{ ._, .p_d, .sra, .tmp2x, .ui(31), ._, ._ }, |
| | 17156 | .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ }, |
| | 17157 | .{ ._, .p_d, .cmpgt, .tmp3x, .src0x, ._, ._ }, |
| | 17158 | .{ ._, .p_, .xor, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 17159 | .{ ._, .p_, .xor, .tmp3x, .src1x, ._, ._ }, |
| | 17160 | .{ ._, ._ps, .blendv, .dst0x, .tmp2x, .tmp3x, ._ }, |
| | 17161 | } }, |
| | 17162 | }, .{ |
| | 17163 | .required_features = .{ .avx2, null, null, null }, |
| | 17164 | .src_constraints = .{ |
| | 17165 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 32 } }, |
| | 17166 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 32 } }, |
| | 17167 | .any, |
| | 17168 | }, |
| | 17169 | .patterns = &.{ |
| | 17170 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17171 | }, |
| | 17172 | .extra_temps = .{ |
| | 17173 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17174 | .{ .type = .vector_8_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 17175 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 17176 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 17177 | .unused, |
| | 17178 | .unused, |
| | 17179 | .unused, |
| | 17180 | .unused, |
| | 17181 | .unused, |
| | 17182 | .unused, |
| | 17183 | .unused, |
| | 17184 | }, |
| | 17185 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 17186 | .each = .{ .once = &.{ |
| | 17187 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17188 | .{ ._, .vp_d, .sub, .dst0y, .src0y, .src1y, ._ }, |
| | 17189 | .{ ._, .vp_d, .sra, .tmp2y, .src0y, .ui(31), ._ }, |
| | 17190 | .{ ._, .vp_d, .cmpgt, .tmp3y, .dst0y, .src0y, ._ }, |
| | 17191 | .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .lea(.tmp0y), ._ }, |
| | 17192 | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .src1y, ._ }, |
| | 17193 | .{ ._, .v_ps, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y }, |
| | 17194 | } }, |
| | 17195 | }, .{ |
| | 17196 | .required_features = .{ .avx, null, null, null }, |
| | 17197 | .src_constraints = .{ |
| | 17198 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 17199 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 17200 | .any, |
| | 17201 | }, |
| | 17202 | .patterns = &.{ |
| | 17203 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 17204 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17205 | }, |
| | 17206 | .extra_temps = .{ |
| | 17207 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17208 | .{ .type = .vector_4_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 17209 | .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 17210 | .unused, |
| | 17211 | .unused, |
| | 17212 | .unused, |
| | 17213 | .unused, |
| | 17214 | .unused, |
| | 17215 | .unused, |
| | 17216 | .unused, |
| | 17217 | .unused, |
| | 17218 | }, |
| | 17219 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 17220 | .each = .{ .once = &.{ |
| | 17221 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17222 | .{ ._, .vp_d, .sub, .dst0x, .src0x, .src1x, ._ }, |
| | 17223 | .{ ._, .vp_d, .maxs, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| | 17224 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 17225 | .{ ._, .vp_d, .mins, .dst0x, .dst0x, .lea(.tmp0x), ._ }, |
| | 17226 | } }, |
| | 17227 | }, .{ |
| | 17228 | .required_features = .{ .sse4_1, null, null, null }, |
| | 17229 | .src_constraints = .{ |
| | 17230 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 17231 | .{ .scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 17232 | .any, |
| | 17233 | }, |
| | 17234 | .patterns = &.{ |
| | 17235 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 17236 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 17237 | }, |
| | 17238 | .extra_temps = .{ |
| | 17239 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17240 | .{ .type = .vector_4_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 17241 | .{ .type = .vector_4_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 17242 | .unused, |
| | 17243 | .unused, |
| | 17244 | .unused, |
| | 17245 | .unused, |
| | 17246 | .unused, |
| | 17247 | .unused, |
| | 17248 | .unused, |
| | 17249 | .unused, |
| | 17250 | }, |
| | 17251 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 17252 | .each = .{ .once = &.{ |
| | 17253 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17254 | .{ ._, .p_d, .sub, .dst0x, .src1x, ._, ._ }, |
| | 17255 | .{ ._, .p_d, .maxs, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 17256 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 17257 | .{ ._, .p_d, .mins, .dst0x, .lea(.tmp0x), ._, ._ }, |
| | 17258 | } }, |
| | 17259 | }, .{ |
| | 17260 | .required_features = .{ .avx2, null, null, null }, |
| | 17261 | .src_constraints = .{ |
| | 17262 | .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| | 17263 | .{ .scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| | 17264 | .any, |
| | 17265 | }, |
| | 17266 | .patterns = &.{ |
| | 17267 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 17268 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17269 | }, |
| | 17270 | .extra_temps = .{ |
| | 17271 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17272 | .{ .type = .vector_8_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 17273 | .{ .type = .vector_8_i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 17274 | .unused, |
| | 17275 | .unused, |
| | 17276 | .unused, |
| | 17277 | .unused, |
| | 17278 | .unused, |
| | 17279 | .unused, |
| | 17280 | .unused, |
| | 17281 | .unused, |
| | 17282 | }, |
| | 17283 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 17284 | .each = .{ .once = &.{ |
| | 17285 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17286 | .{ ._, .vp_d, .sub, .dst0y, .src0y, .src1y, ._ }, |
| | 17287 | .{ ._, .vp_d, .maxs, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 17288 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp2), ._, ._ }, |
| | 17289 | .{ ._, .vp_d, .mins, .dst0y, .dst0y, .lea(.tmp0y), ._ }, |
| | 17290 | } }, |
| | 17291 | }, .{ |
| | 17292 | .required_features = .{ .avx, null, null, null }, |
| | 17293 | .src_constraints = .{ |
| | 17294 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 17295 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 17296 | .any, |
| | 17297 | }, |
| | 17298 | .patterns = &.{ |
| | 17299 | .{ .src = .{ .mem, .to_sse, .none } }, |
| | 17300 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17301 | }, |
| | 17302 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 17303 | .each = .{ .once = &.{ |
| | 17304 | .{ ._, .vp_d, .maxu, .dst0x, .src1x, .src0x, ._ }, |
| | 17305 | .{ ._, .vp_d, .sub, .dst0x, .dst0x, .src1x, ._ }, |
| | 17306 | } }, |
| | 17307 | }, .{ |
| | 17308 | .required_features = .{ .sse4_1, null, null, null }, |
| | 17309 | .src_constraints = .{ |
| | 17310 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 17311 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 17312 | .any, |
| | 17313 | }, |
| | 17314 | .patterns = &.{ |
| | 17315 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 17316 | }, |
| | 17317 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 17318 | .each = .{ .once = &.{ |
| | 17319 | .{ ._, .p_d, .maxu, .src0x, .src1x, ._, ._ }, |
| | 17320 | .{ ._, .p_d, .sub, .dst0x, .src1x, ._, ._ }, |
| | 17321 | } }, |
| | 17322 | }, .{ |
| | 17323 | .required_features = .{ .avx2, null, null, null }, |
| | 17324 | .src_constraints = .{ |
| | 17325 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| | 17326 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| | 17327 | .any, |
| | 17328 | }, |
| | 17329 | .patterns = &.{ |
| | 17330 | .{ .src = .{ .mem, .to_sse, .none } }, |
| | 17331 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17332 | }, |
| | 17333 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 17334 | .each = .{ .once = &.{ |
| | 17335 | .{ ._, .vp_d, .maxu, .dst0y, .src1y, .src0y, ._ }, |
| | 17336 | .{ ._, .vp_d, .sub, .dst0y, .dst0y, .src1y, ._ }, |
| | 17337 | } }, |
| | 17338 | }, .{ |
| | 17339 | .required_features = .{ .avx, null, null, null }, |
| | 17340 | .src_constraints = .{ |
| | 17341 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 17342 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 17343 | .any, |
| | 17344 | }, |
| | 17345 | .patterns = &.{ |
| | 17346 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17347 | }, |
| | 17348 | .extra_temps = .{ |
| | 17349 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17350 | .{ .type = .vector_2_i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 17351 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 17352 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 17353 | .unused, |
| | 17354 | .unused, |
| | 17355 | .unused, |
| | 17356 | .unused, |
| | 17357 | .unused, |
| | 17358 | .unused, |
| | 17359 | .unused, |
| | 17360 | }, |
| | 17361 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 17362 | .each = .{ .once = &.{ |
| | 17363 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17364 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| | 17365 | .{ ._, .vp_q, .sub, .dst0x, .src0x, .src1x, ._ }, |
| | 17366 | .{ ._, .vp_q, .cmpgt, .tmp2x, .tmp2x, .src0x, ._ }, |
| | 17367 | .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .src0x, ._ }, |
| | 17368 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .lea(.tmp0x), ._ }, |
| | 17369 | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .src1x, ._ }, |
| | 17370 | .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, |
| | 17371 | } }, |
| | 17372 | }, .{ |
| | 17373 | .required_features = .{ .sse4_2, null, null, null }, |
| | 17374 | .src_constraints = .{ |
| | 17375 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 17376 | .{ .scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 17377 | .any, |
| | 17378 | }, |
| | 17379 | .patterns = &.{ |
| | 17380 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17381 | }, |
| | 17382 | .extra_temps = .{ |
| | 17383 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17384 | .{ .type = .vector_2_i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 17385 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 17386 | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, |
| | 17387 | .unused, |
| | 17388 | .unused, |
| | 17389 | .unused, |
| | 17390 | .unused, |
| | 17391 | .unused, |
| | 17392 | .unused, |
| | 17393 | .unused, |
| | 17394 | }, |
| | 17395 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 17396 | .each = .{ .once = &.{ |
| | 17397 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17398 | .{ ._, .p_, .xor, .tmp2x, .tmp2x, ._, ._ }, |
| | 17399 | .{ ._, ._dqa, .mov, .dst0x, .src0x, ._, ._ }, |
| | 17400 | .{ ._, .p_q, .sub, .dst0x, .src1x, ._, ._ }, |
| | 17401 | .{ ._, .p_q, .cmpgt, .tmp2x, .src0x, ._, ._ }, |
| | 17402 | .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ }, |
| | 17403 | .{ ._, .p_q, .cmpgt, .tmp3x, .src0x, ._, ._ }, |
| | 17404 | .{ ._, .p_, .xor, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 17405 | .{ ._, .p_, .xor, .tmp3x, .src1x, ._, ._ }, |
| | 17406 | .{ ._, ._pd, .blendv, .dst0x, .tmp2x, .tmp3x, ._ }, |
| | 17407 | } }, |
| | 17408 | }, .{ |
| | 17409 | .required_features = .{ .avx2, null, null, null }, |
| | 17410 | .src_constraints = .{ |
| | 17411 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 64 } }, |
| | 17412 | .{ .scalar_exact_signed_int = .{ .of = .yword, .is = 64 } }, |
| | 17413 | .any, |
| | 17414 | }, |
| | 17415 | .patterns = &.{ |
| | 17416 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17417 | }, |
| | 17418 | .extra_temps = .{ |
| | 17419 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17420 | .{ .type = .vector_4_i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .yword } } }, |
| | 17421 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 17422 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 17423 | .unused, |
| | 17424 | .unused, |
| | 17425 | .unused, |
| | 17426 | .unused, |
| | 17427 | .unused, |
| | 17428 | .unused, |
| | 17429 | .unused, |
| | 17430 | }, |
| | 17431 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 17432 | .each = .{ .once = &.{ |
| | 17433 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17434 | .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .tmp2y, ._ }, |
| | 17435 | .{ ._, .vp_q, .sub, .dst0y, .src0y, .src1y, ._ }, |
| | 17436 | .{ ._, .vp_q, .cmpgt, .tmp2y, .tmp2y, .src0y, ._ }, |
| | 17437 | .{ ._, .vp_q, .cmpgt, .tmp3y, .dst0y, .src0y, ._ }, |
| | 17438 | .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .lea(.tmp0y), ._ }, |
| | 17439 | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .src1y, ._ }, |
| | 17440 | .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y }, |
| | 17441 | } }, |
| | 17442 | }, .{ |
| | 17443 | .required_features = .{ .avx2, null, null, null }, |
| | 17444 | .src_constraints = .{ |
| | 17445 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 17446 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 17447 | .any, |
| | 17448 | }, |
| | 17449 | .patterns = &.{ |
| | 17450 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 17451 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17452 | }, |
| | 17453 | .extra_temps = .{ |
| | 17454 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17455 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 17456 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 17457 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 17458 | .unused, |
| | 17459 | .unused, |
| | 17460 | .unused, |
| | 17461 | .unused, |
| | 17462 | .unused, |
| | 17463 | .unused, |
| | 17464 | .unused, |
| | 17465 | }, |
| | 17466 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 17467 | .each = .{ .once = &.{ |
| | 17468 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17469 | .{ ._, .vp_q, .broadcast, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 17470 | .{ ._, .vp_q, .sub, .dst0x, .src0x, .src1x, ._ }, |
| | 17471 | .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp2x, .dst0x, ._ }, |
| | 17472 | .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, |
| | 17473 | .{ ._, .vp_q, .cmpeq, .tmp3x, .tmp3x, .tmp3x, ._ }, |
| | 17474 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp3x, ._ }, |
| | 17475 | .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .tmp2x, ._ }, |
| | 17476 | .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, |
| | 17477 | } }, |
| | 17478 | }, .{ |
| | 17479 | .required_features = .{ .avx, null, null, null }, |
| | 17480 | .src_constraints = .{ |
| | 17481 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 17482 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 17483 | .any, |
| | 17484 | }, |
| | 17485 | .patterns = &.{ |
| | 17486 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 17487 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17488 | }, |
| | 17489 | .extra_temps = .{ |
| | 17490 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17491 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 17492 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 17493 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 17494 | .unused, |
| | 17495 | .unused, |
| | 17496 | .unused, |
| | 17497 | .unused, |
| | 17498 | .unused, |
| | 17499 | .unused, |
| | 17500 | .unused, |
| | 17501 | }, |
| | 17502 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 17503 | .each = .{ .once = &.{ |
| | 17504 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17505 | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 17506 | .{ ._, .vp_q, .sub, .dst0x, .src0x, .src1x, ._ }, |
| | 17507 | .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp2x, .dst0x, ._ }, |
| | 17508 | .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, |
| | 17509 | .{ ._, .vp_q, .cmpeq, .tmp3x, .tmp3x, .tmp3x, ._ }, |
| | 17510 | .{ ._, .vp_, .xor, .tmp2x, .tmp2x, .tmp3x, ._ }, |
| | 17511 | .{ ._, .vp_q, .cmpgt, .tmp3x, .dst0x, .tmp2x, ._ }, |
| | 17512 | .{ ._, .vp_b, .blendv, .dst0x, .dst0x, .tmp2x, .tmp3x }, |
| | 17513 | } }, |
| | 17514 | }, .{ |
| | 17515 | .required_features = .{ .sse4_2, null, null, null }, |
| | 17516 | .src_constraints = .{ |
| | 17517 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 17518 | .{ .scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 17519 | .any, |
| | 17520 | }, |
| | 17521 | .patterns = &.{ |
| | 17522 | .{ .src = .{ .to_mut_sse, .mem, .none } }, |
| | 17523 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 17524 | }, |
| | 17525 | .extra_temps = .{ |
| | 17526 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17527 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 17528 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 17529 | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, |
| | 17530 | .unused, |
| | 17531 | .unused, |
| | 17532 | .unused, |
| | 17533 | .unused, |
| | 17534 | .unused, |
| | 17535 | .unused, |
| | 17536 | .unused, |
| | 17537 | }, |
| | 17538 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 17539 | .each = .{ .once = &.{ |
| | 17540 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17541 | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 17542 | .{ ._, .p_q, .sub, .dst0x, .src1x, ._, ._ }, |
| | 17543 | .{ ._, ._dqa, .mov, .tmp3x, .tmp2x, ._, ._ }, |
| | 17544 | .{ ._, .p_q, .cmpgt, .tmp3x, .dst0x, ._, ._ }, |
| | 17545 | .{ ._, .p_b, .blendv, .dst0x, .tmp2x, .tmp3x, ._ }, |
| | 17546 | .{ ._, .p_q, .cmpeq, .tmp3x, .tmp3x, ._, ._ }, |
| | 17547 | .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ }, |
| | 17548 | .{ ._, ._dqa, .mov, .tmp3x, .dst0x, ._, ._ }, |
| | 17549 | .{ ._, .p_q, .cmpgt, .tmp3x, .tmp2x, ._, ._ }, |
| | 17550 | .{ ._, .p_b, .blendv, .dst0x, .tmp2x, .tmp3x, ._ }, |
| | 17551 | } }, |
| | 17552 | }, .{ |
| | 17553 | .required_features = .{ .avx2, null, null, null }, |
| | 17554 | .src_constraints = .{ |
| | 17555 | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| | 17556 | .{ .scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| | 17557 | .any, |
| | 17558 | }, |
| | 17559 | .patterns = &.{ |
| | 17560 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 17561 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17562 | }, |
| | 17563 | .extra_temps = .{ |
| | 17564 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17565 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 17566 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 17567 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 17568 | .unused, |
| | 17569 | .unused, |
| | 17570 | .unused, |
| | 17571 | .unused, |
| | 17572 | .unused, |
| | 17573 | .unused, |
| | 17574 | .unused, |
| | 17575 | }, |
| | 17576 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 17577 | .each = .{ .once = &.{ |
| | 17578 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17579 | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, |
| | 17580 | .{ ._, .vp_q, .sub, .dst0y, .src0y, .src1y, ._ }, |
| | 17581 | .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp2y, .dst0y, ._ }, |
| | 17582 | .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y }, |
| | 17583 | .{ ._, .vp_q, .cmpeq, .tmp3y, .tmp3y, .tmp3y, ._ }, |
| | 17584 | .{ ._, .vp_, .xor, .tmp2y, .tmp2y, .tmp3y, ._ }, |
| | 17585 | .{ ._, .vp_q, .cmpgt, .tmp3y, .dst0y, .tmp2y, ._ }, |
| | 17586 | .{ ._, .vp_b, .blendv, .dst0y, .dst0y, .tmp2y, .tmp3y }, |
| | 17587 | } }, |
| | 17588 | }, .{ |
| | 17589 | .required_features = .{ .avx2, null, null, null }, |
| | 17590 | .src_constraints = .{ |
| | 17591 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 17592 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 17593 | .any, |
| | 17594 | }, |
| | 17595 | .patterns = &.{ |
| | 17596 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17597 | }, |
| | 17598 | .extra_temps = .{ |
| | 17599 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17600 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 17601 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 17602 | .unused, |
| | 17603 | .unused, |
| | 17604 | .unused, |
| | 17605 | .unused, |
| | 17606 | .unused, |
| | 17607 | .unused, |
| | 17608 | .unused, |
| | 17609 | .unused, |
| | 17610 | }, |
| | 17611 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 17612 | .each = .{ .once = &.{ |
| | 17613 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17614 | .{ ._, .vp_q, .broadcast, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 17615 | .{ ._, .vp_, .xor, .dst0x, .src0x, .tmp2x, ._ }, |
| | 17616 | .{ ._, .vp_, .xor, .tmp2x, .src1x, .tmp2x, ._ }, |
| | 17617 | .{ ._, .vp_q, .cmpgt, .tmp2x, .dst0x, .tmp2x, ._ }, |
| | 17618 | .{ ._, .vp_q, .sub, .dst0x, .src0x, .src1x, ._ }, |
| | 17619 | .{ ._, .vp_, .@"and", .dst0x, .dst0x, .tmp2x, ._ }, |
| | 17620 | } }, |
| | 17621 | }, .{ |
| | 17622 | .required_features = .{ .avx, null, null, null }, |
| | 17623 | .src_constraints = .{ |
| | 17624 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 17625 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 17626 | .any, |
| | 17627 | }, |
| | 17628 | .patterns = &.{ |
| | 17629 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17630 | }, |
| | 17631 | .extra_temps = .{ |
| | 17632 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17633 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 17634 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 17635 | .unused, |
| | 17636 | .unused, |
| | 17637 | .unused, |
| | 17638 | .unused, |
| | 17639 | .unused, |
| | 17640 | .unused, |
| | 17641 | .unused, |
| | 17642 | .unused, |
| | 17643 | }, |
| | 17644 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 17645 | .each = .{ .once = &.{ |
| | 17646 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17647 | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 17648 | .{ ._, .vp_, .xor, .dst0x, .src0x, .tmp2x, ._ }, |
| | 17649 | .{ ._, .vp_, .xor, .tmp2x, .src1x, .tmp2x, ._ }, |
| | 17650 | .{ ._, .vp_q, .cmpgt, .tmp2x, .dst0x, .tmp2x, ._ }, |
| | 17651 | .{ ._, .vp_q, .sub, .dst0x, .src0x, .src1x, ._ }, |
| | 17652 | .{ ._, .vp_, .@"and", .dst0x, .dst0x, .tmp2x, ._ }, |
| | 17653 | } }, |
| | 17654 | }, .{ |
| | 17655 | .required_features = .{ .sse4_2, null, null, null }, |
| | 17656 | .src_constraints = .{ |
| | 17657 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 17658 | .{ .scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 17659 | .any, |
| | 17660 | }, |
| | 17661 | .patterns = &.{ |
| | 17662 | .{ .src = .{ .to_mut_sse, .to_sse, .none } }, |
| | 17663 | }, |
| | 17664 | .extra_temps = .{ |
| | 17665 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17666 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 17667 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 17668 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 17669 | .unused, |
| | 17670 | .unused, |
| | 17671 | .unused, |
| | 17672 | .unused, |
| | 17673 | .unused, |
| | 17674 | .unused, |
| | 17675 | .unused, |
| | 17676 | }, |
| | 17677 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 17678 | .each = .{ .once = &.{ |
| | 17679 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17680 | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 17681 | .{ ._, ._dqa, .mov, .tmp3x, .src0x, ._, ._ }, |
| | 17682 | .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ }, |
| | 17683 | .{ ._, .p_, .xor, .tmp2x, .src1x, ._, ._ }, |
| | 17684 | .{ ._, .p_q, .cmpgt, .tmp3x, .tmp2x, ._, ._ }, |
| | 17685 | .{ ._, .p_q, .sub, .dst0x, .src1x, ._, ._ }, |
| | 17686 | .{ ._, .p_, .@"and", .dst0x, .tmp3x, ._, ._ }, |
| | 17687 | } }, |
| | 17688 | }, .{ |
| | 17689 | .required_features = .{ .avx2, null, null, null }, |
| | 17690 | .src_constraints = .{ |
| | 17691 | .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } }, |
| | 17692 | .{ .scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } }, |
| | 17693 | .any, |
| | 17694 | }, |
| | 17695 | .patterns = &.{ |
| | 17696 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17697 | }, |
| | 17698 | .extra_temps = .{ |
| | 17699 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 17700 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 17701 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 17702 | .unused, |
| | 17703 | .unused, |
| | 17704 | .unused, |
| | 17705 | .unused, |
| | 17706 | .unused, |
| | 17707 | .unused, |
| | 17708 | .unused, |
| | 17709 | .unused, |
| | 17710 | }, |
| | 17711 | .dst_temps = .{ .{ .rc = .sse }, .unused }, |
| | 17712 | .each = .{ .once = &.{ |
| | 17713 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 17714 | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, |
| | 17715 | .{ ._, .vp_, .xor, .dst0y, .src0y, .tmp2y, ._ }, |
| | 17716 | .{ ._, .vp_, .xor, .tmp2y, .src1y, .tmp2y, ._ }, |
| | 17717 | .{ ._, .vp_q, .cmpgt, .tmp2y, .dst0y, .tmp2y, ._ }, |
| | 17718 | .{ ._, .vp_q, .sub, .dst0y, .src0y, .src1y, ._ }, |
| | 17719 | .{ ._, .vp_, .@"and", .dst0y, .dst0y, .tmp2y, ._ }, |
| | 17720 | } }, |
| | 17721 | }, .{ |
| | 17722 | .required_features = .{ .avx, null, null, null }, |
| | 17723 | .src_constraints = .{ |
| | 17724 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 17725 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 17726 | .any, |
| | 17727 | }, |
| | 17728 | .patterns = &.{ |
| | 17729 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 17730 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17731 | }, |
| | 17732 | .extra_temps = .{ |
| | 17733 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 17734 | .unused, |
| | 17735 | .unused, |
| | 17736 | .unused, |
| | 17737 | .unused, |
| | 17738 | .unused, |
| | 17739 | .unused, |
| | 17740 | .unused, |
| | 17741 | .unused, |
| | 17742 | .unused, |
| | 17743 | .unused, |
| | 17744 | }, |
| | 17745 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 17746 | .each = .{ .once = &.{ |
| | 17747 | .{ ._, .vp_, .xor, .tmp0x, .tmp0x, .tmp0x, ._ }, |
| | 17748 | .{ ._, .vp_q, .sub, .dst0x, .src0x, .src1x, ._ }, |
| | 17749 | .{ ._, .v_pd, .blendv, .dst0x, .dst0x, .tmp0x, .dst0x }, |
| | 17750 | } }, |
| | 17751 | }, .{ |
| | 17752 | .required_features = .{ .sse4_1, null, null, null }, |
| | 17753 | .src_constraints = .{ |
| | 17754 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 17755 | .{ .scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 17756 | .any, |
| | 17757 | }, |
| | 17758 | .patterns = &.{ |
| | 17759 | .{ .src = .{ .{ .to_reg = .xmm0 }, .mem, .none } }, |
| | 17760 | .{ .src = .{ .{ .to_reg = .xmm0 }, .to_sse, .none } }, |
| | 17761 | }, |
| | 17762 | .extra_temps = .{ |
| | 17763 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 17764 | .unused, |
| | 17765 | .unused, |
| | 17766 | .unused, |
| | 17767 | .unused, |
| | 17768 | .unused, |
| | 17769 | .unused, |
| | 17770 | .unused, |
| | 17771 | .unused, |
| | 17772 | .unused, |
| | 17773 | .unused, |
| | 17774 | }, |
| | 17775 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 17776 | .each = .{ .once = &.{ |
| | 17777 | .{ ._, .p_, .xor, .tmp0x, .tmp0x, ._, ._ }, |
| | 17778 | .{ ._, .p_q, .sub, .dst0x, .src1x, ._, ._ }, |
| | 17779 | .{ ._, ._pd, .blendv, .dst0x, .tmp0x, .dst0x, ._ }, |
| | 17780 | } }, |
| | 17781 | }, .{ |
| | 17782 | .required_features = .{ .avx2, null, null, null }, |
| | 17783 | .src_constraints = .{ |
| | 17784 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| | 17785 | .{ .scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| | 17786 | .any, |
| | 17787 | }, |
| | 17788 | .patterns = &.{ |
| | 17789 | .{ .src = .{ .to_sse, .mem, .none } }, |
| | 17790 | .{ .src = .{ .to_sse, .to_sse, .none } }, |
| | 17791 | }, |
| | 17792 | .extra_temps = .{ |
| | 17793 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 17794 | .unused, |
| | 17795 | .unused, |
| | 17796 | .unused, |
| | 17797 | .unused, |
| | 17798 | .unused, |
| | 17799 | .unused, |
| | 17800 | .unused, |
| | 17801 | .unused, |
| | 17802 | .unused, |
| | 17803 | .unused, |
| | 17804 | }, |
| | 17805 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .sse } }, .unused }, |
| | 17806 | .each = .{ .once = &.{ |
| | 17807 | .{ ._, .vp_, .xor, .tmp0y, .tmp0y, .tmp0y, ._ }, |
| | 17808 | .{ ._, .vp_q, .sub, .dst0y, .src0y, .src1y, ._ }, |
| | 17809 | .{ ._, .v_pd, .blendv, .dst0y, .dst0y, .tmp0y, .dst0y }, |
| | 17810 | } }, |
| | 17811 | }, .{ |
| | 17812 | .required_features = .{ .avx2, null, null, null }, |
| | 17813 | .src_constraints = .{ |
| | 17814 | .{ .multiple_scalar_exact_int = .{ .of = .yword, .is = 1 } }, |
| | 17815 | .{ .multiple_scalar_exact_int = .{ .of = .yword, .is = 1 } }, |
| | 17816 | .any, |
| | 17817 | }, |
| | 17818 | .patterns = &.{ |
| | 17819 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 17820 | }, |
| | 17821 | .extra_temps = .{ |
| | 17822 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 17823 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 17824 | .unused, |
| | 17825 | .unused, |
| | 17826 | .unused, |
| | 17827 | .unused, |
| | 17828 | .unused, |
| | 17829 | .unused, |
| | 17830 | .unused, |
| | 17831 | .unused, |
| | 17832 | .unused, |
| | 17833 | }, |
| | 17834 | .dst_temps = .{ .mem, .unused }, |
| | 17835 | .clobbers = .{ .eflags = true }, |
| | 17836 | .each = .{ .once = &.{ |
| | 17837 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 17838 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 17839 | .{ ._, .vp_, .andn, .tmp1y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, |
| | 17840 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| | 17841 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 17842 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 17843 | } }, |
| | 17844 | }, .{ |
| | 17845 | .required_features = .{ .avx, null, null, null }, |
| | 17846 | .src_constraints = .{ |
| | 17847 | .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 17848 | .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 17849 | .any, |
| | 17850 | }, |
| | 17851 | .patterns = &.{ |
| | 17852 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 17853 | }, |
| | 17854 | .extra_temps = .{ |
| | 17855 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 17856 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 17857 | .unused, |
| | 17858 | .unused, |
| | 17859 | .unused, |
| | 17860 | .unused, |
| | 17861 | .unused, |
| | 17862 | .unused, |
| | 17863 | .unused, |
| | 17864 | .unused, |
| | 17865 | .unused, |
| | 17866 | }, |
| | 17867 | .dst_temps = .{ .mem, .unused }, |
| | 17868 | .clobbers = .{ .eflags = true }, |
| | 17869 | .each = .{ .once = &.{ |
| | 17870 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 17871 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 17872 | .{ ._, .vp_, .andn, .tmp1x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, |
| | 17873 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 17874 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 17875 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 17876 | } }, |
| | 17877 | }, .{ |
| | 17878 | .required_features = .{ .sse2, null, null, null }, |
| | 17879 | .src_constraints = .{ |
| | 17880 | .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 17881 | .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 17882 | .any, |
| | 17883 | }, |
| | 17884 | .patterns = &.{ |
| | 17885 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 17886 | }, |
| | 17887 | .extra_temps = .{ |
| | 17888 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 17889 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 17890 | .unused, |
| | 17891 | .unused, |
| | 17892 | .unused, |
| | 17893 | .unused, |
| | 17894 | .unused, |
| | 17895 | .unused, |
| | 17896 | .unused, |
| | 17897 | .unused, |
| | 17898 | .unused, |
| | 17899 | }, |
| | 17900 | .dst_temps = .{ .mem, .unused }, |
| | 17901 | .clobbers = .{ .eflags = true }, |
| | 17902 | .each = .{ .once = &.{ |
| | 17903 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 17904 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 17905 | .{ ._, .p_, .andn, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 17906 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 17907 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 17908 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 17909 | } }, |
| | 17910 | }, .{ |
| | 17911 | .required_features = .{ .sse, null, null, null }, |
| | 17912 | .src_constraints = .{ |
| | 17913 | .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 17914 | .{ .multiple_scalar_exact_int = .{ .of = .xword, .is = 1 } }, |
| | 17915 | .any, |
| | 17916 | }, |
| | 17917 | .patterns = &.{ |
| | 17918 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 17919 | }, |
| | 17920 | .extra_temps = .{ |
| | 17921 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 17922 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 17923 | .unused, |
| | 17924 | .unused, |
| | 17925 | .unused, |
| | 17926 | .unused, |
| | 17927 | .unused, |
| | 17928 | .unused, |
| | 17929 | .unused, |
| | 17930 | .unused, |
| | 17931 | .unused, |
| | 17932 | }, |
| | 17933 | .dst_temps = .{ .mem, .unused }, |
| | 17934 | .clobbers = .{ .eflags = true }, |
| | 17935 | .each = .{ .once = &.{ |
| | 17936 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 17937 | .{ .@"0:", ._ps, .mova, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 17938 | .{ ._, ._ps, .andn, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 17939 | .{ ._, ._ps, .mova, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 17940 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 17941 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 17942 | } }, |
| | 17943 | }, .{ |
| | 17944 | .required_features = .{ .mmx, null, null, null }, |
| | 17945 | .src_constraints = .{ |
| | 17946 | .{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 1 } }, |
| | 17947 | .{ .multiple_scalar_exact_int = .{ .of = .qword, .is = 1 } }, |
| | 17948 | .any, |
| | 17949 | }, |
| | 17950 | .patterns = &.{ |
| | 17951 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 17952 | }, |
| | 17953 | .extra_temps = .{ |
| | 17954 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 17955 | .{ .type = .vector_8_u8, .kind = .{ .rc = .mmx } }, |
| | 17956 | .unused, |
| | 17957 | .unused, |
| | 17958 | .unused, |
| | 17959 | .unused, |
| | 17960 | .unused, |
| | 17961 | .unused, |
| | 17962 | .unused, |
| | 17963 | .unused, |
| | 17964 | .unused, |
| | 17965 | }, |
| | 17966 | .dst_temps = .{ .mem, .unused }, |
| | 17967 | .clobbers = .{ .eflags = true }, |
| | 17968 | .each = .{ .once = &.{ |
| | 17969 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 17970 | .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 17971 | .{ ._, .p_, .andn, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 17972 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| | 17973 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 17974 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 17975 | } }, |
| | 17976 | }, .{ |
| | 17977 | .required_features = .{ .avx2, null, null, null }, |
| | 17978 | .src_constraints = .{ |
| | 17979 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 8 } }, |
| | 17980 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 8 } }, |
| | 17981 | .any, |
| | 17982 | }, |
| | 17983 | .patterns = &.{ |
| | 17984 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 17985 | }, |
| | 17986 | .extra_temps = .{ |
| | 17987 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 17988 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| | 17989 | .unused, |
| | 17990 | .unused, |
| | 17991 | .unused, |
| | 17992 | .unused, |
| | 17993 | .unused, |
| | 17994 | .unused, |
| | 17995 | .unused, |
| | 17996 | .unused, |
| | 17997 | .unused, |
| | 17998 | }, |
| | 17999 | .dst_temps = .{ .mem, .unused }, |
| | 18000 | .clobbers = .{ .eflags = true }, |
| | 18001 | .each = .{ .once = &.{ |
| | 18002 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18003 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18004 | .{ ._, .vp_b, .subs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 18005 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| | 18006 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 18007 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18008 | } }, |
| | 18009 | }, .{ |
| | 18010 | .required_features = .{ .avx, null, null, null }, |
| | 18011 | .src_constraints = .{ |
| | 18012 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 18013 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 18014 | .any, |
| | 18015 | }, |
| | 18016 | .patterns = &.{ |
| | 18017 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18018 | }, |
| | 18019 | .extra_temps = .{ |
| | 18020 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18021 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 18022 | .unused, |
| | 18023 | .unused, |
| | 18024 | .unused, |
| | 18025 | .unused, |
| | 18026 | .unused, |
| | 18027 | .unused, |
| | 18028 | .unused, |
| | 18029 | .unused, |
| | 18030 | .unused, |
| | 18031 | }, |
| | 18032 | .dst_temps = .{ .mem, .unused }, |
| | 18033 | .clobbers = .{ .eflags = true }, |
| | 18034 | .each = .{ .once = &.{ |
| | 18035 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18036 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18037 | .{ ._, .vp_b, .subs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 18038 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 18039 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 18040 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18041 | } }, |
| | 18042 | }, .{ |
| | 18043 | .required_features = .{ .sse2, null, null, null }, |
| | 18044 | .src_constraints = .{ |
| | 18045 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 18046 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 8 } }, |
| | 18047 | .any, |
| | 18048 | }, |
| | 18049 | .patterns = &.{ |
| | 18050 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18051 | }, |
| | 18052 | .extra_temps = .{ |
| | 18053 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18054 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 18055 | .unused, |
| | 18056 | .unused, |
| | 18057 | .unused, |
| | 18058 | .unused, |
| | 18059 | .unused, |
| | 18060 | .unused, |
| | 18061 | .unused, |
| | 18062 | .unused, |
| | 18063 | .unused, |
| | 18064 | }, |
| | 18065 | .dst_temps = .{ .mem, .unused }, |
| | 18066 | .clobbers = .{ .eflags = true }, |
| | 18067 | .each = .{ .once = &.{ |
| | 18068 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18069 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18070 | .{ ._, .p_b, .subs, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18071 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 18072 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 18073 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18074 | } }, |
| | 18075 | }, .{ |
| | 18076 | .required_features = .{ .mmx, null, null, null }, |
| | 18077 | .src_constraints = .{ |
| | 18078 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 8 } }, |
| | 18079 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 8 } }, |
| | 18080 | .any, |
| | 18081 | }, |
| | 18082 | .patterns = &.{ |
| | 18083 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18084 | }, |
| | 18085 | .extra_temps = .{ |
| | 18086 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18087 | .{ .type = .vector_8_i8, .kind = .{ .rc = .mmx } }, |
| | 18088 | .unused, |
| | 18089 | .unused, |
| | 18090 | .unused, |
| | 18091 | .unused, |
| | 18092 | .unused, |
| | 18093 | .unused, |
| | 18094 | .unused, |
| | 18095 | .unused, |
| | 18096 | .unused, |
| | 18097 | }, |
| | 18098 | .dst_temps = .{ .mem, .unused }, |
| | 18099 | .clobbers = .{ .eflags = true }, |
| | 18100 | .each = .{ .once = &.{ |
| | 18101 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18102 | .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18103 | .{ ._, .p_b, .subs, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18104 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| | 18105 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 18106 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18107 | } }, |
| | 18108 | }, .{ |
| | 18109 | .required_features = .{ .cmov, .slow_incdec, null, null }, |
| | 18110 | .src_constraints = .{ |
| | 18111 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 18112 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 18113 | .any, |
| | 18114 | }, |
| | 18115 | .patterns = &.{ |
| | 18116 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18117 | }, |
| | 18118 | .extra_temps = .{ |
| | 18119 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18120 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 18121 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 18122 | .unused, |
| | 18123 | .unused, |
| | 18124 | .unused, |
| | 18125 | .unused, |
| | 18126 | .unused, |
| | 18127 | .unused, |
| | 18128 | .unused, |
| | 18129 | .unused, |
| | 18130 | }, |
| | 18131 | .dst_temps = .{ .mem, .unused }, |
| | 18132 | .clobbers = .{ .eflags = true }, |
| | 18133 | .each = .{ .once = &.{ |
| | 18134 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18135 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18136 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 18137 | .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ }, |
| | 18138 | .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ }, |
| | 18139 | .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18140 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 18141 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 18142 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 18143 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18144 | } }, |
| | 18145 | }, .{ |
| | 18146 | .required_features = .{ .cmov, null, null, null }, |
| | 18147 | .src_constraints = .{ |
| | 18148 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 18149 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 18150 | .any, |
| | 18151 | }, |
| | 18152 | .patterns = &.{ |
| | 18153 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18154 | }, |
| | 18155 | .extra_temps = .{ |
| | 18156 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18157 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 18158 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 18159 | .unused, |
| | 18160 | .unused, |
| | 18161 | .unused, |
| | 18162 | .unused, |
| | 18163 | .unused, |
| | 18164 | .unused, |
| | 18165 | .unused, |
| | 18166 | .unused, |
| | 18167 | }, |
| | 18168 | .dst_temps = .{ .mem, .unused }, |
| | 18169 | .clobbers = .{ .eflags = true }, |
| | 18170 | .each = .{ .once = &.{ |
| | 18171 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18172 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18173 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 18174 | .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ }, |
| | 18175 | .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ }, |
| | 18176 | .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18177 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 18178 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 18179 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 18180 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 18181 | } }, |
| | 18182 | }, .{ |
| | 18183 | .required_features = .{ .slow_incdec, null, null, null }, |
| | 18184 | .src_constraints = .{ |
| | 18185 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 18186 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 18187 | .any, |
| | 18188 | }, |
| | 18189 | .patterns = &.{ |
| | 18190 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18191 | }, |
| | 18192 | .extra_temps = .{ |
| | 18193 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18194 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 18195 | .unused, |
| | 18196 | .unused, |
| | 18197 | .unused, |
| | 18198 | .unused, |
| | 18199 | .unused, |
| | 18200 | .unused, |
| | 18201 | .unused, |
| | 18202 | .unused, |
| | 18203 | .unused, |
| | 18204 | }, |
| | 18205 | .dst_temps = .{ .mem, .unused }, |
| | 18206 | .clobbers = .{ .eflags = true }, |
| | 18207 | .each = .{ .once = &.{ |
| | 18208 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18209 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18210 | .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18211 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 18212 | .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ }, |
| | 18213 | .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smin), ._, ._ }, |
| | 18214 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 18215 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 18216 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18217 | } }, |
| | 18218 | }, .{ |
| | 18219 | .src_constraints = .{ |
| | 18220 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 18221 | .{ .multiple_scalar_exact_signed_int = .{ .of = .byte, .is = 8 } }, |
| | 18222 | .any, |
| | 18223 | }, |
| | 18224 | .patterns = &.{ |
| | 18225 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18226 | }, |
| | 18227 | .extra_temps = .{ |
| | 18228 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18229 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 18230 | .unused, |
| | 18231 | .unused, |
| | 18232 | .unused, |
| | 18233 | .unused, |
| | 18234 | .unused, |
| | 18235 | .unused, |
| | 18236 | .unused, |
| | 18237 | .unused, |
| | 18238 | .unused, |
| | 18239 | }, |
| | 18240 | .dst_temps = .{ .mem, .unused }, |
| | 18241 | .clobbers = .{ .eflags = true }, |
| | 18242 | .each = .{ .once = &.{ |
| | 18243 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18244 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18245 | .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18246 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 18247 | .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ }, |
| | 18248 | .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smin), ._, ._ }, |
| | 18249 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 18250 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 18251 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 18252 | } }, |
| | 18253 | }, .{ |
| | 18254 | .required_features = .{ .avx2, null, null, null }, |
| | 18255 | .src_constraints = .{ |
| | 18256 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| | 18257 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .byte } }, |
| | 18258 | .any, |
| | 18259 | }, |
| | 18260 | .patterns = &.{ |
| | 18261 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18262 | }, |
| | 18263 | .extra_temps = .{ |
| | 18264 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18265 | .{ .type = .i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 18266 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| | 18267 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| | 18268 | .{ .type = .vector_32_i8, .kind = .{ .rc = .sse } }, |
| | 18269 | .unused, |
| | 18270 | .unused, |
| | 18271 | .unused, |
| | 18272 | .unused, |
| | 18273 | .unused, |
| | 18274 | .unused, |
| | 18275 | }, |
| | 18276 | .dst_temps = .{ .mem, .unused }, |
| | 18277 | .clobbers = .{ .eflags = true }, |
| | 18278 | .each = .{ .once = &.{ |
| | 18279 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 18280 | .{ ._, .vp_b, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ }, |
| | 18281 | .{ ._, .vp_b, .broadcast, .tmp3y, .lea(.tmp0b), ._, ._ }, |
| | 18282 | .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ }, |
| | 18283 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18284 | .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18285 | .{ ._, .vp_b, .sub, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 18286 | .{ ._, .vp_b, .maxs, .tmp4y, .tmp4y, .tmp3y, ._ }, |
| | 18287 | .{ ._, .vp_b, .mins, .tmp4y, .tmp4y, .tmp2y, ._ }, |
| | 18288 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ }, |
| | 18289 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 18290 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18291 | } }, |
| | 18292 | }, .{ |
| | 18293 | .required_features = .{ .avx, null, null, null }, |
| | 18294 | .src_constraints = .{ |
| | 18295 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 18296 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 18297 | .any, |
| | 18298 | }, |
| | 18299 | .patterns = &.{ |
| | 18300 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18301 | }, |
| | 18302 | .extra_temps = .{ |
| | 18303 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18304 | .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 18305 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 18306 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 18307 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 18308 | .unused, |
| | 18309 | .unused, |
| | 18310 | .unused, |
| | 18311 | .unused, |
| | 18312 | .unused, |
| | 18313 | .unused, |
| | 18314 | }, |
| | 18315 | .dst_temps = .{ .mem, .unused }, |
| | 18316 | .clobbers = .{ .eflags = true }, |
| | 18317 | .each = .{ .once = &.{ |
| | 18318 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 18319 | .{ ._, .vp_b, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| | 18320 | .{ ._, .v_dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ }, |
| | 18321 | .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ }, |
| | 18322 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18323 | .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18324 | .{ ._, .vp_b, .sub, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 18325 | .{ ._, .vp_b, .maxs, .tmp4x, .tmp4x, .tmp3x, ._ }, |
| | 18326 | .{ ._, .vp_b, .mins, .tmp4x, .tmp4x, .tmp2x, ._ }, |
| | 18327 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 18328 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 18329 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18330 | } }, |
| | 18331 | }, .{ |
| | 18332 | .required_features = .{ .sse4_1, null, null, null }, |
| | 18333 | .src_constraints = .{ |
| | 18334 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 18335 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 18336 | .any, |
| | 18337 | }, |
| | 18338 | .patterns = &.{ |
| | 18339 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18340 | }, |
| | 18341 | .extra_temps = .{ |
| | 18342 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18343 | .{ .type = .vector_16_i8, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 18344 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 18345 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 18346 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 18347 | .unused, |
| | 18348 | .unused, |
| | 18349 | .unused, |
| | 18350 | .unused, |
| | 18351 | .unused, |
| | 18352 | .unused, |
| | 18353 | }, |
| | 18354 | .dst_temps = .{ .mem, .unused }, |
| | 18355 | .clobbers = .{ .eflags = true }, |
| | 18356 | .each = .{ .once = &.{ |
| | 18357 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 18358 | .{ ._, .p_b, .cmpeq, .tmp2x, .tmp2x, ._, ._ }, |
| | 18359 | .{ ._, ._dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ }, |
| | 18360 | .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ }, |
| | 18361 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18362 | .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18363 | .{ ._, .p_b, .sub, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18364 | .{ ._, .p_b, .maxs, .tmp4x, .tmp3x, ._, ._ }, |
| | 18365 | .{ ._, .p_b, .mins, .tmp4x, .tmp2x, ._, ._ }, |
| | 18366 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 18367 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 18368 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18369 | } }, |
| | 18370 | }, .{ |
| | 18371 | .required_features = .{ .sse2, null, null, null }, |
| | 18372 | .src_constraints = .{ |
| | 18373 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 18374 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .byte } }, |
| | 18375 | .any, |
| | 18376 | }, |
| | 18377 | .patterns = &.{ |
| | 18378 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18379 | }, |
| | 18380 | .extra_temps = .{ |
| | 18381 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18382 | .{ .type = .vector_16_i8, .kind = .{ .slimit_delta_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 18383 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 18384 | .{ .type = .vector_16_i8, .kind = .{ .rc = .sse } }, |
| | 18385 | .unused, |
| | 18386 | .unused, |
| | 18387 | .unused, |
| | 18388 | .unused, |
| | 18389 | .unused, |
| | 18390 | .unused, |
| | 18391 | .unused, |
| | 18392 | }, |
| | 18393 | .dst_temps = .{ .mem, .unused }, |
| | 18394 | .clobbers = .{ .eflags = true }, |
| | 18395 | .each = .{ .once = &.{ |
| | 18396 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 18397 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 18398 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18399 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18400 | .{ ._, .p_b, .sub, .tmp3x, .tmp2x, ._, ._ }, |
| | 18401 | .{ ._, .p_b, .subs, .tmp3x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18402 | .{ ._, .p_b, .add, .tmp3x, .tmp2x, ._, ._ }, |
| | 18403 | .{ ._, .p_b, .adds, .tmp3x, .tmp2x, ._, ._ }, |
| | 18404 | .{ ._, .p_b, .sub, .tmp3x, .tmp2x, ._, ._ }, |
| | 18405 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 18406 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 18407 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18408 | } }, |
| | 18409 | }, .{ |
| | 18410 | .required_features = .{ .cmov, .slow_incdec, null, null }, |
| | 18411 | .src_constraints = .{ |
| | 18412 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 18413 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 18414 | .any, |
| | 18415 | }, |
| | 18416 | .patterns = &.{ |
| | 18417 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18418 | }, |
| | 18419 | .extra_temps = .{ |
| | 18420 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18421 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 18422 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 18423 | .unused, |
| | 18424 | .unused, |
| | 18425 | .unused, |
| | 18426 | .unused, |
| | 18427 | .unused, |
| | 18428 | .unused, |
| | 18429 | .unused, |
| | 18430 | .unused, |
| | 18431 | }, |
| | 18432 | .dst_temps = .{ .mem, .unused }, |
| | 18433 | .clobbers = .{ .eflags = true }, |
| | 18434 | .each = .{ .once = &.{ |
| | 18435 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18436 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18437 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 18438 | .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ }, |
| | 18439 | .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18440 | .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ }, |
| | 18441 | .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ }, |
| | 18442 | .{ ._, ._po, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 18443 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 18444 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 18445 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18446 | } }, |
| | 18447 | }, .{ |
| | 18448 | .required_features = .{ .cmov, null, null, null }, |
| | 18449 | .src_constraints = .{ |
| | 18450 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 18451 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 18452 | .any, |
| | 18453 | }, |
| | 18454 | .patterns = &.{ |
| | 18455 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18456 | }, |
| | 18457 | .extra_temps = .{ |
| | 18458 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18459 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 18460 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 18461 | .unused, |
| | 18462 | .unused, |
| | 18463 | .unused, |
| | 18464 | .unused, |
| | 18465 | .unused, |
| | 18466 | .unused, |
| | 18467 | .unused, |
| | 18468 | .unused, |
| | 18469 | }, |
| | 18470 | .dst_temps = .{ .mem, .unused }, |
| | 18471 | .clobbers = .{ .eflags = true }, |
| | 18472 | .each = .{ .once = &.{ |
| | 18473 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18474 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18475 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 18476 | .{ ._, ._r, .sa, .tmp2b, .ui(7), ._, ._ }, |
| | 18477 | .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18478 | .{ ._, ._, .xor, .tmp2b, .sa(.src0, .add_smax), ._, ._ }, |
| | 18479 | .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ }, |
| | 18480 | .{ ._, ._po, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 18481 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 18482 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 18483 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 18484 | } }, |
| | 18485 | }, .{ |
| | 18486 | .required_features = .{ .slow_incdec, null, null, null }, |
| | 18487 | .src_constraints = .{ |
| | 18488 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 18489 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 18490 | .any, |
| | 18491 | }, |
| | 18492 | .patterns = &.{ |
| | 18493 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18494 | }, |
| | 18495 | .extra_temps = .{ |
| | 18496 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18497 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 18498 | .unused, |
| | 18499 | .unused, |
| | 18500 | .unused, |
| | 18501 | .unused, |
| | 18502 | .unused, |
| | 18503 | .unused, |
| | 18504 | .unused, |
| | 18505 | .unused, |
| | 18506 | .unused, |
| | 18507 | }, |
| | 18508 | .dst_temps = .{ .mem, .unused }, |
| | 18509 | .clobbers = .{ .eflags = true }, |
| | 18510 | .each = .{ .once = &.{ |
| | 18511 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18512 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18513 | .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18514 | .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ }, |
| | 18515 | .{ ._, ._pe, .j, .@"1f", ._, ._, ._ }, |
| | 18516 | .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ }, |
| | 18517 | .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smax), ._, ._ }, |
| | 18518 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 18519 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 18520 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18521 | } }, |
| | 18522 | }, .{ |
| | 18523 | .src_constraints = .{ |
| | 18524 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 18525 | .{ .multiple_scalar_signed_int = .{ .of = .byte, .is = .byte } }, |
| | 18526 | .any, |
| | 18527 | }, |
| | 18528 | .patterns = &.{ |
| | 18529 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18530 | }, |
| | 18531 | .extra_temps = .{ |
| | 18532 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18533 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| | 18534 | .unused, |
| | 18535 | .unused, |
| | 18536 | .unused, |
| | 18537 | .unused, |
| | 18538 | .unused, |
| | 18539 | .unused, |
| | 18540 | .unused, |
| | 18541 | .unused, |
| | 18542 | .unused, |
| | 18543 | }, |
| | 18544 | .dst_temps = .{ .mem, .unused }, |
| | 18545 | .clobbers = .{ .eflags = true }, |
| | 18546 | .each = .{ .once = &.{ |
| | 18547 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18548 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18549 | .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18550 | .{ ._, ._, .@"test", .tmp1b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ }, |
| | 18551 | .{ ._, ._pe, .j, .@"1f", ._, ._, ._ }, |
| | 18552 | .{ ._, ._r, .sa, .tmp1b, .ui(7), ._, ._ }, |
| | 18553 | .{ ._, ._, .xor, .tmp1b, .sa(.src0, .add_smax), ._, ._ }, |
| | 18554 | .{ .@"1:", ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 18555 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 18556 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 18557 | } }, |
| | 18558 | }, .{ |
| | 18559 | .required_features = .{ .avx2, null, null, null }, |
| | 18560 | .src_constraints = .{ |
| | 18561 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| | 18562 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .byte } }, |
| | 18563 | .any, |
| | 18564 | }, |
| | 18565 | .patterns = &.{ |
| | 18566 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18567 | }, |
| | 18568 | .extra_temps = .{ |
| | 18569 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18570 | .{ .type = .vector_32_u8, .kind = .{ .rc = .sse } }, |
| | 18571 | .unused, |
| | 18572 | .unused, |
| | 18573 | .unused, |
| | 18574 | .unused, |
| | 18575 | .unused, |
| | 18576 | .unused, |
| | 18577 | .unused, |
| | 18578 | .unused, |
| | 18579 | .unused, |
| | 18580 | }, |
| | 18581 | .dst_temps = .{ .mem, .unused }, |
| | 18582 | .clobbers = .{ .eflags = true }, |
| | 18583 | .each = .{ .once = &.{ |
| | 18584 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18585 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18586 | .{ ._, .vp_b, .subus, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 18587 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| | 18588 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 18589 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18590 | } }, |
| | 18591 | }, .{ |
| | 18592 | .required_features = .{ .avx, null, null, null }, |
| | 18593 | .src_constraints = .{ |
| | 18594 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 18595 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 18596 | .any, |
| | 18597 | }, |
| | 18598 | .patterns = &.{ |
| | 18599 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18600 | }, |
| | 18601 | .extra_temps = .{ |
| | 18602 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18603 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 18604 | .unused, |
| | 18605 | .unused, |
| | 18606 | .unused, |
| | 18607 | .unused, |
| | 18608 | .unused, |
| | 18609 | .unused, |
| | 18610 | .unused, |
| | 18611 | .unused, |
| | 18612 | .unused, |
| | 18613 | }, |
| | 18614 | .dst_temps = .{ .mem, .unused }, |
| | 18615 | .clobbers = .{ .eflags = true }, |
| | 18616 | .each = .{ .once = &.{ |
| | 18617 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18618 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18619 | .{ ._, .vp_b, .subus, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 18620 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 18621 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 18622 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18623 | } }, |
| | 18624 | }, .{ |
| | 18625 | .required_features = .{ .sse2, null, null, null }, |
| | 18626 | .src_constraints = .{ |
| | 18627 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 18628 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .byte } }, |
| | 18629 | .any, |
| | 18630 | }, |
| | 18631 | .patterns = &.{ |
| | 18632 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18633 | }, |
| | 18634 | .extra_temps = .{ |
| | 18635 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18636 | .{ .type = .vector_16_u8, .kind = .{ .rc = .sse } }, |
| | 18637 | .unused, |
| | 18638 | .unused, |
| | 18639 | .unused, |
| | 18640 | .unused, |
| | 18641 | .unused, |
| | 18642 | .unused, |
| | 18643 | .unused, |
| | 18644 | .unused, |
| | 18645 | .unused, |
| | 18646 | }, |
| | 18647 | .dst_temps = .{ .mem, .unused }, |
| | 18648 | .clobbers = .{ .eflags = true }, |
| | 18649 | .each = .{ .once = &.{ |
| | 18650 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18651 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18652 | .{ ._, .p_b, .subus, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18653 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 18654 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 18655 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18656 | } }, |
| | 18657 | }, .{ |
| | 18658 | .required_features = .{ .mmx, null, null, null }, |
| | 18659 | .src_constraints = .{ |
| | 18660 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, |
| | 18661 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .byte } }, |
| | 18662 | .any, |
| | 18663 | }, |
| | 18664 | .patterns = &.{ |
| | 18665 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18666 | }, |
| | 18667 | .extra_temps = .{ |
| | 18668 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18669 | .{ .type = .vector_8_u8, .kind = .{ .rc = .mmx } }, |
| | 18670 | .unused, |
| | 18671 | .unused, |
| | 18672 | .unused, |
| | 18673 | .unused, |
| | 18674 | .unused, |
| | 18675 | .unused, |
| | 18676 | .unused, |
| | 18677 | .unused, |
| | 18678 | .unused, |
| | 18679 | }, |
| | 18680 | .dst_temps = .{ .mem, .unused }, |
| | 18681 | .clobbers = .{ .eflags = true }, |
| | 18682 | .each = .{ .once = &.{ |
| | 18683 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18684 | .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18685 | .{ ._, .p_b, .subus, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18686 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| | 18687 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 18688 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18689 | } }, |
| | 18690 | }, .{ |
| | 18691 | .required_features = .{ .cmov, .slow_incdec, null, null }, |
| | 18692 | .src_constraints = .{ |
| | 18693 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 18694 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 18695 | .any, |
| | 18696 | }, |
| | 18697 | .patterns = &.{ |
| | 18698 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18699 | }, |
| | 18700 | .extra_temps = .{ |
| | 18701 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18702 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 18703 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 18704 | .unused, |
| | 18705 | .unused, |
| | 18706 | .unused, |
| | 18707 | .unused, |
| | 18708 | .unused, |
| | 18709 | .unused, |
| | 18710 | .unused, |
| | 18711 | .unused, |
| | 18712 | }, |
| | 18713 | .dst_temps = .{ .mem, .unused }, |
| | 18714 | .clobbers = .{ .eflags = true }, |
| | 18715 | .each = .{ .once = &.{ |
| | 18716 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18717 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| | 18718 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18719 | .{ ._, ._, .sub, .tmp2b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18720 | .{ ._, ._c, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 18721 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| | 18722 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 18723 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18724 | } }, |
| | 18725 | }, .{ |
| | 18726 | .required_features = .{ .cmov, null, null, null }, |
| | 18727 | .src_constraints = .{ |
| | 18728 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 18729 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 18730 | .any, |
| | 18731 | }, |
| | 18732 | .patterns = &.{ |
| | 18733 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18734 | }, |
| | 18735 | .extra_temps = .{ |
| | 18736 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18737 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 18738 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 18739 | .unused, |
| | 18740 | .unused, |
| | 18741 | .unused, |
| | 18742 | .unused, |
| | 18743 | .unused, |
| | 18744 | .unused, |
| | 18745 | .unused, |
| | 18746 | .unused, |
| | 18747 | }, |
| | 18748 | .dst_temps = .{ .mem, .unused }, |
| | 18749 | .clobbers = .{ .eflags = true }, |
| | 18750 | .each = .{ .once = &.{ |
| | 18751 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18752 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| | 18753 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18754 | .{ ._, ._, .sub, .tmp2b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18755 | .{ ._, ._c, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 18756 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp2b, ._, ._ }, |
| | 18757 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 18758 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 18759 | } }, |
| | 18760 | }, .{ |
| | 18761 | .required_features = .{ .slow_incdec, null, null, null }, |
| | 18762 | .src_constraints = .{ |
| | 18763 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 18764 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 18765 | .any, |
| | 18766 | }, |
| | 18767 | .patterns = &.{ |
| | 18768 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18769 | }, |
| | 18770 | .extra_temps = .{ |
| | 18771 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18772 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 18773 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 18774 | .unused, |
| | 18775 | .unused, |
| | 18776 | .unused, |
| | 18777 | .unused, |
| | 18778 | .unused, |
| | 18779 | .unused, |
| | 18780 | .unused, |
| | 18781 | .unused, |
| | 18782 | }, |
| | 18783 | .dst_temps = .{ .mem, .unused }, |
| | 18784 | .clobbers = .{ .eflags = true }, |
| | 18785 | .each = .{ .once = &.{ |
| | 18786 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18787 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18788 | .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18789 | .{ ._, ._, .cmc, ._, ._, ._, ._ }, |
| | 18790 | .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ }, |
| | 18791 | .{ ._, ._, .@"and", .tmp1b, .tmp2b, ._, ._ }, |
| | 18792 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 18793 | .{ ._, ._, .add, .tmp0p, .si(1), ._, ._ }, |
| | 18794 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18795 | } }, |
| | 18796 | }, .{ |
| | 18797 | .src_constraints = .{ |
| | 18798 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 18799 | .{ .multiple_scalar_unsigned_int = .{ .of = .byte, .is = .byte } }, |
| | 18800 | .any, |
| | 18801 | }, |
| | 18802 | .patterns = &.{ |
| | 18803 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18804 | }, |
| | 18805 | .extra_temps = .{ |
| | 18806 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18807 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 18808 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 18809 | .unused, |
| | 18810 | .unused, |
| | 18811 | .unused, |
| | 18812 | .unused, |
| | 18813 | .unused, |
| | 18814 | .unused, |
| | 18815 | .unused, |
| | 18816 | .unused, |
| | 18817 | }, |
| | 18818 | .dst_temps = .{ .mem, .unused }, |
| | 18819 | .clobbers = .{ .eflags = true }, |
| | 18820 | .each = .{ .once = &.{ |
| | 18821 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18822 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18823 | .{ ._, ._, .sub, .tmp1b, .memia(.src1b, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18824 | .{ ._, ._, .cmc, ._, ._, ._, ._ }, |
| | 18825 | .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ }, |
| | 18826 | .{ ._, ._, .@"and", .tmp1b, .tmp2b, ._, ._ }, |
| | 18827 | .{ ._, ._, .mov, .memia(.dst0b, .tmp0, .add_unaligned_size), .tmp1b, ._, ._ }, |
| | 18828 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 18829 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 18830 | } }, |
| | 18831 | }, .{ |
| | 18832 | .required_features = .{ .avx2, null, null, null }, |
| | 18833 | .src_constraints = .{ |
| | 18834 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 16 } }, |
| | 18835 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 16 } }, |
| | 18836 | .any, |
| | 18837 | }, |
| | 18838 | .patterns = &.{ |
| | 18839 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18840 | }, |
| | 18841 | .extra_temps = .{ |
| | 18842 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18843 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| | 18844 | .unused, |
| | 18845 | .unused, |
| | 18846 | .unused, |
| | 18847 | .unused, |
| | 18848 | .unused, |
| | 18849 | .unused, |
| | 18850 | .unused, |
| | 18851 | .unused, |
| | 18852 | .unused, |
| | 18853 | }, |
| | 18854 | .dst_temps = .{ .mem, .unused }, |
| | 18855 | .clobbers = .{ .eflags = true }, |
| | 18856 | .each = .{ .once = &.{ |
| | 18857 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18858 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18859 | .{ ._, .vp_w, .subs, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 18860 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| | 18861 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 18862 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18863 | } }, |
| | 18864 | }, .{ |
| | 18865 | .required_features = .{ .avx, null, null, null }, |
| | 18866 | .src_constraints = .{ |
| | 18867 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 18868 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 18869 | .any, |
| | 18870 | }, |
| | 18871 | .patterns = &.{ |
| | 18872 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18873 | }, |
| | 18874 | .extra_temps = .{ |
| | 18875 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18876 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 18877 | .unused, |
| | 18878 | .unused, |
| | 18879 | .unused, |
| | 18880 | .unused, |
| | 18881 | .unused, |
| | 18882 | .unused, |
| | 18883 | .unused, |
| | 18884 | .unused, |
| | 18885 | .unused, |
| | 18886 | }, |
| | 18887 | .dst_temps = .{ .mem, .unused }, |
| | 18888 | .clobbers = .{ .eflags = true }, |
| | 18889 | .each = .{ .once = &.{ |
| | 18890 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18891 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18892 | .{ ._, .vp_w, .subs, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 18893 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 18894 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 18895 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18896 | } }, |
| | 18897 | }, .{ |
| | 18898 | .required_features = .{ .sse2, null, null, null }, |
| | 18899 | .src_constraints = .{ |
| | 18900 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 18901 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 16 } }, |
| | 18902 | .any, |
| | 18903 | }, |
| | 18904 | .patterns = &.{ |
| | 18905 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18906 | }, |
| | 18907 | .extra_temps = .{ |
| | 18908 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18909 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 18910 | .unused, |
| | 18911 | .unused, |
| | 18912 | .unused, |
| | 18913 | .unused, |
| | 18914 | .unused, |
| | 18915 | .unused, |
| | 18916 | .unused, |
| | 18917 | .unused, |
| | 18918 | .unused, |
| | 18919 | }, |
| | 18920 | .dst_temps = .{ .mem, .unused }, |
| | 18921 | .clobbers = .{ .eflags = true }, |
| | 18922 | .each = .{ .once = &.{ |
| | 18923 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18924 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18925 | .{ ._, .p_w, .subs, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18926 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 18927 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 18928 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18929 | } }, |
| | 18930 | }, .{ |
| | 18931 | .required_features = .{ .cmov, .fast_imm16, null, null }, |
| | 18932 | .src_constraints = .{ |
| | 18933 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 18934 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 18935 | .any, |
| | 18936 | }, |
| | 18937 | .patterns = &.{ |
| | 18938 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18939 | }, |
| | 18940 | .extra_temps = .{ |
| | 18941 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18942 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 18943 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 18944 | .unused, |
| | 18945 | .unused, |
| | 18946 | .unused, |
| | 18947 | .unused, |
| | 18948 | .unused, |
| | 18949 | .unused, |
| | 18950 | .unused, |
| | 18951 | .unused, |
| | 18952 | }, |
| | 18953 | .dst_temps = .{ .mem, .unused }, |
| | 18954 | .clobbers = .{ .eflags = true }, |
| | 18955 | .each = .{ .once = &.{ |
| | 18956 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18957 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18958 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 18959 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 18960 | .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ }, |
| | 18961 | .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18962 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 18963 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 18964 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 18965 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 18966 | } }, |
| | 18967 | }, .{ |
| | 18968 | .required_features = .{ .cmov, null, null, null }, |
| | 18969 | .src_constraints = .{ |
| | 18970 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 18971 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 18972 | .any, |
| | 18973 | }, |
| | 18974 | .patterns = &.{ |
| | 18975 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 18976 | }, |
| | 18977 | .extra_temps = .{ |
| | 18978 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 18979 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 18980 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 18981 | .unused, |
| | 18982 | .unused, |
| | 18983 | .unused, |
| | 18984 | .unused, |
| | 18985 | .unused, |
| | 18986 | .unused, |
| | 18987 | .unused, |
| | 18988 | .unused, |
| | 18989 | }, |
| | 18990 | .dst_temps = .{ .mem, .unused }, |
| | 18991 | .clobbers = .{ .eflags = true }, |
| | 18992 | .each = .{ .once = &.{ |
| | 18993 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 18994 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18995 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 18996 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 18997 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 18998 | .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 18999 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 19000 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 19001 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 19002 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19003 | } }, |
| | 19004 | }, .{ |
| | 19005 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 19006 | .src_constraints = .{ |
| | 19007 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 19008 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 19009 | .any, |
| | 19010 | }, |
| | 19011 | .patterns = &.{ |
| | 19012 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19013 | }, |
| | 19014 | .extra_temps = .{ |
| | 19015 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19016 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19017 | .unused, |
| | 19018 | .unused, |
| | 19019 | .unused, |
| | 19020 | .unused, |
| | 19021 | .unused, |
| | 19022 | .unused, |
| | 19023 | .unused, |
| | 19024 | .unused, |
| | 19025 | .unused, |
| | 19026 | }, |
| | 19027 | .dst_temps = .{ .mem, .unused }, |
| | 19028 | .clobbers = .{ .eflags = true }, |
| | 19029 | .each = .{ .once = &.{ |
| | 19030 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19031 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19032 | .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19033 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 19034 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 19035 | .{ ._, ._, .xor, .tmp1w, .sa(.src0, .add_smax), ._, ._ }, |
| | 19036 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 19037 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 19038 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19039 | } }, |
| | 19040 | }, .{ |
| | 19041 | .src_constraints = .{ |
| | 19042 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 19043 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 16 } }, |
| | 19044 | .any, |
| | 19045 | }, |
| | 19046 | .patterns = &.{ |
| | 19047 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19048 | }, |
| | 19049 | .extra_temps = .{ |
| | 19050 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19051 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19052 | .unused, |
| | 19053 | .unused, |
| | 19054 | .unused, |
| | 19055 | .unused, |
| | 19056 | .unused, |
| | 19057 | .unused, |
| | 19058 | .unused, |
| | 19059 | .unused, |
| | 19060 | .unused, |
| | 19061 | }, |
| | 19062 | .dst_temps = .{ .mem, .unused }, |
| | 19063 | .clobbers = .{ .eflags = true }, |
| | 19064 | .each = .{ .once = &.{ |
| | 19065 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19066 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19067 | .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19068 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 19069 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 19070 | .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ }, |
| | 19071 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 19072 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 19073 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19074 | } }, |
| | 19075 | }, .{ |
| | 19076 | .required_features = .{ .avx2, null, null, null }, |
| | 19077 | .src_constraints = .{ |
| | 19078 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| | 19079 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .word } }, |
| | 19080 | .any, |
| | 19081 | }, |
| | 19082 | .patterns = &.{ |
| | 19083 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19084 | }, |
| | 19085 | .extra_temps = .{ |
| | 19086 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19087 | .{ .type = .i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 19088 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| | 19089 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| | 19090 | .{ .type = .vector_16_i16, .kind = .{ .rc = .sse } }, |
| | 19091 | .unused, |
| | 19092 | .unused, |
| | 19093 | .unused, |
| | 19094 | .unused, |
| | 19095 | .unused, |
| | 19096 | .unused, |
| | 19097 | }, |
| | 19098 | .dst_temps = .{ .mem, .unused }, |
| | 19099 | .clobbers = .{ .eflags = true }, |
| | 19100 | .each = .{ .once = &.{ |
| | 19101 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 19102 | .{ ._, .vp_w, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ }, |
| | 19103 | .{ ._, .vp_w, .broadcast, .tmp3y, .lea(.tmp0w), ._, ._ }, |
| | 19104 | .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ }, |
| | 19105 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19106 | .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19107 | .{ ._, .vp_w, .sub, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 19108 | .{ ._, .vp_w, .maxs, .tmp4y, .tmp4y, .tmp3y, ._ }, |
| | 19109 | .{ ._, .vp_w, .mins, .tmp4y, .tmp4y, .tmp2y, ._ }, |
| | 19110 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ }, |
| | 19111 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 19112 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19113 | } }, |
| | 19114 | }, .{ |
| | 19115 | .required_features = .{ .avx, null, null, null }, |
| | 19116 | .src_constraints = .{ |
| | 19117 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 19118 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 19119 | .any, |
| | 19120 | }, |
| | 19121 | .patterns = &.{ |
| | 19122 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19123 | }, |
| | 19124 | .extra_temps = .{ |
| | 19125 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19126 | .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 19127 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 19128 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 19129 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 19130 | .unused, |
| | 19131 | .unused, |
| | 19132 | .unused, |
| | 19133 | .unused, |
| | 19134 | .unused, |
| | 19135 | .unused, |
| | 19136 | }, |
| | 19137 | .dst_temps = .{ .mem, .unused }, |
| | 19138 | .clobbers = .{ .eflags = true }, |
| | 19139 | .each = .{ .once = &.{ |
| | 19140 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 19141 | .{ ._, .vp_w, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| | 19142 | .{ ._, .v_dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ }, |
| | 19143 | .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ }, |
| | 19144 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19145 | .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19146 | .{ ._, .vp_w, .sub, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 19147 | .{ ._, .vp_w, .maxs, .tmp4x, .tmp4x, .tmp3x, ._ }, |
| | 19148 | .{ ._, .vp_w, .mins, .tmp4x, .tmp4x, .tmp2x, ._ }, |
| | 19149 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 19150 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 19151 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19152 | } }, |
| | 19153 | }, .{ |
| | 19154 | .required_features = .{ .sse2, null, null, null }, |
| | 19155 | .src_constraints = .{ |
| | 19156 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 19157 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .word } }, |
| | 19158 | .any, |
| | 19159 | }, |
| | 19160 | .patterns = &.{ |
| | 19161 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19162 | }, |
| | 19163 | .extra_temps = .{ |
| | 19164 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19165 | .{ .type = .vector_8_i16, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 19166 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 19167 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 19168 | .{ .type = .vector_8_i16, .kind = .{ .rc = .sse } }, |
| | 19169 | .unused, |
| | 19170 | .unused, |
| | 19171 | .unused, |
| | 19172 | .unused, |
| | 19173 | .unused, |
| | 19174 | .unused, |
| | 19175 | }, |
| | 19176 | .dst_temps = .{ .mem, .unused }, |
| | 19177 | .clobbers = .{ .eflags = true }, |
| | 19178 | .each = .{ .once = &.{ |
| | 19179 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 19180 | .{ ._, .p_w, .cmpeq, .tmp2x, .tmp2x, ._, ._ }, |
| | 19181 | .{ ._, ._dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ }, |
| | 19182 | .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ }, |
| | 19183 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19184 | .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19185 | .{ ._, .p_w, .sub, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19186 | .{ ._, .p_w, .maxs, .tmp4x, .tmp3x, ._, ._ }, |
| | 19187 | .{ ._, .p_w, .mins, .tmp4x, .tmp2x, ._, ._ }, |
| | 19188 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 19189 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 19190 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19191 | } }, |
| | 19192 | }, .{ |
| | 19193 | .required_features = .{ .cmov, .fast_imm16, null, null }, |
| | 19194 | .src_constraints = .{ |
| | 19195 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 19196 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 19197 | .any, |
| | 19198 | }, |
| | 19199 | .patterns = &.{ |
| | 19200 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19201 | }, |
| | 19202 | .extra_temps = .{ |
| | 19203 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19204 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19205 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19206 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19207 | .unused, |
| | 19208 | .unused, |
| | 19209 | .unused, |
| | 19210 | .unused, |
| | 19211 | .unused, |
| | 19212 | .unused, |
| | 19213 | .unused, |
| | 19214 | }, |
| | 19215 | .dst_temps = .{ .mem, .unused }, |
| | 19216 | .clobbers = .{ .eflags = true }, |
| | 19217 | .each = .{ .once = &.{ |
| | 19218 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19219 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19220 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 19221 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 19222 | .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19223 | .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ }, |
| | 19224 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 19225 | .{ ._, ._, .add, .tmp3w, .tmp3w, ._, ._ }, |
| | 19226 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 19227 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 19228 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 19229 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19230 | } }, |
| | 19231 | }, .{ |
| | 19232 | .required_features = .{ .cmov, null, null, null }, |
| | 19233 | .src_constraints = .{ |
| | 19234 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 19235 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 19236 | .any, |
| | 19237 | }, |
| | 19238 | .patterns = &.{ |
| | 19239 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19240 | }, |
| | 19241 | .extra_temps = .{ |
| | 19242 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19243 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19244 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19245 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19246 | .unused, |
| | 19247 | .unused, |
| | 19248 | .unused, |
| | 19249 | .unused, |
| | 19250 | .unused, |
| | 19251 | .unused, |
| | 19252 | .unused, |
| | 19253 | }, |
| | 19254 | .dst_temps = .{ .mem, .unused }, |
| | 19255 | .clobbers = .{ .eflags = true }, |
| | 19256 | .each = .{ .once = &.{ |
| | 19257 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19258 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19259 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 19260 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 19261 | .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19262 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 19263 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 19264 | .{ ._, ._, .add, .tmp3w, .tmp3w, ._, ._ }, |
| | 19265 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 19266 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 19267 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 19268 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19269 | } }, |
| | 19270 | }, .{ |
| | 19271 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 19272 | .src_constraints = .{ |
| | 19273 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 19274 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 19275 | .any, |
| | 19276 | }, |
| | 19277 | .patterns = &.{ |
| | 19278 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19279 | }, |
| | 19280 | .extra_temps = .{ |
| | 19281 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19282 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19283 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19284 | .unused, |
| | 19285 | .unused, |
| | 19286 | .unused, |
| | 19287 | .unused, |
| | 19288 | .unused, |
| | 19289 | .unused, |
| | 19290 | .unused, |
| | 19291 | .unused, |
| | 19292 | }, |
| | 19293 | .dst_temps = .{ .mem, .unused }, |
| | 19294 | .clobbers = .{ .eflags = true }, |
| | 19295 | .each = .{ .once = &.{ |
| | 19296 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19297 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19298 | .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19299 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 19300 | .{ ._, ._, .add, .tmp2w, .tmp2w, ._, ._ }, |
| | 19301 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 19302 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 19303 | .{ ._, ._, .xor, .tmp1w, .sa(.src0, .add_smax), ._, ._ }, |
| | 19304 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 19305 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 19306 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19307 | } }, |
| | 19308 | }, .{ |
| | 19309 | .src_constraints = .{ |
| | 19310 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 19311 | .{ .multiple_scalar_exact_signed_int = .{ .of = .word, .is = 15 } }, |
| | 19312 | .any, |
| | 19313 | }, |
| | 19314 | .patterns = &.{ |
| | 19315 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19316 | }, |
| | 19317 | .extra_temps = .{ |
| | 19318 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19319 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19320 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19321 | .unused, |
| | 19322 | .unused, |
| | 19323 | .unused, |
| | 19324 | .unused, |
| | 19325 | .unused, |
| | 19326 | .unused, |
| | 19327 | .unused, |
| | 19328 | .unused, |
| | 19329 | }, |
| | 19330 | .dst_temps = .{ .mem, .unused }, |
| | 19331 | .clobbers = .{ .eflags = true }, |
| | 19332 | .each = .{ .once = &.{ |
| | 19333 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19334 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19335 | .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19336 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 19337 | .{ ._, ._, .add, .tmp2w, .tmp2w, ._, ._ }, |
| | 19338 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 19339 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 19340 | .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ }, |
| | 19341 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 19342 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 19343 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19344 | } }, |
| | 19345 | }, .{ |
| | 19346 | .required_features = .{ .bmi2, .cmov, .fast_imm16, null }, |
| | 19347 | .src_constraints = .{ |
| | 19348 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 19349 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 19350 | .any, |
| | 19351 | }, |
| | 19352 | .patterns = &.{ |
| | 19353 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19354 | }, |
| | 19355 | .extra_temps = .{ |
| | 19356 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19357 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19358 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19359 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19360 | .unused, |
| | 19361 | .unused, |
| | 19362 | .unused, |
| | 19363 | .unused, |
| | 19364 | .unused, |
| | 19365 | .unused, |
| | 19366 | .unused, |
| | 19367 | }, |
| | 19368 | .dst_temps = .{ .mem, .unused }, |
| | 19369 | .clobbers = .{ .eflags = true }, |
| | 19370 | .each = .{ .once = &.{ |
| | 19371 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19372 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19373 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 19374 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 19375 | .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19376 | .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ }, |
| | 19377 | .{ ._, ._rx, .ro, .tmp3d, .tmp1d, .uia(1, .src0, .add_bit_size_rem_64), ._ }, |
| | 19378 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 19379 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 19380 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 19381 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 19382 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19383 | } }, |
| | 19384 | }, .{ |
| | 19385 | .required_features = .{ .bmi2, .cmov, null, null }, |
| | 19386 | .src_constraints = .{ |
| | 19387 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 19388 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 19389 | .any, |
| | 19390 | }, |
| | 19391 | .patterns = &.{ |
| | 19392 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19393 | }, |
| | 19394 | .extra_temps = .{ |
| | 19395 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19396 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19397 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19398 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19399 | .unused, |
| | 19400 | .unused, |
| | 19401 | .unused, |
| | 19402 | .unused, |
| | 19403 | .unused, |
| | 19404 | .unused, |
| | 19405 | .unused, |
| | 19406 | }, |
| | 19407 | .dst_temps = .{ .mem, .unused }, |
| | 19408 | .clobbers = .{ .eflags = true }, |
| | 19409 | .each = .{ .once = &.{ |
| | 19410 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19411 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19412 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 19413 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 19414 | .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19415 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 19416 | .{ ._, ._rx, .ro, .tmp3d, .tmp1d, .uia(1, .src0, .add_bit_size_rem_64), ._ }, |
| | 19417 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 19418 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 19419 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 19420 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 19421 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19422 | } }, |
| | 19423 | }, .{ |
| | 19424 | .required_features = .{ .cmov, .fast_imm16, null, null }, |
| | 19425 | .src_constraints = .{ |
| | 19426 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 19427 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 19428 | .any, |
| | 19429 | }, |
| | 19430 | .patterns = &.{ |
| | 19431 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19432 | }, |
| | 19433 | .extra_temps = .{ |
| | 19434 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19435 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19436 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19437 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19438 | .unused, |
| | 19439 | .unused, |
| | 19440 | .unused, |
| | 19441 | .unused, |
| | 19442 | .unused, |
| | 19443 | .unused, |
| | 19444 | .unused, |
| | 19445 | }, |
| | 19446 | .dst_temps = .{ .mem, .unused }, |
| | 19447 | .clobbers = .{ .eflags = true }, |
| | 19448 | .each = .{ .once = &.{ |
| | 19449 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19450 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19451 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 19452 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 19453 | .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19454 | .{ ._, ._, .xor, .tmp2w, .sa(.src0, .add_smax), ._, ._ }, |
| | 19455 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 19456 | .{ ._, ._l, .sa, .tmp3d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 19457 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 19458 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 19459 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 19460 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 19461 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19462 | } }, |
| | 19463 | }, .{ |
| | 19464 | .required_features = .{ .cmov, null, null, null }, |
| | 19465 | .src_constraints = .{ |
| | 19466 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 19467 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 19468 | .any, |
| | 19469 | }, |
| | 19470 | .patterns = &.{ |
| | 19471 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19472 | }, |
| | 19473 | .extra_temps = .{ |
| | 19474 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19475 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19476 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19477 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19478 | .unused, |
| | 19479 | .unused, |
| | 19480 | .unused, |
| | 19481 | .unused, |
| | 19482 | .unused, |
| | 19483 | .unused, |
| | 19484 | .unused, |
| | 19485 | }, |
| | 19486 | .dst_temps = .{ .mem, .unused }, |
| | 19487 | .clobbers = .{ .eflags = true }, |
| | 19488 | .each = .{ .once = &.{ |
| | 19489 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19490 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19491 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 19492 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 19493 | .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19494 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 19495 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 19496 | .{ ._, ._l, .sa, .tmp3d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 19497 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 19498 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 19499 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 19500 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 19501 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19502 | } }, |
| | 19503 | }, .{ |
| | 19504 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 19505 | .src_constraints = .{ |
| | 19506 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 19507 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 19508 | .any, |
| | 19509 | }, |
| | 19510 | .patterns = &.{ |
| | 19511 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19512 | }, |
| | 19513 | .extra_temps = .{ |
| | 19514 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19515 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19516 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19517 | .unused, |
| | 19518 | .unused, |
| | 19519 | .unused, |
| | 19520 | .unused, |
| | 19521 | .unused, |
| | 19522 | .unused, |
| | 19523 | .unused, |
| | 19524 | .unused, |
| | 19525 | }, |
| | 19526 | .dst_temps = .{ .mem, .unused }, |
| | 19527 | .clobbers = .{ .eflags = true }, |
| | 19528 | .each = .{ .once = &.{ |
| | 19529 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19530 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19531 | .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19532 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 19533 | .{ ._, ._l, .sa, .tmp2d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 19534 | .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ }, |
| | 19535 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 19536 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 19537 | .{ ._, ._, .xor, .tmp1w, .sa(.src0, .add_smax), ._, ._ }, |
| | 19538 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 19539 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 19540 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19541 | } }, |
| | 19542 | }, .{ |
| | 19543 | .src_constraints = .{ |
| | 19544 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 19545 | .{ .multiple_scalar_signed_int = .{ .of = .word, .is = .word } }, |
| | 19546 | .any, |
| | 19547 | }, |
| | 19548 | .patterns = &.{ |
| | 19549 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19550 | }, |
| | 19551 | .extra_temps = .{ |
| | 19552 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19553 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19554 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| | 19555 | .unused, |
| | 19556 | .unused, |
| | 19557 | .unused, |
| | 19558 | .unused, |
| | 19559 | .unused, |
| | 19560 | .unused, |
| | 19561 | .unused, |
| | 19562 | .unused, |
| | 19563 | }, |
| | 19564 | .dst_temps = .{ .mem, .unused }, |
| | 19565 | .clobbers = .{ .eflags = true }, |
| | 19566 | .each = .{ .once = &.{ |
| | 19567 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19568 | .{ .@"0:", ._, .movsx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19569 | .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19570 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 19571 | .{ ._, ._l, .sa, .tmp2d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 19572 | .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ }, |
| | 19573 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 19574 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 19575 | .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ }, |
| | 19576 | .{ .@"1:", ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 19577 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 19578 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19579 | } }, |
| | 19580 | }, .{ |
| | 19581 | .required_features = .{ .mmx, null, null, null }, |
| | 19582 | .src_constraints = .{ |
| | 19583 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, |
| | 19584 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, |
| | 19585 | .any, |
| | 19586 | }, |
| | 19587 | .patterns = &.{ |
| | 19588 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19589 | }, |
| | 19590 | .extra_temps = .{ |
| | 19591 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19592 | .{ .type = .vector_4_i16, .kind = .{ .rc = .mmx } }, |
| | 19593 | .unused, |
| | 19594 | .unused, |
| | 19595 | .unused, |
| | 19596 | .unused, |
| | 19597 | .unused, |
| | 19598 | .unused, |
| | 19599 | .unused, |
| | 19600 | .unused, |
| | 19601 | .unused, |
| | 19602 | }, |
| | 19603 | .dst_temps = .{ .mem, .unused }, |
| | 19604 | .clobbers = .{ .eflags = true }, |
| | 19605 | .each = .{ .once = &.{ |
| | 19606 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19607 | .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19608 | .{ ._, .p_w, .subus, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19609 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| | 19610 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 19611 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19612 | } }, |
| | 19613 | }, .{ |
| | 19614 | .required_features = .{ .avx2, null, null, null }, |
| | 19615 | .src_constraints = .{ |
| | 19616 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| | 19617 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .word } }, |
| | 19618 | .any, |
| | 19619 | }, |
| | 19620 | .patterns = &.{ |
| | 19621 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19622 | }, |
| | 19623 | .extra_temps = .{ |
| | 19624 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19625 | .{ .type = .vector_16_u16, .kind = .{ .rc = .sse } }, |
| | 19626 | .unused, |
| | 19627 | .unused, |
| | 19628 | .unused, |
| | 19629 | .unused, |
| | 19630 | .unused, |
| | 19631 | .unused, |
| | 19632 | .unused, |
| | 19633 | .unused, |
| | 19634 | .unused, |
| | 19635 | }, |
| | 19636 | .dst_temps = .{ .mem, .unused }, |
| | 19637 | .clobbers = .{ .eflags = true }, |
| | 19638 | .each = .{ .once = &.{ |
| | 19639 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19640 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19641 | .{ ._, .vp_w, .subus, .tmp1y, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 19642 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| | 19643 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 19644 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19645 | } }, |
| | 19646 | }, .{ |
| | 19647 | .required_features = .{ .avx, null, null, null }, |
| | 19648 | .src_constraints = .{ |
| | 19649 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 19650 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 19651 | .any, |
| | 19652 | }, |
| | 19653 | .patterns = &.{ |
| | 19654 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19655 | }, |
| | 19656 | .extra_temps = .{ |
| | 19657 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19658 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 19659 | .unused, |
| | 19660 | .unused, |
| | 19661 | .unused, |
| | 19662 | .unused, |
| | 19663 | .unused, |
| | 19664 | .unused, |
| | 19665 | .unused, |
| | 19666 | .unused, |
| | 19667 | .unused, |
| | 19668 | }, |
| | 19669 | .dst_temps = .{ .mem, .unused }, |
| | 19670 | .clobbers = .{ .eflags = true }, |
| | 19671 | .each = .{ .once = &.{ |
| | 19672 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19673 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19674 | .{ ._, .vp_w, .subus, .tmp1x, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 19675 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 19676 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 19677 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19678 | } }, |
| | 19679 | }, .{ |
| | 19680 | .required_features = .{ .sse2, null, null, null }, |
| | 19681 | .src_constraints = .{ |
| | 19682 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 19683 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .word } }, |
| | 19684 | .any, |
| | 19685 | }, |
| | 19686 | .patterns = &.{ |
| | 19687 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19688 | }, |
| | 19689 | .extra_temps = .{ |
| | 19690 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19691 | .{ .type = .vector_8_u16, .kind = .{ .rc = .sse } }, |
| | 19692 | .unused, |
| | 19693 | .unused, |
| | 19694 | .unused, |
| | 19695 | .unused, |
| | 19696 | .unused, |
| | 19697 | .unused, |
| | 19698 | .unused, |
| | 19699 | .unused, |
| | 19700 | .unused, |
| | 19701 | }, |
| | 19702 | .dst_temps = .{ .mem, .unused }, |
| | 19703 | .clobbers = .{ .eflags = true }, |
| | 19704 | .each = .{ .once = &.{ |
| | 19705 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19706 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19707 | .{ ._, .p_w, .subus, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19708 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 19709 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 19710 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19711 | } }, |
| | 19712 | }, .{ |
| | 19713 | .required_features = .{ .mmx, null, null, null }, |
| | 19714 | .src_constraints = .{ |
| | 19715 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, |
| | 19716 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .word } }, |
| | 19717 | .any, |
| | 19718 | }, |
| | 19719 | .patterns = &.{ |
| | 19720 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19721 | }, |
| | 19722 | .extra_temps = .{ |
| | 19723 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19724 | .{ .type = .vector_4_u16, .kind = .{ .rc = .mmx } }, |
| | 19725 | .unused, |
| | 19726 | .unused, |
| | 19727 | .unused, |
| | 19728 | .unused, |
| | 19729 | .unused, |
| | 19730 | .unused, |
| | 19731 | .unused, |
| | 19732 | .unused, |
| | 19733 | .unused, |
| | 19734 | }, |
| | 19735 | .dst_temps = .{ .mem, .unused }, |
| | 19736 | .clobbers = .{ .eflags = true }, |
| | 19737 | .each = .{ .once = &.{ |
| | 19738 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19739 | .{ .@"0:", ._q, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19740 | .{ ._, .p_w, .subus, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19741 | .{ ._, ._q, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| | 19742 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 19743 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19744 | } }, |
| | 19745 | }, .{ |
| | 19746 | .required_features = .{ .cmov, null, null, null }, |
| | 19747 | .src_constraints = .{ |
| | 19748 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| | 19749 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| | 19750 | .any, |
| | 19751 | }, |
| | 19752 | .patterns = &.{ |
| | 19753 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19754 | }, |
| | 19755 | .extra_temps = .{ |
| | 19756 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19757 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 19758 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 19759 | .unused, |
| | 19760 | .unused, |
| | 19761 | .unused, |
| | 19762 | .unused, |
| | 19763 | .unused, |
| | 19764 | .unused, |
| | 19765 | .unused, |
| | 19766 | .unused, |
| | 19767 | }, |
| | 19768 | .dst_temps = .{ .mem, .unused }, |
| | 19769 | .clobbers = .{ .eflags = true }, |
| | 19770 | .each = .{ .once = &.{ |
| | 19771 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19772 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| | 19773 | .{ .@"0:", ._, .movzx, .tmp2d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19774 | .{ ._, ._, .sub, .tmp2w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19775 | .{ ._, ._c, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 19776 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp2w, ._, ._ }, |
| | 19777 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 19778 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19779 | } }, |
| | 19780 | }, .{ |
| | 19781 | .src_constraints = .{ |
| | 19782 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| | 19783 | .{ .multiple_scalar_unsigned_int = .{ .of = .word, .is = .word } }, |
| | 19784 | .any, |
| | 19785 | }, |
| | 19786 | .patterns = &.{ |
| | 19787 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19788 | }, |
| | 19789 | .extra_temps = .{ |
| | 19790 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19791 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 19792 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| | 19793 | .unused, |
| | 19794 | .unused, |
| | 19795 | .unused, |
| | 19796 | .unused, |
| | 19797 | .unused, |
| | 19798 | .unused, |
| | 19799 | .unused, |
| | 19800 | .unused, |
| | 19801 | }, |
| | 19802 | .dst_temps = .{ .mem, .unused }, |
| | 19803 | .clobbers = .{ .eflags = true }, |
| | 19804 | .each = .{ .once = &.{ |
| | 19805 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19806 | .{ .@"0:", ._, .movzx, .tmp1d, .memia(.src0w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19807 | .{ ._, ._, .sub, .tmp1w, .memia(.src1w, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19808 | .{ ._, ._, .cmc, ._, ._, ._, ._ }, |
| | 19809 | .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ }, |
| | 19810 | .{ ._, ._, .@"and", .tmp1d, .tmp2d, ._, ._ }, |
| | 19811 | .{ ._, ._, .mov, .memia(.dst0w, .tmp0, .add_unaligned_size), .tmp1w, ._, ._ }, |
| | 19812 | .{ ._, ._, .add, .tmp0p, .si(2), ._, ._ }, |
| | 19813 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19814 | } }, |
| | 19815 | }, .{ |
| | 19816 | .required_features = .{ .avx2, null, null, null }, |
| | 19817 | .src_constraints = .{ |
| | 19818 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 32 } }, |
| | 19819 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 32 } }, |
| | 19820 | .any, |
| | 19821 | }, |
| | 19822 | .patterns = &.{ |
| | 19823 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19824 | }, |
| | 19825 | .extra_temps = .{ |
| | 19826 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19827 | .{ .type = .i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 19828 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 19829 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 19830 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 19831 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 19832 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 19833 | .unused, |
| | 19834 | .unused, |
| | 19835 | .unused, |
| | 19836 | .unused, |
| | 19837 | }, |
| | 19838 | .dst_temps = .{ .mem, .unused }, |
| | 19839 | .clobbers = .{ .eflags = true }, |
| | 19840 | .each = .{ .once = &.{ |
| | 19841 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 19842 | .{ ._, .vp_d, .broadcast, .tmp2y, .lea(.tmp0d), ._, ._ }, |
| | 19843 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19844 | .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19845 | .{ ._, .v_dqa, .mov, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19846 | .{ ._, .vp_d, .sub, .tmp5y, .tmp3y, .tmp4y, ._ }, |
| | 19847 | .{ ._, .vp_d, .sra, .tmp6y, .tmp3y, .ui(31), ._ }, |
| | 19848 | .{ ._, .vp_d, .cmpgt, .tmp3y, .tmp5y, .tmp3y, ._ }, |
| | 19849 | .{ ._, .vp_, .xor, .tmp6y, .tmp6y, .tmp2y, ._ }, |
| | 19850 | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp4y, ._ }, |
| | 19851 | .{ ._, .v_ps, .blendv, .tmp3y, .tmp5y, .tmp6y, .tmp3y }, |
| | 19852 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, |
| | 19853 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 19854 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19855 | } }, |
| | 19856 | }, .{ |
| | 19857 | .required_features = .{ .avx, null, null, null }, |
| | 19858 | .src_constraints = .{ |
| | 19859 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 19860 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 19861 | .any, |
| | 19862 | }, |
| | 19863 | .patterns = &.{ |
| | 19864 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19865 | }, |
| | 19866 | .extra_temps = .{ |
| | 19867 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19868 | .{ .type = .i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 19869 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 19870 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 19871 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 19872 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 19873 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 19874 | .unused, |
| | 19875 | .unused, |
| | 19876 | .unused, |
| | 19877 | .unused, |
| | 19878 | }, |
| | 19879 | .dst_temps = .{ .mem, .unused }, |
| | 19880 | .clobbers = .{ .eflags = true }, |
| | 19881 | .each = .{ .once = &.{ |
| | 19882 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 19883 | .{ ._, .v_ss, .broadcast, .tmp2x, .lea(.tmp0d), ._, ._ }, |
| | 19884 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19885 | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19886 | .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19887 | .{ ._, .vp_d, .sub, .tmp5x, .tmp3x, .tmp4x, ._ }, |
| | 19888 | .{ ._, .vp_d, .sra, .tmp6x, .tmp3x, .ui(31), ._ }, |
| | 19889 | .{ ._, .vp_d, .cmpgt, .tmp3x, .tmp5x, .tmp3x, ._ }, |
| | 19890 | .{ ._, .vp_, .xor, .tmp6x, .tmp6x, .tmp2x, ._ }, |
| | 19891 | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp4x, ._ }, |
| | 19892 | .{ ._, .v_ps, .blendv, .tmp3x, .tmp5x, .tmp6x, .tmp3x }, |
| | 19893 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 19894 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 19895 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19896 | } }, |
| | 19897 | }, .{ |
| | 19898 | .required_features = .{ .sse4_1, null, null, null }, |
| | 19899 | .src_constraints = .{ |
| | 19900 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 19901 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 32 } }, |
| | 19902 | .any, |
| | 19903 | }, |
| | 19904 | .patterns = &.{ |
| | 19905 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19906 | }, |
| | 19907 | .extra_temps = .{ |
| | 19908 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19909 | .{ .type = .i32, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 19910 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 19911 | .{ .type = .vector_4_i32, .kind = .{ .reg = .xmm0 } }, |
| | 19912 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 19913 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 19914 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 19915 | .unused, |
| | 19916 | .unused, |
| | 19917 | .unused, |
| | 19918 | .unused, |
| | 19919 | }, |
| | 19920 | .dst_temps = .{ .mem, .unused }, |
| | 19921 | .clobbers = .{ .eflags = true }, |
| | 19922 | .each = .{ .once = &.{ |
| | 19923 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 19924 | .{ ._, ._dqa, .mov, .tmp2x, .lea(.tmp0x), ._, ._ }, |
| | 19925 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19926 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19927 | .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19928 | .{ ._, ._dqa, .mov, .tmp5x, .tmp3x, ._, ._ }, |
| | 19929 | .{ ._, .p_d, .sub, .tmp5x, .tmp4x, ._, ._ }, |
| | 19930 | .{ ._, ._dqa, .mov, .tmp6x, .tmp3x, ._, ._ }, |
| | 19931 | .{ ._, .p_d, .sra, .tmp6x, .ui(31), ._, ._ }, |
| | 19932 | .{ ._, .p_d, .cmpgt, .tmp3x, .tmp5x, ._, ._ }, |
| | 19933 | .{ ._, .p_, .xor, .tmp6x, .tmp2x, ._, ._ }, |
| | 19934 | .{ ._, .p_, .xor, .tmp3x, .tmp4x, ._, ._ }, |
| | 19935 | .{ ._, ._ps, .blendv, .tmp6x, .tmp5x, .tmp3x, ._ }, |
| | 19936 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp6x, ._, ._ }, |
| | 19937 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 19938 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19939 | } }, |
| | 19940 | }, .{ |
| | 19941 | .required_features = .{ .cmov, null, null, null }, |
| | 19942 | .src_constraints = .{ |
| | 19943 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } }, |
| | 19944 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } }, |
| | 19945 | .any, |
| | 19946 | }, |
| | 19947 | .patterns = &.{ |
| | 19948 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19949 | }, |
| | 19950 | .extra_temps = .{ |
| | 19951 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19952 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 19953 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 19954 | .unused, |
| | 19955 | .unused, |
| | 19956 | .unused, |
| | 19957 | .unused, |
| | 19958 | .unused, |
| | 19959 | .unused, |
| | 19960 | .unused, |
| | 19961 | .unused, |
| | 19962 | }, |
| | 19963 | .dst_temps = .{ .mem, .unused }, |
| | 19964 | .clobbers = .{ .eflags = true }, |
| | 19965 | .each = .{ .once = &.{ |
| | 19966 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 19967 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19968 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 19969 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 19970 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 19971 | .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 19972 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 19973 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 19974 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 19975 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 19976 | } }, |
| | 19977 | }, .{ |
| | 19978 | .src_constraints = .{ |
| | 19979 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } }, |
| | 19980 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 32 } }, |
| | 19981 | .any, |
| | 19982 | }, |
| | 19983 | .patterns = &.{ |
| | 19984 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 19985 | }, |
| | 19986 | .extra_temps = .{ |
| | 19987 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 19988 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 19989 | .unused, |
| | 19990 | .unused, |
| | 19991 | .unused, |
| | 19992 | .unused, |
| | 19993 | .unused, |
| | 19994 | .unused, |
| | 19995 | .unused, |
| | 19996 | .unused, |
| | 19997 | .unused, |
| | 19998 | }, |
| | 19999 | .dst_temps = .{ .mem, .unused }, |
| | 20000 | .clobbers = .{ .eflags = true }, |
| | 20001 | .each = .{ .once = &.{ |
| | 20002 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20003 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20004 | .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20005 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 20006 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 20007 | .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smin), ._, ._ }, |
| | 20008 | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 20009 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 20010 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20011 | } }, |
| | 20012 | }, .{ |
| | 20013 | .required_features = .{ .avx2, null, null, null }, |
| | 20014 | .src_constraints = .{ |
| | 20015 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| | 20016 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .dword } }, |
| | 20017 | .any, |
| | 20018 | }, |
| | 20019 | .patterns = &.{ |
| | 20020 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20021 | }, |
| | 20022 | .extra_temps = .{ |
| | 20023 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20024 | .{ .type = .i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 20025 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 20026 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 20027 | .{ .type = .vector_8_i32, .kind = .{ .rc = .sse } }, |
| | 20028 | .unused, |
| | 20029 | .unused, |
| | 20030 | .unused, |
| | 20031 | .unused, |
| | 20032 | .unused, |
| | 20033 | .unused, |
| | 20034 | }, |
| | 20035 | .dst_temps = .{ .mem, .unused }, |
| | 20036 | .clobbers = .{ .eflags = true }, |
| | 20037 | .each = .{ .once = &.{ |
| | 20038 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 20039 | .{ ._, .vp_d, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ }, |
| | 20040 | .{ ._, .vp_d, .broadcast, .tmp3y, .lea(.tmp0d), ._, ._ }, |
| | 20041 | .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ }, |
| | 20042 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20043 | .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20044 | .{ ._, .vp_d, .sub, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 20045 | .{ ._, .vp_d, .maxs, .tmp4y, .tmp4y, .tmp3y, ._ }, |
| | 20046 | .{ ._, .vp_d, .mins, .tmp4y, .tmp4y, .tmp2y, ._ }, |
| | 20047 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ }, |
| | 20048 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 20049 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20050 | } }, |
| | 20051 | }, .{ |
| | 20052 | .required_features = .{ .avx, null, null, null }, |
| | 20053 | .src_constraints = .{ |
| | 20054 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 20055 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 20056 | .any, |
| | 20057 | }, |
| | 20058 | .patterns = &.{ |
| | 20059 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20060 | }, |
| | 20061 | .extra_temps = .{ |
| | 20062 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20063 | .{ .type = .i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 20064 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 20065 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 20066 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 20067 | .unused, |
| | 20068 | .unused, |
| | 20069 | .unused, |
| | 20070 | .unused, |
| | 20071 | .unused, |
| | 20072 | .unused, |
| | 20073 | }, |
| | 20074 | .dst_temps = .{ .mem, .unused }, |
| | 20075 | .clobbers = .{ .eflags = true }, |
| | 20076 | .each = .{ .once = &.{ |
| | 20077 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 20078 | .{ ._, .vp_d, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| | 20079 | .{ ._, .v_ss, .broadcast, .tmp3x, .lea(.tmp0d), ._, ._ }, |
| | 20080 | .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ }, |
| | 20081 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20082 | .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20083 | .{ ._, .vp_d, .sub, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 20084 | .{ ._, .vp_d, .maxs, .tmp4x, .tmp4x, .tmp3x, ._ }, |
| | 20085 | .{ ._, .vp_d, .mins, .tmp4x, .tmp4x, .tmp2x, ._ }, |
| | 20086 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 20087 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 20088 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20089 | } }, |
| | 20090 | }, .{ |
| | 20091 | .required_features = .{ .sse4_1, null, null, null }, |
| | 20092 | .src_constraints = .{ |
| | 20093 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 20094 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .dword } }, |
| | 20095 | .any, |
| | 20096 | }, |
| | 20097 | .patterns = &.{ |
| | 20098 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20099 | }, |
| | 20100 | .extra_temps = .{ |
| | 20101 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20102 | .{ .type = .vector_4_i32, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .xword } } }, |
| | 20103 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 20104 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 20105 | .{ .type = .vector_4_i32, .kind = .{ .rc = .sse } }, |
| | 20106 | .unused, |
| | 20107 | .unused, |
| | 20108 | .unused, |
| | 20109 | .unused, |
| | 20110 | .unused, |
| | 20111 | .unused, |
| | 20112 | }, |
| | 20113 | .dst_temps = .{ .mem, .unused }, |
| | 20114 | .clobbers = .{ .eflags = true }, |
| | 20115 | .each = .{ .once = &.{ |
| | 20116 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 20117 | .{ ._, .p_d, .cmpeq, .tmp2x, .tmp2x, ._, ._ }, |
| | 20118 | .{ ._, ._dqa, .mov, .tmp3x, .lea(.tmp0x), ._, ._ }, |
| | 20119 | .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ }, |
| | 20120 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20121 | .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20122 | .{ ._, .p_d, .sub, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20123 | .{ ._, .p_d, .maxs, .tmp4x, .tmp3x, ._, ._ }, |
| | 20124 | .{ ._, .p_d, .mins, .tmp4x, .tmp2x, ._, ._ }, |
| | 20125 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 20126 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 20127 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20128 | } }, |
| | 20129 | }, .{ |
| | 20130 | .required_features = .{ .cmov, null, null, null }, |
| | 20131 | .src_constraints = .{ |
| | 20132 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } }, |
| | 20133 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } }, |
| | 20134 | .any, |
| | 20135 | }, |
| | 20136 | .patterns = &.{ |
| | 20137 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20138 | }, |
| | 20139 | .extra_temps = .{ |
| | 20140 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20141 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 20142 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 20143 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 20144 | .unused, |
| | 20145 | .unused, |
| | 20146 | .unused, |
| | 20147 | .unused, |
| | 20148 | .unused, |
| | 20149 | .unused, |
| | 20150 | .unused, |
| | 20151 | }, |
| | 20152 | .dst_temps = .{ .mem, .unused }, |
| | 20153 | .clobbers = .{ .eflags = true }, |
| | 20154 | .each = .{ .once = &.{ |
| | 20155 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20156 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20157 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 20158 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 20159 | .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20160 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 20161 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 20162 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 20163 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 20164 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 20165 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 20166 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20167 | } }, |
| | 20168 | }, .{ |
| | 20169 | .src_constraints = .{ |
| | 20170 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } }, |
| | 20171 | .{ .multiple_scalar_exact_signed_int = .{ .of = .dword, .is = 31 } }, |
| | 20172 | .any, |
| | 20173 | }, |
| | 20174 | .patterns = &.{ |
| | 20175 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20176 | }, |
| | 20177 | .extra_temps = .{ |
| | 20178 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20179 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 20180 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 20181 | .unused, |
| | 20182 | .unused, |
| | 20183 | .unused, |
| | 20184 | .unused, |
| | 20185 | .unused, |
| | 20186 | .unused, |
| | 20187 | .unused, |
| | 20188 | .unused, |
| | 20189 | }, |
| | 20190 | .dst_temps = .{ .mem, .unused }, |
| | 20191 | .clobbers = .{ .eflags = true }, |
| | 20192 | .each = .{ .once = &.{ |
| | 20193 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20194 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20195 | .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20196 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 20197 | .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ }, |
| | 20198 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 20199 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 20200 | .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ }, |
| | 20201 | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 20202 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 20203 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20204 | } }, |
| | 20205 | }, .{ |
| | 20206 | .required_features = .{ .bmi2, .cmov, null, null }, |
| | 20207 | .src_constraints = .{ |
| | 20208 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| | 20209 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| | 20210 | .any, |
| | 20211 | }, |
| | 20212 | .patterns = &.{ |
| | 20213 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20214 | }, |
| | 20215 | .extra_temps = .{ |
| | 20216 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20217 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 20218 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 20219 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 20220 | .unused, |
| | 20221 | .unused, |
| | 20222 | .unused, |
| | 20223 | .unused, |
| | 20224 | .unused, |
| | 20225 | .unused, |
| | 20226 | .unused, |
| | 20227 | }, |
| | 20228 | .dst_temps = .{ .mem, .unused }, |
| | 20229 | .clobbers = .{ .eflags = true }, |
| | 20230 | .each = .{ .once = &.{ |
| | 20231 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20232 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20233 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 20234 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 20235 | .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20236 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 20237 | .{ ._, ._rx, .ro, .tmp3d, .tmp1d, .uia(1, .src0, .add_bit_size_rem_64), ._ }, |
| | 20238 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 20239 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 20240 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 20241 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 20242 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20243 | } }, |
| | 20244 | }, .{ |
| | 20245 | .required_features = .{ .cmov, null, null, null }, |
| | 20246 | .src_constraints = .{ |
| | 20247 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| | 20248 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| | 20249 | .any, |
| | 20250 | }, |
| | 20251 | .patterns = &.{ |
| | 20252 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20253 | }, |
| | 20254 | .extra_temps = .{ |
| | 20255 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20256 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 20257 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 20258 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 20259 | .unused, |
| | 20260 | .unused, |
| | 20261 | .unused, |
| | 20262 | .unused, |
| | 20263 | .unused, |
| | 20264 | .unused, |
| | 20265 | .unused, |
| | 20266 | }, |
| | 20267 | .dst_temps = .{ .mem, .unused }, |
| | 20268 | .clobbers = .{ .eflags = true }, |
| | 20269 | .each = .{ .once = &.{ |
| | 20270 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20271 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20272 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 20273 | .{ ._, ._r, .sa, .tmp2d, .ui(31), ._, ._ }, |
| | 20274 | .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20275 | .{ ._, ._, .xor, .tmp2d, .sa(.src0, .add_smax), ._, ._ }, |
| | 20276 | .{ ._, ._, .mov, .tmp3d, .tmp1d, ._, ._ }, |
| | 20277 | .{ ._, ._l, .sa, .tmp3d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 20278 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 20279 | .{ ._, ._o, .cmov, .tmp1d, .tmp2d, ._, ._ }, |
| | 20280 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 20281 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 20282 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20283 | } }, |
| | 20284 | }, .{ |
| | 20285 | .src_constraints = .{ |
| | 20286 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| | 20287 | .{ .multiple_scalar_signed_int = .{ .of = .dword, .is = .dword } }, |
| | 20288 | .any, |
| | 20289 | }, |
| | 20290 | .patterns = &.{ |
| | 20291 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20292 | }, |
| | 20293 | .extra_temps = .{ |
| | 20294 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20295 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 20296 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| | 20297 | .unused, |
| | 20298 | .unused, |
| | 20299 | .unused, |
| | 20300 | .unused, |
| | 20301 | .unused, |
| | 20302 | .unused, |
| | 20303 | .unused, |
| | 20304 | .unused, |
| | 20305 | }, |
| | 20306 | .dst_temps = .{ .mem, .unused }, |
| | 20307 | .clobbers = .{ .eflags = true }, |
| | 20308 | .each = .{ .once = &.{ |
| | 20309 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20310 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20311 | .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20312 | .{ ._, ._, .mov, .tmp2d, .tmp1d, ._, ._ }, |
| | 20313 | .{ ._, ._l, .sa, .tmp2d, .uia(31, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 20314 | .{ ._, ._, .add, .tmp2d, .tmp2d, ._, ._ }, |
| | 20315 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 20316 | .{ ._, ._r, .sa, .tmp1d, .ui(31), ._, ._ }, |
| | 20317 | .{ ._, ._, .xor, .tmp1d, .sa(.src0, .add_smax), ._, ._ }, |
| | 20318 | .{ .@"1:", ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 20319 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 20320 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20321 | } }, |
| | 20322 | }, .{ |
| | 20323 | .required_features = .{ .avx2, null, null, null }, |
| | 20324 | .src_constraints = .{ |
| | 20325 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| | 20326 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .dword } }, |
| | 20327 | .any, |
| | 20328 | }, |
| | 20329 | .patterns = &.{ |
| | 20330 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20331 | }, |
| | 20332 | .extra_temps = .{ |
| | 20333 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20334 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| | 20335 | .{ .type = .vector_8_u32, .kind = .{ .rc = .sse } }, |
| | 20336 | .unused, |
| | 20337 | .unused, |
| | 20338 | .unused, |
| | 20339 | .unused, |
| | 20340 | .unused, |
| | 20341 | .unused, |
| | 20342 | .unused, |
| | 20343 | .unused, |
| | 20344 | }, |
| | 20345 | .dst_temps = .{ .mem, .unused }, |
| | 20346 | .clobbers = .{ .eflags = true }, |
| | 20347 | .each = .{ .once = &.{ |
| | 20348 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20349 | .{ .@"0:", .v_dqa, .mov, .tmp1y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20350 | .{ ._, .vp_d, .maxu, .tmp2y, .tmp1y, .memia(.src0y, .tmp0, .add_unaligned_size), ._ }, |
| | 20351 | .{ ._, .vp_d, .sub, .tmp1y, .tmp2y, .tmp1y, ._ }, |
| | 20352 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp1y, ._, ._ }, |
| | 20353 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 20354 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20355 | } }, |
| | 20356 | }, .{ |
| | 20357 | .required_features = .{ .avx, null, null, null }, |
| | 20358 | .src_constraints = .{ |
| | 20359 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 20360 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 20361 | .any, |
| | 20362 | }, |
| | 20363 | .patterns = &.{ |
| | 20364 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20365 | }, |
| | 20366 | .extra_temps = .{ |
| | 20367 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20368 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 20369 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 20370 | .unused, |
| | 20371 | .unused, |
| | 20372 | .unused, |
| | 20373 | .unused, |
| | 20374 | .unused, |
| | 20375 | .unused, |
| | 20376 | .unused, |
| | 20377 | .unused, |
| | 20378 | }, |
| | 20379 | .dst_temps = .{ .mem, .unused }, |
| | 20380 | .clobbers = .{ .eflags = true }, |
| | 20381 | .each = .{ .once = &.{ |
| | 20382 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20383 | .{ .@"0:", .v_dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20384 | .{ ._, .vp_d, .maxu, .tmp2x, .tmp1x, .memia(.src0x, .tmp0, .add_unaligned_size), ._ }, |
| | 20385 | .{ ._, .vp_d, .sub, .tmp1x, .tmp2x, .tmp1x, ._ }, |
| | 20386 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp1x, ._, ._ }, |
| | 20387 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 20388 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20389 | } }, |
| | 20390 | }, .{ |
| | 20391 | .required_features = .{ .sse4_1, null, null, null }, |
| | 20392 | .src_constraints = .{ |
| | 20393 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 20394 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .dword } }, |
| | 20395 | .any, |
| | 20396 | }, |
| | 20397 | .patterns = &.{ |
| | 20398 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20399 | }, |
| | 20400 | .extra_temps = .{ |
| | 20401 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20402 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 20403 | .{ .type = .vector_4_u32, .kind = .{ .rc = .sse } }, |
| | 20404 | .unused, |
| | 20405 | .unused, |
| | 20406 | .unused, |
| | 20407 | .unused, |
| | 20408 | .unused, |
| | 20409 | .unused, |
| | 20410 | .unused, |
| | 20411 | .unused, |
| | 20412 | }, |
| | 20413 | .dst_temps = .{ .mem, .unused }, |
| | 20414 | .clobbers = .{ .eflags = true }, |
| | 20415 | .each = .{ .once = &.{ |
| | 20416 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20417 | .{ .@"0:", ._dqa, .mov, .tmp1x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20418 | .{ ._, ._dqa, .mov, .tmp2x, .tmp1x, ._, ._ }, |
| | 20419 | .{ ._, .p_d, .maxu, .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20420 | .{ ._, .p_d, .sub, .tmp2x, .tmp1x, ._, ._ }, |
| | 20421 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| | 20422 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 20423 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20424 | } }, |
| | 20425 | }, .{ |
| | 20426 | .required_features = .{ .cmov, null, null, null }, |
| | 20427 | .src_constraints = .{ |
| | 20428 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| | 20429 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| | 20430 | .any, |
| | 20431 | }, |
| | 20432 | .patterns = &.{ |
| | 20433 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20434 | }, |
| | 20435 | .extra_temps = .{ |
| | 20436 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20437 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 20438 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 20439 | .unused, |
| | 20440 | .unused, |
| | 20441 | .unused, |
| | 20442 | .unused, |
| | 20443 | .unused, |
| | 20444 | .unused, |
| | 20445 | .unused, |
| | 20446 | .unused, |
| | 20447 | }, |
| | 20448 | .dst_temps = .{ .mem, .unused }, |
| | 20449 | .clobbers = .{ .eflags = true }, |
| | 20450 | .each = .{ .once = &.{ |
| | 20451 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20452 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| | 20453 | .{ .@"0:", ._, .mov, .tmp2d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20454 | .{ ._, ._, .sub, .tmp2d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20455 | .{ ._, ._c, .cmov, .tmp2d, .tmp1d, ._, ._ }, |
| | 20456 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp2d, ._, ._ }, |
| | 20457 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 20458 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20459 | } }, |
| | 20460 | }, .{ |
| | 20461 | .src_constraints = .{ |
| | 20462 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| | 20463 | .{ .multiple_scalar_unsigned_int = .{ .of = .dword, .is = .dword } }, |
| | 20464 | .any, |
| | 20465 | }, |
| | 20466 | .patterns = &.{ |
| | 20467 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20468 | }, |
| | 20469 | .extra_temps = .{ |
| | 20470 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20471 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 20472 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| | 20473 | .unused, |
| | 20474 | .unused, |
| | 20475 | .unused, |
| | 20476 | .unused, |
| | 20477 | .unused, |
| | 20478 | .unused, |
| | 20479 | .unused, |
| | 20480 | .unused, |
| | 20481 | }, |
| | 20482 | .dst_temps = .{ .mem, .unused }, |
| | 20483 | .clobbers = .{ .eflags = true }, |
| | 20484 | .each = .{ .once = &.{ |
| | 20485 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20486 | .{ .@"0:", ._, .mov, .tmp1d, .memia(.src0d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20487 | .{ ._, ._, .sub, .tmp1d, .memia(.src1d, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20488 | .{ ._, ._, .cmc, ._, ._, ._, ._ }, |
| | 20489 | .{ ._, ._, .sbb, .tmp2d, .tmp2d, ._, ._ }, |
| | 20490 | .{ ._, ._, .@"and", .tmp1d, .tmp2d, ._, ._ }, |
| | 20491 | .{ ._, ._, .mov, .memia(.dst0d, .tmp0, .add_unaligned_size), .tmp1d, ._, ._ }, |
| | 20492 | .{ ._, ._, .add, .tmp0p, .si(4), ._, ._ }, |
| | 20493 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20494 | } }, |
| | 20495 | }, .{ |
| | 20496 | .required_features = .{ .avx2, null, null, null }, |
| | 20497 | .src_constraints = .{ |
| | 20498 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 64 } }, |
| | 20499 | .{ .multiple_scalar_exact_signed_int = .{ .of = .yword, .is = 64 } }, |
| | 20500 | .any, |
| | 20501 | }, |
| | 20502 | .patterns = &.{ |
| | 20503 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20504 | }, |
| | 20505 | .extra_temps = .{ |
| | 20506 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20507 | .{ .type = .i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 20508 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 20509 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 20510 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 20511 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 20512 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 20513 | .unused, |
| | 20514 | .unused, |
| | 20515 | .unused, |
| | 20516 | .unused, |
| | 20517 | }, |
| | 20518 | .dst_temps = .{ .mem, .unused }, |
| | 20519 | .clobbers = .{ .eflags = true }, |
| | 20520 | .each = .{ .once = &.{ |
| | 20521 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 20522 | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, |
| | 20523 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20524 | .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20525 | .{ ._, .v_dqa, .mov, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20526 | .{ ._, .vp_, .xor, .tmp5y, .tmp5y, .tmp5y, ._ }, |
| | 20527 | .{ ._, .vp_q, .sub, .tmp6y, .tmp3y, .tmp4y, ._ }, |
| | 20528 | .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp5y, .tmp3y, ._ }, |
| | 20529 | .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp6y, .tmp3y, ._ }, |
| | 20530 | .{ ._, .vp_, .xor, .tmp5y, .tmp5y, .tmp2y, ._ }, |
| | 20531 | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp4y, ._ }, |
| | 20532 | .{ ._, .v_pd, .blendv, .tmp5y, .tmp6y, .tmp5y, .tmp3y }, |
| | 20533 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp5y, ._, ._ }, |
| | 20534 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 20535 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20536 | } }, |
| | 20537 | }, .{ |
| | 20538 | .required_features = .{ .avx, null, null, null }, |
| | 20539 | .src_constraints = .{ |
| | 20540 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 20541 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 20542 | .any, |
| | 20543 | }, |
| | 20544 | .patterns = &.{ |
| | 20545 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20546 | }, |
| | 20547 | .extra_temps = .{ |
| | 20548 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20549 | .{ .type = .i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 20550 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20551 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20552 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20553 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20554 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20555 | .unused, |
| | 20556 | .unused, |
| | 20557 | .unused, |
| | 20558 | .unused, |
| | 20559 | }, |
| | 20560 | .dst_temps = .{ .mem, .unused }, |
| | 20561 | .clobbers = .{ .eflags = true }, |
| | 20562 | .each = .{ .once = &.{ |
| | 20563 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 20564 | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 20565 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20566 | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20567 | .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20568 | .{ ._, .vp_, .xor, .tmp5x, .tmp5x, .tmp5x, ._ }, |
| | 20569 | .{ ._, .vp_q, .sub, .tmp6x, .tmp3x, .tmp4x, ._ }, |
| | 20570 | .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp5x, .tmp3x, ._ }, |
| | 20571 | .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp6x, .tmp3x, ._ }, |
| | 20572 | .{ ._, .vp_, .xor, .tmp5x, .tmp5x, .tmp2x, ._ }, |
| | 20573 | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp4x, ._ }, |
| | 20574 | .{ ._, .v_pd, .blendv, .tmp5x, .tmp6x, .tmp5x, .tmp3x }, |
| | 20575 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp5x, ._, ._ }, |
| | 20576 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 20577 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20578 | } }, |
| | 20579 | }, .{ |
| | 20580 | .required_features = .{ .sse4_2, null, null, null }, |
| | 20581 | .src_constraints = .{ |
| | 20582 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 20583 | .{ .multiple_scalar_exact_signed_int = .{ .of = .xword, .is = 64 } }, |
| | 20584 | .any, |
| | 20585 | }, |
| | 20586 | .patterns = &.{ |
| | 20587 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20588 | }, |
| | 20589 | .extra_temps = .{ |
| | 20590 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20591 | .{ .type = .i64, .kind = .{ .smax_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 20592 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20593 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20594 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20595 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20596 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20597 | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, |
| | 20598 | .unused, |
| | 20599 | .unused, |
| | 20600 | .unused, |
| | 20601 | }, |
| | 20602 | .dst_temps = .{ .mem, .unused }, |
| | 20603 | .clobbers = .{ .eflags = true }, |
| | 20604 | .each = .{ .once = &.{ |
| | 20605 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 20606 | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 20607 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20608 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20609 | .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20610 | .{ ._, .p_, .xor, .tmp5x, .tmp5x, ._, ._ }, |
| | 20611 | .{ ._, ._dqa, .mov, .tmp6x, .tmp3x, ._, ._ }, |
| | 20612 | .{ ._, .p_q, .sub, .tmp6x, .tmp4x, ._, ._ }, |
| | 20613 | .{ ._, .p_q, .cmpgt, .tmp5x, .tmp3x, ._, ._ }, |
| | 20614 | .{ ._, ._dqa, .mov, .tmp7x, .tmp6x, ._, ._ }, |
| | 20615 | .{ ._, .p_q, .cmpgt, .tmp7x, .tmp3x, ._, ._ }, |
| | 20616 | .{ ._, .p_, .xor, .tmp5x, .tmp2x, ._, ._ }, |
| | 20617 | .{ ._, .p_, .xor, .tmp7x, .tmp4x, ._, ._ }, |
| | 20618 | .{ ._, ._pd, .blendv, .tmp6x, .tmp5x, .tmp7x, ._ }, |
| | 20619 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp6x, ._, ._ }, |
| | 20620 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 20621 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20622 | } }, |
| | 20623 | }, .{ |
| | 20624 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| | 20625 | .src_constraints = .{ |
| | 20626 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } }, |
| | 20627 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } }, |
| | 20628 | .any, |
| | 20629 | }, |
| | 20630 | .patterns = &.{ |
| | 20631 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20632 | }, |
| | 20633 | .extra_temps = .{ |
| | 20634 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20635 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20636 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20637 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20638 | .unused, |
| | 20639 | .unused, |
| | 20640 | .unused, |
| | 20641 | .unused, |
| | 20642 | .unused, |
| | 20643 | .unused, |
| | 20644 | .unused, |
| | 20645 | }, |
| | 20646 | .dst_temps = .{ .mem, .unused }, |
| | 20647 | .clobbers = .{ .eflags = true }, |
| | 20648 | .each = .{ .once = &.{ |
| | 20649 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20650 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| | 20651 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20652 | .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ }, |
| | 20653 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 20654 | .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ }, |
| | 20655 | .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20656 | .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ }, |
| | 20657 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 20658 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 20659 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20660 | } }, |
| | 20661 | }, .{ |
| | 20662 | .required_features = .{ .@"64bit", null, null, null }, |
| | 20663 | .src_constraints = .{ |
| | 20664 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } }, |
| | 20665 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 64 } }, |
| | 20666 | .any, |
| | 20667 | }, |
| | 20668 | .patterns = &.{ |
| | 20669 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20670 | }, |
| | 20671 | .extra_temps = .{ |
| | 20672 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20673 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20674 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20675 | .unused, |
| | 20676 | .unused, |
| | 20677 | .unused, |
| | 20678 | .unused, |
| | 20679 | .unused, |
| | 20680 | .unused, |
| | 20681 | .unused, |
| | 20682 | .unused, |
| | 20683 | }, |
| | 20684 | .dst_temps = .{ .mem, .unused }, |
| | 20685 | .clobbers = .{ .eflags = true }, |
| | 20686 | .each = .{ .once = &.{ |
| | 20687 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20688 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smin), ._, ._ }, |
| | 20689 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20690 | .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20691 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 20692 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 20693 | .{ ._, ._, .xor, .tmp2q, .tmp1q, ._, ._ }, |
| | 20694 | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 20695 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 20696 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20697 | } }, |
| | 20698 | }, .{ |
| | 20699 | .required_features = .{ .avx2, null, null, null }, |
| | 20700 | .src_constraints = .{ |
| | 20701 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| | 20702 | .{ .multiple_scalar_signed_int = .{ .of = .yword, .is = .qword } }, |
| | 20703 | .any, |
| | 20704 | }, |
| | 20705 | .patterns = &.{ |
| | 20706 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20707 | }, |
| | 20708 | .extra_temps = .{ |
| | 20709 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20710 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 20711 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 20712 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 20713 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 20714 | .{ .type = .vector_4_i64, .kind = .{ .rc = .sse } }, |
| | 20715 | .unused, |
| | 20716 | .unused, |
| | 20717 | .unused, |
| | 20718 | .unused, |
| | 20719 | .unused, |
| | 20720 | }, |
| | 20721 | .dst_temps = .{ .mem, .unused }, |
| | 20722 | .clobbers = .{ .eflags = true }, |
| | 20723 | .each = .{ .once = &.{ |
| | 20724 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 20725 | .{ ._, .vp_q, .cmpeq, .tmp2y, .tmp2y, .tmp2y, ._ }, |
| | 20726 | .{ ._, .vp_q, .broadcast, .tmp3y, .lea(.tmp0q), ._, ._ }, |
| | 20727 | .{ ._, .vp_, .xor, .tmp2y, .tmp3y, .tmp2y, ._ }, |
| | 20728 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20729 | .{ .@"0:", .v_dqa, .mov, .tmp4y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20730 | .{ ._, .vp_q, .sub, .tmp4y, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 20731 | .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp3y, .tmp4y, ._ }, |
| | 20732 | .{ ._, .vp_b, .blendv, .tmp4y, .tmp4y, .tmp3y, .tmp5y }, |
| | 20733 | .{ ._, .vp_q, .cmpgt, .tmp5y, .tmp4y, .tmp2y, ._ }, |
| | 20734 | .{ ._, .vp_b, .blendv, .tmp4y, .tmp4y, .tmp2y, .tmp5y }, |
| | 20735 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp4y, ._, ._ }, |
| | 20736 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 20737 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20738 | } }, |
| | 20739 | }, .{ |
| | 20740 | .required_features = .{ .avx, null, null, null }, |
| | 20741 | .src_constraints = .{ |
| | 20742 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 20743 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 20744 | .any, |
| | 20745 | }, |
| | 20746 | .patterns = &.{ |
| | 20747 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20748 | }, |
| | 20749 | .extra_temps = .{ |
| | 20750 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20751 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 20752 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20753 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20754 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20755 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20756 | .unused, |
| | 20757 | .unused, |
| | 20758 | .unused, |
| | 20759 | .unused, |
| | 20760 | .unused, |
| | 20761 | }, |
| | 20762 | .dst_temps = .{ .mem, .unused }, |
| | 20763 | .clobbers = .{ .eflags = true }, |
| | 20764 | .each = .{ .once = &.{ |
| | 20765 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 20766 | .{ ._, .vp_q, .cmpeq, .tmp2x, .tmp2x, .tmp2x, ._ }, |
| | 20767 | .{ ._, .v_, .movddup, .tmp3x, .lea(.tmp0q), ._, ._ }, |
| | 20768 | .{ ._, .vp_, .xor, .tmp2x, .tmp3x, .tmp2x, ._ }, |
| | 20769 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20770 | .{ .@"0:", .v_dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20771 | .{ ._, .vp_q, .sub, .tmp4x, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 20772 | .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp3x, .tmp4x, ._ }, |
| | 20773 | .{ ._, .vp_b, .blendv, .tmp4x, .tmp4x, .tmp3x, .tmp5x }, |
| | 20774 | .{ ._, .vp_q, .cmpgt, .tmp5x, .tmp4x, .tmp2x, ._ }, |
| | 20775 | .{ ._, .vp_b, .blendv, .tmp4x, .tmp4x, .tmp2x, .tmp5x }, |
| | 20776 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 20777 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 20778 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20779 | } }, |
| | 20780 | }, .{ |
| | 20781 | .required_features = .{ .sse4_2, null, null, null }, |
| | 20782 | .src_constraints = .{ |
| | 20783 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 20784 | .{ .multiple_scalar_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 20785 | .any, |
| | 20786 | }, |
| | 20787 | .patterns = &.{ |
| | 20788 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20789 | }, |
| | 20790 | .extra_temps = .{ |
| | 20791 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20792 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 20793 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20794 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20795 | .{ .type = .vector_2_i64, .kind = .{ .rc = .sse } }, |
| | 20796 | .{ .type = .vector_2_i64, .kind = .{ .reg = .xmm0 } }, |
| | 20797 | .unused, |
| | 20798 | .unused, |
| | 20799 | .unused, |
| | 20800 | .unused, |
| | 20801 | .unused, |
| | 20802 | }, |
| | 20803 | .dst_temps = .{ .mem, .unused }, |
| | 20804 | .clobbers = .{ .eflags = true }, |
| | 20805 | .each = .{ .once = &.{ |
| | 20806 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 20807 | .{ ._, .p_q, .cmpeq, .tmp2x, .tmp2x, ._, ._ }, |
| | 20808 | .{ ._, ._, .movddup, .tmp3x, .lea(.tmp0q), ._, ._ }, |
| | 20809 | .{ ._, .p_, .xor, .tmp2x, .tmp3x, ._, ._ }, |
| | 20810 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20811 | .{ .@"0:", ._dqa, .mov, .tmp4x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20812 | .{ ._, .p_q, .sub, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20813 | .{ ._, ._dqa, .mov, .tmp5x, .tmp3x, ._, ._ }, |
| | 20814 | .{ ._, .p_q, .cmpgt, .tmp5x, .tmp4x, ._, ._ }, |
| | 20815 | .{ ._, .p_b, .blendv, .tmp4x, .tmp3x, .tmp5x, ._ }, |
| | 20816 | .{ ._, ._dqa, .mov, .tmp5x, .tmp4x, ._, ._ }, |
| | 20817 | .{ ._, .p_q, .cmpgt, .tmp5x, .tmp2x, ._, ._ }, |
| | 20818 | .{ ._, .p_b, .blendv, .tmp4x, .tmp2x, .tmp5x, ._ }, |
| | 20819 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp4x, ._, ._ }, |
| | 20820 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 20821 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20822 | } }, |
| | 20823 | }, .{ |
| | 20824 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| | 20825 | .src_constraints = .{ |
| | 20826 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } }, |
| | 20827 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } }, |
| | 20828 | .any, |
| | 20829 | }, |
| | 20830 | .patterns = &.{ |
| | 20831 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20832 | }, |
| | 20833 | .extra_temps = .{ |
| | 20834 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20835 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20836 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20837 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20838 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20839 | .unused, |
| | 20840 | .unused, |
| | 20841 | .unused, |
| | 20842 | .unused, |
| | 20843 | .unused, |
| | 20844 | .unused, |
| | 20845 | }, |
| | 20846 | .dst_temps = .{ .mem, .unused }, |
| | 20847 | .clobbers = .{ .eflags = true }, |
| | 20848 | .each = .{ .once = &.{ |
| | 20849 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20850 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| | 20851 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20852 | .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ }, |
| | 20853 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 20854 | .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20855 | .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ }, |
| | 20856 | .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ }, |
| | 20857 | .{ ._, ._, .add, .tmp4q, .tmp4q, ._, ._ }, |
| | 20858 | .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ }, |
| | 20859 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 20860 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 20861 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20862 | } }, |
| | 20863 | }, .{ |
| | 20864 | .required_features = .{ .@"64bit", null, null, null }, |
| | 20865 | .src_constraints = .{ |
| | 20866 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } }, |
| | 20867 | .{ .multiple_scalar_exact_signed_int = .{ .of = .qword, .is = 63 } }, |
| | 20868 | .any, |
| | 20869 | }, |
| | 20870 | .patterns = &.{ |
| | 20871 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20872 | }, |
| | 20873 | .extra_temps = .{ |
| | 20874 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20875 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20876 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20877 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20878 | .unused, |
| | 20879 | .unused, |
| | 20880 | .unused, |
| | 20881 | .unused, |
| | 20882 | .unused, |
| | 20883 | .unused, |
| | 20884 | .unused, |
| | 20885 | }, |
| | 20886 | .dst_temps = .{ .mem, .unused }, |
| | 20887 | .clobbers = .{ .eflags = true }, |
| | 20888 | .each = .{ .once = &.{ |
| | 20889 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20890 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| | 20891 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20892 | .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20893 | .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ }, |
| | 20894 | .{ ._, ._, .add, .tmp3q, .tmp3q, ._, ._ }, |
| | 20895 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 20896 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 20897 | .{ ._, ._, .xor, .tmp2q, .tmp1q, ._, ._ }, |
| | 20898 | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 20899 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 20900 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20901 | } }, |
| | 20902 | }, .{ |
| | 20903 | .required_features = .{ .@"64bit", .bmi2, .cmov, null }, |
| | 20904 | .src_constraints = .{ |
| | 20905 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| | 20906 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| | 20907 | .any, |
| | 20908 | }, |
| | 20909 | .patterns = &.{ |
| | 20910 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20911 | }, |
| | 20912 | .extra_temps = .{ |
| | 20913 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20914 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20915 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20916 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20917 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20918 | .unused, |
| | 20919 | .unused, |
| | 20920 | .unused, |
| | 20921 | .unused, |
| | 20922 | .unused, |
| | 20923 | .unused, |
| | 20924 | }, |
| | 20925 | .dst_temps = .{ .mem, .unused }, |
| | 20926 | .clobbers = .{ .eflags = true }, |
| | 20927 | .each = .{ .once = &.{ |
| | 20928 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20929 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| | 20930 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20931 | .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ }, |
| | 20932 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 20933 | .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20934 | .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ }, |
| | 20935 | .{ ._, ._rx, .ro, .tmp4q, .tmp2q, .sia(-31, .src0, .add_bit_size_rem_64), ._ }, |
| | 20936 | .{ ._, ._, .add, .tmp4d, .tmp4d, ._, ._ }, |
| | 20937 | .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ }, |
| | 20938 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 20939 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 20940 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20941 | } }, |
| | 20942 | }, .{ |
| | 20943 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| | 20944 | .src_constraints = .{ |
| | 20945 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| | 20946 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| | 20947 | .any, |
| | 20948 | }, |
| | 20949 | .patterns = &.{ |
| | 20950 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20951 | }, |
| | 20952 | .extra_temps = .{ |
| | 20953 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20954 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20955 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20956 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20957 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20958 | .unused, |
| | 20959 | .unused, |
| | 20960 | .unused, |
| | 20961 | .unused, |
| | 20962 | .unused, |
| | 20963 | .unused, |
| | 20964 | }, |
| | 20965 | .dst_temps = .{ .mem, .unused }, |
| | 20966 | .clobbers = .{ .eflags = true }, |
| | 20967 | .each = .{ .once = &.{ |
| | 20968 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 20969 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| | 20970 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20971 | .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ }, |
| | 20972 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 20973 | .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 20974 | .{ ._, ._, .xor, .tmp3q, .tmp1q, ._, ._ }, |
| | 20975 | .{ ._, ._, .mov, .tmp4q, .tmp2q, ._, ._ }, |
| | 20976 | .{ ._, ._r, .sa, .tmp4q, .sia(-31, .src0, .add_bit_size_rem_64), ._, ._ }, |
| | 20977 | .{ ._, ._, .add, .tmp4d, .tmp4d, ._, ._ }, |
| | 20978 | .{ ._, ._o, .cmov, .tmp2q, .tmp3q, ._, ._ }, |
| | 20979 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 20980 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 20981 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 20982 | } }, |
| | 20983 | }, .{ |
| | 20984 | .required_features = .{ .@"64bit", null, null, null }, |
| | 20985 | .src_constraints = .{ |
| | 20986 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| | 20987 | .{ .multiple_scalar_signed_int = .{ .of = .qword, .is = .qword } }, |
| | 20988 | .any, |
| | 20989 | }, |
| | 20990 | .patterns = &.{ |
| | 20991 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 20992 | }, |
| | 20993 | .extra_temps = .{ |
| | 20994 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 20995 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20996 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20997 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| | 20998 | .unused, |
| | 20999 | .unused, |
| | 21000 | .unused, |
| | 21001 | .unused, |
| | 21002 | .unused, |
| | 21003 | .unused, |
| | 21004 | .unused, |
| | 21005 | }, |
| | 21006 | .dst_temps = .{ .mem, .unused }, |
| | 21007 | .clobbers = .{ .eflags = true }, |
| | 21008 | .each = .{ .once = &.{ |
| | 21009 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21010 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| | 21011 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21012 | .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21013 | .{ ._, ._, .mov, .tmp3q, .tmp2q, ._, ._ }, |
| | 21014 | .{ ._, ._r, .sa, .tmp3q, .sia(-31, .src0, .add_bit_size_rem_64), ._, ._ }, |
| | 21015 | .{ ._, ._, .add, .tmp3d, .tmp3d, ._, ._ }, |
| | 21016 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 21017 | .{ ._, ._r, .sa, .tmp2q, .ui(63), ._, ._ }, |
| | 21018 | .{ ._, ._, .xor, .tmp2q, .tmp1q, ._, ._ }, |
| | 21019 | .{ .@"1:", ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 21020 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 21021 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21022 | } }, |
| | 21023 | }, .{ |
| | 21024 | .required_features = .{ .avx2, null, null, null }, |
| | 21025 | .src_constraints = .{ |
| | 21026 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } }, |
| | 21027 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .yword, .is = 64 } }, |
| | 21028 | .any, |
| | 21029 | }, |
| | 21030 | .patterns = &.{ |
| | 21031 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 21032 | }, |
| | 21033 | .extra_temps = .{ |
| | 21034 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 21035 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 21036 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 21037 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 21038 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 21039 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 21040 | .unused, |
| | 21041 | .unused, |
| | 21042 | .unused, |
| | 21043 | .unused, |
| | 21044 | .unused, |
| | 21045 | }, |
| | 21046 | .dst_temps = .{ .mem, .unused }, |
| | 21047 | .clobbers = .{ .eflags = true }, |
| | 21048 | .each = .{ .once = &.{ |
| | 21049 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 21050 | .{ ._, .vp_q, .broadcast, .tmp2y, .lea(.tmp0q), ._, ._ }, |
| | 21051 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21052 | .{ .@"0:", .v_dqa, .mov, .tmp3y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21053 | .{ ._, .v_dqa, .mov, .tmp4y, .memia(.src1y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21054 | .{ ._, .vp_q, .sub, .tmp5y, .tmp3y, .tmp4y, ._ }, |
| | 21055 | .{ ._, .vp_, .xor, .tmp3y, .tmp3y, .tmp2y, ._ }, |
| | 21056 | .{ ._, .vp_, .xor, .tmp4y, .tmp4y, .tmp2y, ._ }, |
| | 21057 | .{ ._, .vp_q, .cmpgt, .tmp3y, .tmp3y, .tmp4y, ._ }, |
| | 21058 | .{ ._, .vp_, .@"and", .tmp3y, .tmp5y, .tmp3y, ._ }, |
| | 21059 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp3y, ._, ._ }, |
| | 21060 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 21061 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21062 | } }, |
| | 21063 | }, .{ |
| | 21064 | .required_features = .{ .avx, null, null, null }, |
| | 21065 | .src_constraints = .{ |
| | 21066 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 21067 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 21068 | .any, |
| | 21069 | }, |
| | 21070 | .patterns = &.{ |
| | 21071 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 21072 | }, |
| | 21073 | .extra_temps = .{ |
| | 21074 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 21075 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 21076 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 21077 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 21078 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 21079 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 21080 | .unused, |
| | 21081 | .unused, |
| | 21082 | .unused, |
| | 21083 | .unused, |
| | 21084 | .unused, |
| | 21085 | }, |
| | 21086 | .dst_temps = .{ .mem, .unused }, |
| | 21087 | .clobbers = .{ .eflags = true }, |
| | 21088 | .each = .{ .once = &.{ |
| | 21089 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 21090 | .{ ._, .v_, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 21091 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21092 | .{ .@"0:", .v_dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21093 | .{ ._, .v_dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21094 | .{ ._, .vp_q, .sub, .tmp5x, .tmp3x, .tmp4x, ._ }, |
| | 21095 | .{ ._, .vp_, .xor, .tmp3x, .tmp3x, .tmp2x, ._ }, |
| | 21096 | .{ ._, .vp_, .xor, .tmp4x, .tmp4x, .tmp2x, ._ }, |
| | 21097 | .{ ._, .vp_q, .cmpgt, .tmp3x, .tmp3x, .tmp4x, ._ }, |
| | 21098 | .{ ._, .vp_, .@"and", .tmp3x, .tmp5x, .tmp3x, ._ }, |
| | 21099 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 21100 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 21101 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21102 | } }, |
| | 21103 | }, .{ |
| | 21104 | .required_features = .{ .sse4_2, null, null, null }, |
| | 21105 | .src_constraints = .{ |
| | 21106 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 21107 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .xword, .is = 64 } }, |
| | 21108 | .any, |
| | 21109 | }, |
| | 21110 | .patterns = &.{ |
| | 21111 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 21112 | }, |
| | 21113 | .extra_temps = .{ |
| | 21114 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 21115 | .{ .type = .i64, .kind = .{ .smin_mem = .{ .ref = .src0, .vectorize_to = .none } } }, |
| | 21116 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 21117 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 21118 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 21119 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 21120 | .unused, |
| | 21121 | .unused, |
| | 21122 | .unused, |
| | 21123 | .unused, |
| | 21124 | .unused, |
| | 21125 | }, |
| | 21126 | .dst_temps = .{ .mem, .unused }, |
| | 21127 | .clobbers = .{ .eflags = true }, |
| | 21128 | .each = .{ .once = &.{ |
| | 21129 | .{ ._, ._, .lea, .tmp0p, .mem(.tmp1), ._, ._ }, |
| | 21130 | .{ ._, ._, .movddup, .tmp2x, .lea(.tmp0q), ._, ._ }, |
| | 21131 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21132 | .{ .@"0:", ._dqa, .mov, .tmp3x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21133 | .{ ._, ._dqa, .mov, .tmp4x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21134 | .{ ._, ._dqa, .mov, .tmp5x, .tmp3x, ._, ._ }, |
| | 21135 | .{ ._, .p_q, .sub, .tmp5x, .tmp4x, ._, ._ }, |
| | 21136 | .{ ._, .p_, .xor, .tmp3x, .tmp2x, ._, ._ }, |
| | 21137 | .{ ._, .p_, .xor, .tmp4x, .tmp2x, ._, ._ }, |
| | 21138 | .{ ._, .p_q, .cmpgt, .tmp3x, .tmp4x, ._, ._ }, |
| | 21139 | .{ ._, .p_, .@"and", .tmp3x, .tmp5x, ._, ._ }, |
| | 21140 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp3x, ._, ._ }, |
| | 21141 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 21142 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21143 | } }, |
| | 21144 | }, .{ |
| | 21145 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| | 21146 | .src_constraints = .{ |
| | 21147 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 64 } }, |
| | 21148 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 64 } }, |
| | 21149 | .any, |
| | 21150 | }, |
| | 21151 | .patterns = &.{ |
| | 21152 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 21153 | }, |
| | 21154 | .extra_temps = .{ |
| | 21155 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 21156 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 21157 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 21158 | .unused, |
| | 21159 | .unused, |
| | 21160 | .unused, |
| | 21161 | .unused, |
| | 21162 | .unused, |
| | 21163 | .unused, |
| | 21164 | .unused, |
| | 21165 | .unused, |
| | 21166 | }, |
| | 21167 | .dst_temps = .{ .mem, .unused }, |
| | 21168 | .clobbers = .{ .eflags = true }, |
| | 21169 | .each = .{ .once = &.{ |
| | 21170 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21171 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| | 21172 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21173 | .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21174 | .{ ._, ._c, .cmov, .tmp2q, .tmp1q, ._, ._ }, |
| | 21175 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 21176 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 21177 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21178 | } }, |
| | 21179 | }, .{ |
| | 21180 | .required_features = .{ .@"64bit", null, null, null }, |
| | 21181 | .src_constraints = .{ |
| | 21182 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 64 } }, |
| | 21183 | .{ .multiple_scalar_exact_unsigned_int = .{ .of = .qword, .is = 64 } }, |
| | 21184 | .any, |
| | 21185 | }, |
| | 21186 | .patterns = &.{ |
| | 21187 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 21188 | }, |
| | 21189 | .extra_temps = .{ |
| | 21190 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 21191 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 21192 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 21193 | .unused, |
| | 21194 | .unused, |
| | 21195 | .unused, |
| | 21196 | .unused, |
| | 21197 | .unused, |
| | 21198 | .unused, |
| | 21199 | .unused, |
| | 21200 | .unused, |
| | 21201 | }, |
| | 21202 | .dst_temps = .{ .mem, .unused }, |
| | 21203 | .clobbers = .{ .eflags = true }, |
| | 21204 | .each = .{ .once = &.{ |
| | 21205 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21206 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21207 | .{ ._, ._, .sub, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21208 | .{ ._, ._, .cmc, ._, ._, ._, ._ }, |
| | 21209 | .{ ._, ._, .sbb, .tmp2q, .tmp2q, ._, ._ }, |
| | 21210 | .{ ._, ._, .@"and", .tmp1q, .tmp2q, ._, ._ }, |
| | 21211 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| | 21212 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 21213 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21214 | } }, |
| | 21215 | }, .{ |
| | 21216 | .required_features = .{ .avx2, null, null, null }, |
| | 21217 | .src_constraints = .{ |
| | 21218 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| | 21219 | .{ .multiple_scalar_unsigned_int = .{ .of = .yword, .is = .qword } }, |
| | 21220 | .any, |
| | 21221 | }, |
| | 21222 | .patterns = &.{ |
| | 21223 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 21224 | }, |
| | 21225 | .extra_temps = .{ |
| | 21226 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 21227 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 21228 | .{ .type = .vector_4_u64, .kind = .{ .rc = .sse } }, |
| | 21229 | .unused, |
| | 21230 | .unused, |
| | 21231 | .unused, |
| | 21232 | .unused, |
| | 21233 | .unused, |
| | 21234 | .unused, |
| | 21235 | .unused, |
| | 21236 | .unused, |
| | 21237 | }, |
| | 21238 | .dst_temps = .{ .mem, .unused }, |
| | 21239 | .clobbers = .{ .eflags = true }, |
| | 21240 | .each = .{ .once = &.{ |
| | 21241 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21242 | .{ ._, .vp_, .xor, .tmp1y, .tmp1y, .tmp1y, ._ }, |
| | 21243 | .{ .@"0:", .v_dqa, .mov, .tmp2y, .memia(.src0y, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21244 | .{ ._, .vp_q, .sub, .tmp2y, .tmp2y, .memia(.src1y, .tmp0, .add_unaligned_size), ._ }, |
| | 21245 | .{ ._, .v_pd, .blendv, .tmp2y, .tmp2y, .tmp1y, .tmp2y }, |
| | 21246 | .{ ._, .v_dqa, .mov, .memia(.dst0y, .tmp0, .add_unaligned_size), .tmp2y, ._, ._ }, |
| | 21247 | .{ ._, ._, .add, .tmp0p, .si(32), ._, ._ }, |
| | 21248 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21249 | } }, |
| | 21250 | }, .{ |
| | 21251 | .required_features = .{ .avx, null, null, null }, |
| | 21252 | .src_constraints = .{ |
| | 21253 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 21254 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 21255 | .any, |
| | 21256 | }, |
| | 21257 | .patterns = &.{ |
| | 21258 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 21259 | }, |
| | 21260 | .extra_temps = .{ |
| | 21261 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 21262 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 21263 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 21264 | .unused, |
| | 21265 | .unused, |
| | 21266 | .unused, |
| | 21267 | .unused, |
| | 21268 | .unused, |
| | 21269 | .unused, |
| | 21270 | .unused, |
| | 21271 | .unused, |
| | 21272 | }, |
| | 21273 | .dst_temps = .{ .mem, .unused }, |
| | 21274 | .clobbers = .{ .eflags = true }, |
| | 21275 | .each = .{ .once = &.{ |
| | 21276 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21277 | .{ ._, .vp_, .xor, .tmp1x, .tmp1x, .tmp1x, ._ }, |
| | 21278 | .{ .@"0:", .v_dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21279 | .{ ._, .vp_q, .sub, .tmp2x, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._ }, |
| | 21280 | .{ ._, .v_pd, .blendv, .tmp2x, .tmp2x, .tmp1x, .tmp2x }, |
| | 21281 | .{ ._, .v_dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| | 21282 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 21283 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21284 | } }, |
| | 21285 | }, .{ |
| | 21286 | .required_features = .{ .sse4_1, null, null, null }, |
| | 21287 | .src_constraints = .{ |
| | 21288 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 21289 | .{ .multiple_scalar_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 21290 | .any, |
| | 21291 | }, |
| | 21292 | .patterns = &.{ |
| | 21293 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 21294 | }, |
| | 21295 | .extra_temps = .{ |
| | 21296 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 21297 | .{ .type = .vector_2_u64, .kind = .{ .rc = .sse } }, |
| | 21298 | .{ .type = .vector_2_u64, .kind = .{ .reg = .xmm0 } }, |
| | 21299 | .unused, |
| | 21300 | .unused, |
| | 21301 | .unused, |
| | 21302 | .unused, |
| | 21303 | .unused, |
| | 21304 | .unused, |
| | 21305 | .unused, |
| | 21306 | .unused, |
| | 21307 | }, |
| | 21308 | .dst_temps = .{ .mem, .unused }, |
| | 21309 | .clobbers = .{ .eflags = true }, |
| | 21310 | .each = .{ .once = &.{ |
| | 21311 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21312 | .{ ._, .p_, .xor, .tmp1x, .tmp1x, ._, ._ }, |
| | 21313 | .{ .@"0:", ._dqa, .mov, .tmp2x, .memia(.src0x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21314 | .{ ._, .p_q, .sub, .tmp2x, .memia(.src1x, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21315 | .{ ._, ._pd, .blendv, .tmp2x, .tmp1x, .tmp2x, ._ }, |
| | 21316 | .{ ._, ._dqa, .mov, .memia(.dst0x, .tmp0, .add_unaligned_size), .tmp2x, ._, ._ }, |
| | 21317 | .{ ._, ._, .add, .tmp0p, .si(16), ._, ._ }, |
| | 21318 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21319 | } }, |
| | 21320 | }, .{ |
| | 21321 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| | 21322 | .src_constraints = .{ |
| | 21323 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| | 21324 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| | 21325 | .any, |
| | 21326 | }, |
| | 21327 | .patterns = &.{ |
| | 21328 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 21329 | }, |
| | 21330 | .extra_temps = .{ |
| | 21331 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 21332 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 21333 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 21334 | .unused, |
| | 21335 | .unused, |
| | 21336 | .unused, |
| | 21337 | .unused, |
| | 21338 | .unused, |
| | 21339 | .unused, |
| | 21340 | .unused, |
| | 21341 | .unused, |
| | 21342 | }, |
| | 21343 | .dst_temps = .{ .mem, .unused }, |
| | 21344 | .clobbers = .{ .eflags = true }, |
| | 21345 | .each = .{ .once = &.{ |
| | 21346 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21347 | .{ ._, ._, .xor, .tmp1q, .tmp1q, ._, ._ }, |
| | 21348 | .{ .@"0:", ._, .mov, .tmp2q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21349 | .{ ._, ._, .sub, .tmp2q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21350 | .{ ._, ._c, .cmov, .tmp2q, .tmp1q, ._, ._ }, |
| | 21351 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp2q, ._, ._ }, |
| | 21352 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 21353 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21354 | } }, |
| | 21355 | }, .{ |
| | 21356 | .required_features = .{ .@"64bit", null, null, null }, |
| | 21357 | .src_constraints = .{ |
| | 21358 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| | 21359 | .{ .multiple_scalar_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| | 21360 | .any, |
| | 21361 | }, |
| | 21362 | .patterns = &.{ |
| | 21363 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 21364 | }, |
| | 21365 | .extra_temps = .{ |
| | 21366 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 21367 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 21368 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 21369 | .unused, |
| | 21370 | .unused, |
| | 21371 | .unused, |
| | 21372 | .unused, |
| | 21373 | .unused, |
| | 21374 | .unused, |
| | 21375 | .unused, |
| | 21376 | .unused, |
| | 21377 | }, |
| | 21378 | .dst_temps = .{ .mem, .unused }, |
| | 21379 | .clobbers = .{ .eflags = true }, |
| | 21380 | .each = .{ .once = &.{ |
| | 21381 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21382 | .{ .@"0:", ._, .mov, .tmp1q, .memia(.src0q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21383 | .{ ._, ._, .sub, .tmp1q, .memia(.src1q, .tmp0, .add_unaligned_size), ._, ._ }, |
| | 21384 | .{ ._, ._, .cmc, ._, ._, ._, ._ }, |
| | 21385 | .{ ._, ._, .sbb, .tmp2q, .tmp2q, ._, ._ }, |
| | 21386 | .{ ._, ._, .@"and", .tmp1q, .tmp2q, ._, ._ }, |
| | 21387 | .{ ._, ._, .mov, .memia(.dst0q, .tmp0, .add_unaligned_size), .tmp1q, ._, ._ }, |
| | 21388 | .{ ._, ._, .add, .tmp0p, .si(8), ._, ._ }, |
| | 21389 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21390 | } }, |
| | 21391 | }, .{ |
| | 21392 | .required_features = .{ .@"64bit", null, null, null }, |
| | 21393 | .src_constraints = .{ |
| | 21394 | .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 21395 | .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 21396 | .any, |
| | 21397 | }, |
| | 21398 | .patterns = &.{ |
| | 21399 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 21400 | }, |
| | 21401 | .extra_temps = .{ |
| | 21402 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 21403 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| | 21404 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 21405 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 21406 | .{ .type = .isize, .kind = .{ .reg = .rcx } }, |
| | 21407 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| | 21408 | .unused, |
| | 21409 | .unused, |
| | 21410 | .unused, |
| | 21411 | .unused, |
| | 21412 | .unused, |
| | 21413 | }, |
| | 21414 | .dst_temps = .{ .mem, .unused }, |
| | 21415 | .clobbers = .{ .eflags = true }, |
| | 21416 | .each = .{ .once = &.{ |
| | 21417 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21418 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 21419 | .{ .@"0:", ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| | 21420 | .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| | 21421 | .{ ._, ._, .lea, .tmp3p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| | 21422 | .{ ._, ._, .mov, .tmp4p, .sia(1, .src0, .sub_elem_size_div_8), ._, ._ }, |
| | 21423 | .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ }, |
| | 21424 | .{ ._, ._, .sbb, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ }, |
| | 21425 | .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ }, |
| | 21426 | .{ ._, ._c, .in, .tmp4p, ._, ._, ._ }, |
| | 21427 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 21428 | .{ ._, ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ }, |
| | 21429 | .{ ._, ._, .sbb, .tmp5q, .lea(.tmp2q), ._, ._ }, |
| | 21430 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 21431 | .{ ._, ._, .lea, .tmp1p, .leaad(.tmp3, .sub_src0_elem_size, 8), ._, ._ }, |
| | 21432 | .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, |
| | 21433 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| | 21434 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| | 21435 | .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ }, |
| | 21436 | .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ }, |
| | 21437 | .{ .@"1:", ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ }, |
| | 21438 | .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| | 21439 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21440 | } }, |
| | 21441 | }, .{ |
| | 21442 | .required_features = .{ .@"64bit", null, null, null }, |
| | 21443 | .src_constraints = .{ |
| | 21444 | .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 21445 | .{ .scalar_exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 21446 | .any, |
| | 21447 | }, |
| | 21448 | .patterns = &.{ |
| | 21449 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 21450 | }, |
| | 21451 | .extra_temps = .{ |
| | 21452 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 21453 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| | 21454 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 21455 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 21456 | .{ .type = .isize, .kind = .{ .reg = .rcx } }, |
| | 21457 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| | 21458 | .unused, |
| | 21459 | .unused, |
| | 21460 | .unused, |
| | 21461 | .unused, |
| | 21462 | .unused, |
| | 21463 | }, |
| | 21464 | .dst_temps = .{ .mem, .unused }, |
| | 21465 | .clobbers = .{ .eflags = true }, |
| | 21466 | .each = .{ .once = &.{ |
| | 21467 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21468 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 21469 | .{ .@"0:", ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -16), ._, ._ }, |
| | 21470 | .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -16), ._, ._ }, |
| | 21471 | .{ ._, ._, .lea, .tmp3p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -16), ._, ._ }, |
| | 21472 | .{ ._, ._, .mov, .tmp4p, .sia(2, .src0, .sub_elem_size_div_8), ._, ._ }, |
| | 21473 | .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ }, |
| | 21474 | .{ ._, ._, .sbb, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ }, |
| | 21475 | .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ }, |
| | 21476 | .{ ._, ._c, .in, .tmp4p, ._, ._, ._ }, |
| | 21477 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 21478 | .{ ._, ._, .mov, .tmp5q, .lea(.tmp1q), ._, ._ }, |
| | 21479 | .{ ._, ._, .sbb, .tmp5q, .lea(.tmp2q), ._, ._ }, |
| | 21480 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 21481 | .{ ._, ._, .lea, .tmp1p, .leaad(.tmp3, .sub_src0_elem_size, 16), ._, ._ }, |
| | 21482 | .{ ._, ._, .mov, .tmp4d, .sia(-2, .src0, .add_elem_size_div_8), ._, ._ }, |
| | 21483 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| | 21484 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| | 21485 | .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ }, |
| | 21486 | .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ }, |
| | 21487 | .{ .@"1:", ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ }, |
| | 21488 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| | 21489 | .{ ._, ._, .mov, .lead(.tmp3q, 8), .tmp5q, ._, ._ }, |
| | 21490 | .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| | 21491 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21492 | } }, |
| | 21493 | }, .{ |
| | 21494 | .required_features = .{ .@"64bit", null, null, null }, |
| | 21495 | .src_constraints = .{ |
| | 21496 | .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 21497 | .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 21498 | .any, |
| | 21499 | }, |
| | 21500 | .patterns = &.{ |
| | 21501 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 21502 | }, |
| | 21503 | .extra_temps = .{ |
| | 21504 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 21505 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| | 21506 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 21507 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 21508 | .{ .type = .isize, .kind = .{ .reg = .rcx } }, |
| | 21509 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| | 21510 | .unused, |
| | 21511 | .unused, |
| | 21512 | .unused, |
| | 21513 | .unused, |
| | 21514 | .unused, |
| | 21515 | }, |
| | 21516 | .dst_temps = .{ .mem, .unused }, |
| | 21517 | .clobbers = .{ .eflags = true }, |
| | 21518 | .each = .{ .once = &.{ |
| | 21519 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21520 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 21521 | .{ .@"0:", ._, .lea, .tmp1p, .memiad(.src0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| | 21522 | .{ ._, ._, .lea, .tmp2p, .memiad(.src1, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| | 21523 | .{ ._, ._, .lea, .tmp3p, .memiad(.dst0, .tmp0, .add_unaligned_size_add_elem_size, -8), ._, ._ }, |
| | 21524 | .{ ._, ._, .mov, .tmp4p, .sia(1, .src0, .sub_elem_size_div_8), ._, ._ }, |
| | 21525 | .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ }, |
| | 21526 | .{ ._, ._, .sbb, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ }, |
| | 21527 | .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ }, |
| | 21528 | .{ ._, ._c, .in, .tmp4p, ._, ._, ._ }, |
| | 21529 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 21530 | .{ ._, ._l, .sa, .tmp5q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 21531 | .{ ._, ._, .add, .tmp5q, .tmp5q, ._, ._ }, |
| | 21532 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 21533 | .{ ._, ._, .lea, .tmp1p, .leaad(.tmp3, .sub_src0_elem_size, 8), ._, ._ }, |
| | 21534 | .{ ._, ._, .mov, .tmp4d, .sia(-2, .src0, .add_elem_size_div_8), ._, ._ }, |
| | 21535 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| | 21536 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| | 21537 | .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ }, |
| | 21538 | .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ }, |
| | 21539 | .{ ._, ._, .mov, .lead(.tmp3q, -8), .tmp5q, ._, ._ }, |
| | 21540 | .{ .@"1:", ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| | 21541 | .{ ._, ._, .mov, .lea(.tmp3q), .tmp5q, ._, ._ }, |
| | 21542 | .{ ._, ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| | 21543 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21544 | } }, |
| | 21545 | }, .{ |
| | 21546 | .required_features = .{ .@"64bit", null, null, null }, |
| | 21547 | .src_constraints = .{ |
| | 21548 | .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 21549 | .{ .scalar_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 21550 | .any, |
| | 21551 | }, |
| | 21552 | .patterns = &.{ |
| | 21553 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 21554 | }, |
| | 21555 | .extra_temps = .{ |
| | 21556 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 21557 | .{ .type = .usize, .kind = .{ .reg = .rdi } }, |
| | 21558 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 21559 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 21560 | .{ .type = .isize, .kind = .{ .reg = .rcx } }, |
| | 21561 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| | 21562 | .unused, |
| | 21563 | .unused, |
| | 21564 | .unused, |
| | 21565 | .unused, |
| | 21566 | .unused, |
| | 21567 | }, |
| | 21568 | .dst_temps = .{ .mem, .unused }, |
| | 21569 | .clobbers = .{ .eflags = true }, |
| | 21570 | .each = .{ .once = &.{ |
| | 21571 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21572 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 21573 | .{ .@"0:", ._, .lea, .tmp1p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| | 21574 | .{ ._, ._, .lea, .tmp2p, .memia(.src1, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| | 21575 | .{ ._, ._, .lea, .tmp3p, .memia(.dst0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| | 21576 | .{ ._, ._, .mov, .tmp4p, .sa(.src0, .sub_elem_size_div_8), ._, ._ }, |
| | 21577 | .{ .@"1:", ._, .mov, .tmp5q, .leasi(.tmp1q, .@"8", .tmp4), ._, ._ }, |
| | 21578 | .{ ._, ._, .sbb, .tmp5q, .leasi(.tmp2q, .@"8", .tmp4), ._, ._ }, |
| | 21579 | .{ ._, ._, .mov, .leasi(.tmp3q, .@"8", .tmp4), .tmp5q, ._, ._ }, |
| | 21580 | .{ ._, ._c, .in, .tmp4p, ._, ._, ._ }, |
| | 21581 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 21582 | .{ ._, ._l, .sa, .tmp5q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 21583 | .{ ._, ._, .add, .tmp5q, .tmp5q, ._, ._ }, |
| | 21584 | .{ ._, ._no, .j, .@"1f", ._, ._, ._ }, |
| | 21585 | .{ ._, ._, .lea, .tmp1p, .leaa(.tmp3, .sub_src0_elem_size), ._, ._ }, |
| | 21586 | .{ ._, ._, .mov, .tmp4d, .sia(-1, .src0, .add_elem_size_div_8), ._, ._ }, |
| | 21587 | .{ ._, ._r, .sa, .tmp5q, .ui(63), ._, ._ }, |
| | 21588 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| | 21589 | .{ ._, ._, .mov, .tmp4q, .ua(.src0, .add_smin), ._, ._ }, |
| | 21590 | .{ ._, ._, .xor, .tmp5q, .tmp4q, ._, ._ }, |
| | 21591 | .{ ._, ._, .mov, .lead(.tmp3q, -8), .tmp5q, ._, ._ }, |
| | 21592 | .{ .@"1:", ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| | 21593 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21594 | } }, |
| | 21595 | }, .{ |
| | 21596 | .required_features = .{ .@"64bit", null, null, null }, |
| | 21597 | .src_constraints = .{ |
| | 21598 | .{ .scalar_remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| | 21599 | .{ .scalar_remainder_unsigned_int = .{ .of = .qword, .is = .qword } }, |
| | 21600 | .any, |
| | 21601 | }, |
| | 21602 | .patterns = &.{ |
| | 21603 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 21604 | }, |
| | 21605 | .extra_temps = .{ |
| | 21606 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 21607 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 21608 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 21609 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 21610 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 21611 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| | 21612 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| | 21613 | .unused, |
| | 21614 | .unused, |
| | 21615 | .unused, |
| | 21616 | .unused, |
| | 21617 | }, |
| | 21618 | .dst_temps = .{ .mem, .unused }, |
| | 21619 | .clobbers = .{ .eflags = true }, |
| | 21620 | .each = .{ .once = &.{ |
| | 21621 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_unaligned_size), ._, ._ }, |
| | 21622 | .{ ._, ._, .xor, .tmp1d, .tmp1d, ._, ._ }, |
| | 21623 | .{ .@"0:", ._, .lea, .tmp2p, .memia(.src0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| | 21624 | .{ ._, ._, .lea, .tmp3p, .memia(.src1, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| | 21625 | .{ ._, ._, .lea, .tmp4p, .memia(.dst0, .tmp0, .add_unaligned_size_add_elem_size), ._, ._ }, |
| | 21626 | .{ ._, ._, .mov, .tmp5p, .sa(.src0, .sub_elem_size_div_8), ._, ._ }, |
| | 21627 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 21628 | .{ ._, ._, .sbb, .tmp6q, .leasi(.tmp3q, .@"8", .tmp5), ._, ._ }, |
| | 21629 | .{ ._, ._, .mov, .leasi(.tmp4q, .@"8", .tmp5), .tmp6q, ._, ._ }, |
| | 21630 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 21631 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 21632 | .{ ._, ._nc, .j, .@"1f", ._, ._, ._ }, |
| | 21633 | .{ ._, ._, .lea, .tmp5p, .leaa(.tmp4, .sub_src0_elem_size), ._, ._ }, |
| | 21634 | .{ ._, ._, .mov, .tmp6d, .sa(.src0, .add_elem_size_div_8), ._, ._ }, |
| | 21635 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| | 21636 | .{ .@"1:", ._, .add, .tmp0p, .sa(.src0, .add_elem_size), ._, ._ }, |
| | 21637 | .{ ._, ._nc, .j, .@"0b", ._, ._, ._ }, |
| | 21638 | } }, |
| 16520 | } }) catch |err| switch (err) { | 21639 | } }) catch |err| switch (err) { |
| 16521 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ | 21640 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 16522 | @tagName(air_tag), | 21641 | @tagName(air_tag), |
Jacob Young <jacobly@ziglang.org> 2025-05-13 06:50:05-04:00
src