| ... | @@ -83,7 +83,6 @@ end_di_column: u32, | ... | @@ -83,7 +83,6 @@ end_di_column: u32, |
| 83 | epilogue_relocs: std.ArrayListUnmanaged(Mir.Inst.Index) = .empty, | 83 | epilogue_relocs: std.ArrayListUnmanaged(Mir.Inst.Index) = .empty, |
| 84 | | 84 | |
| 85 | reused_operands: std.StaticBitSet(Liveness.bpi - 1) = undefined, | 85 | reused_operands: std.StaticBitSet(Liveness.bpi - 1) = undefined, |
| 86 | const_tracking: ConstTrackingMap = .empty, | | |
| 87 | inst_tracking: InstTrackingMap = .empty, | 86 | inst_tracking: InstTrackingMap = .empty, |
| 88 | | 87 | |
| 89 | // Key is the block instruction | 88 | // Key is the block instruction |
| ... | @@ -926,7 +925,6 @@ pub fn generate( | ... | @@ -926,7 +925,6 @@ pub fn generate( |
| 926 | while (block_it.next()) |block| block.deinit(gpa); | 925 | while (block_it.next()) |block| block.deinit(gpa); |
| 927 | function.blocks.deinit(gpa); | 926 | function.blocks.deinit(gpa); |
| 928 | function.inst_tracking.deinit(gpa); | 927 | function.inst_tracking.deinit(gpa); |
| 929 | function.const_tracking.deinit(gpa); | | |
| 930 | function.epilogue_relocs.deinit(gpa); | 928 | function.epilogue_relocs.deinit(gpa); |
| 931 | function.mir_instructions.deinit(gpa); | 929 | function.mir_instructions.deinit(gpa); |
| 932 | function.mir_extra.deinit(gpa); | 930 | function.mir_extra.deinit(gpa); |
| ... | @@ -2418,7 +2416,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2418,7 +2416,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2418 | } | 2416 | } |
| 2419 | | 2417 | |
| 2420 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | 2418 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2421 | @setEvalBranchQuota(13_900); | 2419 | @setEvalBranchQuota(15_100); |
| 2422 | const pt = cg.pt; | 2420 | const pt = cg.pt; |
| 2423 | const zcu = pt.zcu; | 2421 | const zcu = pt.zcu; |
| 2424 | const ip = &zcu.intern_pool; | 2422 | const ip = &zcu.intern_pool; |
| ... | @@ -2459,9 +2457,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2459,9 +2457,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2459 | .mul_sat => try cg.airMulSat(inst), | 2457 | .mul_sat => try cg.airMulSat(inst), |
| 2460 | .shl_sat => try cg.airShlSat(inst), | 2458 | .shl_sat => try cg.airShlSat(inst), |
| 2461 | | 2459 | |
| 2462 | .add_with_overflow => try cg.airAddSubWithOverflow(inst), | | |
| 2463 | .sub_with_overflow => try cg.airAddSubWithOverflow(inst), | | |
| 2464 | .mul_with_overflow => try cg.airMulWithOverflow(inst), | | |
| 2465 | .shl_with_overflow => try cg.airShlWithOverflow(inst), | 2460 | .shl_with_overflow => try cg.airShlWithOverflow(inst), |
| 2466 | | 2461 | |
| 2467 | .bitcast => try cg.airBitCast(inst), | 2462 | .bitcast => try cg.airBitCast(inst), |
| ... | @@ -28019,6 +28014,5377 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -28019,6 +28014,5377 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28019 | }; | 28014 | }; |
| 28020 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); | 28015 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 28021 | }, | 28016 | }, |
| | 28017 | .add_with_overflow => |air_tag| if (use_old) try cg.airAddSubWithOverflow(inst) else fallback: { |
| | 28018 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| | 28019 | const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; |
| | 28020 | if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airAddSubWithOverflow(inst); |
| | 28021 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| | 28022 | var res: [2]Temp = undefined; |
| | 28023 | cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{ |
| | 28024 | .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any }, |
| | 28025 | .patterns = &.{ |
| | 28026 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| | 28027 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28028 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28029 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28030 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28031 | }, |
| | 28032 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 28033 | .clobbers = .{ .eflags = true }, |
| | 28034 | .each = .{ .once = &.{ |
| | 28035 | .{ ._, ._, .add, .dst0b, .src1b, ._, ._ }, |
| | 28036 | } }, |
| | 28037 | }, .{ |
| | 28038 | .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .exact_unsigned_int = 8 }, .any }, |
| | 28039 | .patterns = &.{ |
| | 28040 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| | 28041 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28042 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28043 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28044 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28045 | }, |
| | 28046 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 28047 | .clobbers = .{ .eflags = true }, |
| | 28048 | .each = .{ .once = &.{ |
| | 28049 | .{ ._, ._, .add, .dst0b, .src1b, ._, ._ }, |
| | 28050 | } }, |
| | 28051 | }, .{ |
| | 28052 | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any }, |
| | 28053 | .patterns = &.{ |
| | 28054 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| | 28055 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28056 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28057 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28058 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28059 | }, |
| | 28060 | .extra_temps = .{ |
| | 28061 | .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 28062 | .unused, |
| | 28063 | .unused, |
| | 28064 | .unused, |
| | 28065 | .unused, |
| | 28066 | .unused, |
| | 28067 | .unused, |
| | 28068 | .unused, |
| | 28069 | .unused, |
| | 28070 | .unused, |
| | 28071 | .unused, |
| | 28072 | }, |
| | 28073 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .po } }, |
| | 28074 | .clobbers = .{ .eflags = true }, |
| | 28075 | .each = .{ .once = &.{ |
| | 28076 | .{ ._, ._, .add, .dst0b, .src1b, ._, ._ }, |
| | 28077 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 28078 | .{ ._, ._l, .sa, .dst0b, .uia(8, .src0, .sub_bit_size), ._, ._ }, |
| | 28079 | .{ ._, ._r, .sa, .dst0b, .uia(8, .src0, .sub_bit_size), ._, ._ }, |
| | 28080 | .{ ._, ._, .@"test", .tmp0b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ }, |
| | 28081 | } }, |
| | 28082 | }, .{ |
| | 28083 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| | 28084 | .patterns = &.{ |
| | 28085 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| | 28086 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28087 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28088 | }, |
| | 28089 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .b } }, |
| | 28090 | .clobbers = .{ .eflags = true }, |
| | 28091 | .each = .{ .once = &.{ |
| | 28092 | .{ ._, ._, .add, .dst0b, .src1b, ._, ._ }, |
| | 28093 | .{ ._, ._, .@"and", .dst0b, .ua(.src0, .add_umax), ._, ._ }, |
| | 28094 | .{ ._, ._, .cmp, .dst0b, .src1b, ._, ._ }, |
| | 28095 | } }, |
| | 28096 | }, .{ |
| | 28097 | .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any }, |
| | 28098 | .patterns = &.{ |
| | 28099 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| | 28100 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28101 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28102 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28103 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28104 | }, |
| | 28105 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 28106 | .clobbers = .{ .eflags = true }, |
| | 28107 | .each = .{ .once = &.{ |
| | 28108 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| | 28109 | } }, |
| | 28110 | }, .{ |
| | 28111 | .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .{ .exact_unsigned_int = 16 }, .any }, |
| | 28112 | .patterns = &.{ |
| | 28113 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| | 28114 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28115 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28116 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28117 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28118 | }, |
| | 28119 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 28120 | .clobbers = .{ .eflags = true }, |
| | 28121 | .each = .{ .once = &.{ |
| | 28122 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| | 28123 | } }, |
| | 28124 | }, .{ |
| | 28125 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 28126 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| | 28127 | .patterns = &.{ |
| | 28128 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| | 28129 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28130 | }, |
| | 28131 | .extra_temps = .{ |
| | 28132 | .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 28133 | .unused, |
| | 28134 | .unused, |
| | 28135 | .unused, |
| | 28136 | .unused, |
| | 28137 | .unused, |
| | 28138 | .unused, |
| | 28139 | .unused, |
| | 28140 | .unused, |
| | 28141 | .unused, |
| | 28142 | .unused, |
| | 28143 | }, |
| | 28144 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 28145 | .clobbers = .{ .eflags = true }, |
| | 28146 | .each = .{ .once = &.{ |
| | 28147 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| | 28148 | .{ ._, ._l, .ro, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 28149 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 28150 | .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 28151 | .{ ._, ._r, .ro, .tmp0d, .ui(1), ._, ._ }, |
| | 28152 | } }, |
| | 28153 | }, .{ |
| | 28154 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| | 28155 | .patterns = &.{ |
| | 28156 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28157 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28158 | }, |
| | 28159 | .extra_temps = .{ |
| | 28160 | .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 28161 | .unused, |
| | 28162 | .unused, |
| | 28163 | .unused, |
| | 28164 | .unused, |
| | 28165 | .unused, |
| | 28166 | .unused, |
| | 28167 | .unused, |
| | 28168 | .unused, |
| | 28169 | .unused, |
| | 28170 | .unused, |
| | 28171 | }, |
| | 28172 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 28173 | .clobbers = .{ .eflags = true }, |
| | 28174 | .each = .{ .once = &.{ |
| | 28175 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| | 28176 | .{ ._, ._l, .ro, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 28177 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 28178 | .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 28179 | .{ ._, ._r, .ro, .tmp0d, .ui(1), ._, ._ }, |
| | 28180 | } }, |
| | 28181 | }, .{ |
| | 28182 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 28183 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| | 28184 | .patterns = &.{ |
| | 28185 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| | 28186 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28187 | }, |
| | 28188 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .b } }, |
| | 28189 | .clobbers = .{ .eflags = true }, |
| | 28190 | .each = .{ .once = &.{ |
| | 28191 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| | 28192 | .{ ._, ._, .@"and", .dst0w, .ua(.src0, .add_umax), ._, ._ }, |
| | 28193 | .{ ._, ._, .cmp, .dst0w, .src1w, ._, ._ }, |
| | 28194 | } }, |
| | 28195 | }, .{ |
| | 28196 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 28197 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| | 28198 | .patterns = &.{ |
| | 28199 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28200 | }, |
| | 28201 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .b } }, |
| | 28202 | .clobbers = .{ .eflags = true }, |
| | 28203 | .each = .{ .once = &.{ |
| | 28204 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| | 28205 | .{ ._, ._, .@"and", .dst0w, .ua(.src0, .add_umax), ._, ._ }, |
| | 28206 | .{ ._, ._, .cmp, .dst0w, .src1w, ._, ._ }, |
| | 28207 | } }, |
| | 28208 | }, .{ |
| | 28209 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| | 28210 | .patterns = &.{ |
| | 28211 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| | 28212 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28213 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28214 | }, |
| | 28215 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .b } }, |
| | 28216 | .clobbers = .{ .eflags = true }, |
| | 28217 | .each = .{ .once = &.{ |
| | 28218 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| | 28219 | .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| | 28220 | .{ ._, ._, .cmp, .dst0w, .src1w, ._, ._ }, |
| | 28221 | } }, |
| | 28222 | }, .{ |
| | 28223 | .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any }, |
| | 28224 | .patterns = &.{ |
| | 28225 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 28226 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28227 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28228 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28229 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28230 | }, |
| | 28231 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 28232 | .clobbers = .{ .eflags = true }, |
| | 28233 | .each = .{ .once = &.{ |
| | 28234 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| | 28235 | } }, |
| | 28236 | }, .{ |
| | 28237 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .{ .exact_unsigned_int = 32 }, .any }, |
| | 28238 | .patterns = &.{ |
| | 28239 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 28240 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28241 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28242 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28243 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28244 | }, |
| | 28245 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 28246 | .clobbers = .{ .eflags = true }, |
| | 28247 | .each = .{ .once = &.{ |
| | 28248 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| | 28249 | } }, |
| | 28250 | }, .{ |
| | 28251 | .required_features = .{ .bmi2, null, null, null }, |
| | 28252 | .src_constraints = .{ .{ .exact_signed_int = 31 }, .{ .exact_signed_int = 31 }, .any }, |
| | 28253 | .patterns = &.{ |
| | 28254 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 28255 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28256 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28257 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28258 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28259 | }, |
| | 28260 | .extra_temps = .{ |
| | 28261 | .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 28262 | .unused, |
| | 28263 | .unused, |
| | 28264 | .unused, |
| | 28265 | .unused, |
| | 28266 | .unused, |
| | 28267 | .unused, |
| | 28268 | .unused, |
| | 28269 | .unused, |
| | 28270 | .unused, |
| | 28271 | .unused, |
| | 28272 | }, |
| | 28273 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 28274 | .clobbers = .{ .eflags = true }, |
| | 28275 | .each = .{ .once = &.{ |
| | 28276 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| | 28277 | .{ ._, ._, .mov, .tmp0d, .ui(1), ._, ._ }, |
| | 28278 | .{ ._, ._, .add, .dst0d, .dst0d, ._, ._ }, |
| | 28279 | .{ ._, ._rx, .sa, .dst0d, .dst0d, .tmp0d, ._ }, |
| | 28280 | } }, |
| | 28281 | }, .{ |
| | 28282 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| | 28283 | .patterns = &.{ |
| | 28284 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 28285 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28286 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28287 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28288 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28289 | }, |
| | 28290 | .extra_temps = .{ |
| | 28291 | .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 28292 | .unused, |
| | 28293 | .unused, |
| | 28294 | .unused, |
| | 28295 | .unused, |
| | 28296 | .unused, |
| | 28297 | .unused, |
| | 28298 | .unused, |
| | 28299 | .unused, |
| | 28300 | .unused, |
| | 28301 | .unused, |
| | 28302 | }, |
| | 28303 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 28304 | .clobbers = .{ .eflags = true }, |
| | 28305 | .each = .{ .once = &.{ |
| | 28306 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| | 28307 | .{ ._, ._l, .ro, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 28308 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 28309 | .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 28310 | .{ ._, ._r, .ro, .tmp0d, .ui(1), ._, ._ }, |
| | 28311 | } }, |
| | 28312 | }, .{ |
| | 28313 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| | 28314 | .patterns = &.{ |
| | 28315 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 28316 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28317 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28318 | }, |
| | 28319 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .b } }, |
| | 28320 | .clobbers = .{ .eflags = true }, |
| | 28321 | .each = .{ .once = &.{ |
| | 28322 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| | 28323 | .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| | 28324 | .{ ._, ._, .cmp, .dst0d, .src1d, ._, ._ }, |
| | 28325 | } }, |
| | 28326 | }, .{ |
| | 28327 | .required_features = .{ .@"64bit", null, null, null }, |
| | 28328 | .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any }, |
| | 28329 | .patterns = &.{ |
| | 28330 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 28331 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28332 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28333 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28334 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28335 | }, |
| | 28336 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 28337 | .clobbers = .{ .eflags = true }, |
| | 28338 | .each = .{ .once = &.{ |
| | 28339 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| | 28340 | } }, |
| | 28341 | }, .{ |
| | 28342 | .required_features = .{ .@"64bit", null, null, null }, |
| | 28343 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .exact_unsigned_int = 64 }, .any }, |
| | 28344 | .patterns = &.{ |
| | 28345 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 28346 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28347 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28348 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28349 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28350 | }, |
| | 28351 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 28352 | .clobbers = .{ .eflags = true }, |
| | 28353 | .each = .{ .once = &.{ |
| | 28354 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| | 28355 | } }, |
| | 28356 | }, .{ |
| | 28357 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 28358 | .src_constraints = .{ .{ .exact_signed_int = 63 }, .{ .exact_signed_int = 63 }, .any }, |
| | 28359 | .patterns = &.{ |
| | 28360 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 28361 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28362 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28363 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28364 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28365 | }, |
| | 28366 | .extra_temps = .{ |
| | 28367 | .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 28368 | .unused, |
| | 28369 | .unused, |
| | 28370 | .unused, |
| | 28371 | .unused, |
| | 28372 | .unused, |
| | 28373 | .unused, |
| | 28374 | .unused, |
| | 28375 | .unused, |
| | 28376 | .unused, |
| | 28377 | .unused, |
| | 28378 | }, |
| | 28379 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 28380 | .clobbers = .{ .eflags = true }, |
| | 28381 | .each = .{ .once = &.{ |
| | 28382 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| | 28383 | .{ ._, ._, .mov, .tmp0d, .ui(1), ._, ._ }, |
| | 28384 | .{ ._, ._, .add, .dst0q, .dst0q, ._, ._ }, |
| | 28385 | .{ ._, ._rx, .sa, .dst0q, .dst0q, .tmp0q, ._ }, |
| | 28386 | } }, |
| | 28387 | }, .{ |
| | 28388 | .required_features = .{ .@"64bit", null, null, null }, |
| | 28389 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| | 28390 | .patterns = &.{ |
| | 28391 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 28392 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28393 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28394 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28395 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28396 | }, |
| | 28397 | .extra_temps = .{ |
| | 28398 | .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 28399 | .unused, |
| | 28400 | .unused, |
| | 28401 | .unused, |
| | 28402 | .unused, |
| | 28403 | .unused, |
| | 28404 | .unused, |
| | 28405 | .unused, |
| | 28406 | .unused, |
| | 28407 | .unused, |
| | 28408 | .unused, |
| | 28409 | }, |
| | 28410 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 28411 | .clobbers = .{ .eflags = true }, |
| | 28412 | .each = .{ .once = &.{ |
| | 28413 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| | 28414 | .{ ._, ._l, .ro, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ }, |
| | 28415 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| | 28416 | .{ ._, ._r, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ }, |
| | 28417 | .{ ._, ._r, .ro, .tmp0q, .ui(1), ._, ._ }, |
| | 28418 | } }, |
| | 28419 | }, .{ |
| | 28420 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 28421 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| | 28422 | .patterns = &.{ |
| | 28423 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 28424 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28425 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28426 | }, |
| | 28427 | .extra_temps = .{ |
| | 28428 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 28429 | .unused, |
| | 28430 | .unused, |
| | 28431 | .unused, |
| | 28432 | .unused, |
| | 28433 | .unused, |
| | 28434 | .unused, |
| | 28435 | .unused, |
| | 28436 | .unused, |
| | 28437 | .unused, |
| | 28438 | .unused, |
| | 28439 | }, |
| | 28440 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .b } }, |
| | 28441 | .clobbers = .{ .eflags = true }, |
| | 28442 | .each = .{ .once = &.{ |
| | 28443 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size), ._, ._ }, |
| | 28444 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| | 28445 | .{ ._, ._, .bzhi, .dst0q, .dst0q, .tmp0q, ._ }, |
| | 28446 | .{ ._, ._, .cmp, .dst0q, .src1q, ._, ._ }, |
| | 28447 | } }, |
| | 28448 | }, .{ |
| | 28449 | .required_features = .{ .@"64bit", null, null, null }, |
| | 28450 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| | 28451 | .patterns = &.{ |
| | 28452 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 28453 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 28454 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28455 | }, |
| | 28456 | .dst_temps = .{ .{ .rc = .general_purpose }, .{ .cc = .b } }, |
| | 28457 | .clobbers = .{ .eflags = true }, |
| | 28458 | .each = .{ .once = &.{ |
| | 28459 | .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 28460 | .{ ._, ._, .add, .src0q, .src1q, ._, ._ }, |
| | 28461 | .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ }, |
| | 28462 | .{ ._, ._, .cmp, .dst0q, .src1q, ._, ._ }, |
| | 28463 | } }, |
| | 28464 | }, .{ |
| | 28465 | .required_features = .{ .@"64bit", null, null, null }, |
| | 28466 | .src_constraints = .{ |
| | 28467 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 28468 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 28469 | .any, |
| | 28470 | }, |
| | 28471 | .patterns = &.{ |
| | 28472 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 28473 | }, |
| | 28474 | .extra_temps = .{ |
| | 28475 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 28476 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 28477 | .unused, |
| | 28478 | .unused, |
| | 28479 | .unused, |
| | 28480 | .unused, |
| | 28481 | .unused, |
| | 28482 | .unused, |
| | 28483 | .unused, |
| | 28484 | .unused, |
| | 28485 | .unused, |
| | 28486 | }, |
| | 28487 | .dst_temps = .{ .mem, .none }, |
| | 28488 | .clobbers = .{ .eflags = true }, |
| | 28489 | .each = .{ .once = &.{ |
| | 28490 | .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ }, |
| | 28491 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 28492 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 28493 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 28494 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 28495 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 28496 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 28497 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| | 28498 | .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ }, |
| | 28499 | .{ ._, ._o, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ }, |
| | 28500 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 28501 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 28502 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 28503 | } }, |
| | 28504 | }, .{ |
| | 28505 | .required_features = .{ .@"64bit", null, null, null }, |
| | 28506 | .src_constraints = .{ |
| | 28507 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 28508 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 28509 | .any, |
| | 28510 | }, |
| | 28511 | .patterns = &.{ |
| | 28512 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 28513 | }, |
| | 28514 | .extra_temps = .{ |
| | 28515 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 28516 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 28517 | .unused, |
| | 28518 | .unused, |
| | 28519 | .unused, |
| | 28520 | .unused, |
| | 28521 | .unused, |
| | 28522 | .unused, |
| | 28523 | .unused, |
| | 28524 | .unused, |
| | 28525 | .unused, |
| | 28526 | }, |
| | 28527 | .dst_temps = .{ .mem, .{ .cc = .c } }, |
| | 28528 | .clobbers = .{ .eflags = true }, |
| | 28529 | .each = .{ .once = &.{ |
| | 28530 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 28531 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 28532 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 28533 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 28534 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 28535 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 28536 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 28537 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 28538 | } }, |
| | 28539 | }, .{ |
| | 28540 | .required_features = .{ .@"64bit", null, null, null }, |
| | 28541 | .src_constraints = .{ |
| | 28542 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 28543 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 28544 | .any, |
| | 28545 | }, |
| | 28546 | .patterns = &.{ |
| | 28547 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 28548 | }, |
| | 28549 | .extra_temps = .{ |
| | 28550 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 28551 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 28552 | .unused, |
| | 28553 | .unused, |
| | 28554 | .unused, |
| | 28555 | .unused, |
| | 28556 | .unused, |
| | 28557 | .unused, |
| | 28558 | .unused, |
| | 28559 | .unused, |
| | 28560 | .unused, |
| | 28561 | }, |
| | 28562 | .dst_temps = .{ .mem, .{ .cc = .o } }, |
| | 28563 | .clobbers = .{ .eflags = true }, |
| | 28564 | .each = .{ .once = &.{ |
| | 28565 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 28566 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 28567 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 28568 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 28569 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 28570 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 28571 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 28572 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 28573 | .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 28574 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 28575 | } }, |
| | 28576 | }, .{ |
| | 28577 | .required_features = .{ .@"64bit", null, null, null }, |
| | 28578 | .src_constraints = .{ |
| | 28579 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 28580 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 28581 | .any, |
| | 28582 | }, |
| | 28583 | .patterns = &.{ |
| | 28584 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 28585 | }, |
| | 28586 | .extra_temps = .{ |
| | 28587 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 28588 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 28589 | .unused, |
| | 28590 | .unused, |
| | 28591 | .unused, |
| | 28592 | .unused, |
| | 28593 | .unused, |
| | 28594 | .unused, |
| | 28595 | .unused, |
| | 28596 | .unused, |
| | 28597 | .unused, |
| | 28598 | }, |
| | 28599 | .dst_temps = .{ .mem, .{ .cc = .c } }, |
| | 28600 | .clobbers = .{ .eflags = true }, |
| | 28601 | .each = .{ .once = &.{ |
| | 28602 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| | 28603 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 28604 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| | 28605 | .{ ._, ._, .adc, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| | 28606 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_src0_size), .tmp1q, ._, ._ }, |
| | 28607 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 28608 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 28609 | } }, |
| | 28610 | }, .{ |
| | 28611 | .required_features = .{ .@"64bit", null, null, null }, |
| | 28612 | .src_constraints = .{ |
| | 28613 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 28614 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 28615 | .any, |
| | 28616 | }, |
| | 28617 | .patterns = &.{ |
| | 28618 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 28619 | }, |
| | 28620 | .extra_temps = .{ |
| | 28621 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 28622 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 28623 | .unused, |
| | 28624 | .unused, |
| | 28625 | .unused, |
| | 28626 | .unused, |
| | 28627 | .unused, |
| | 28628 | .unused, |
| | 28629 | .unused, |
| | 28630 | .unused, |
| | 28631 | .unused, |
| | 28632 | }, |
| | 28633 | .dst_temps = .{ .mem, .{ .cc = .o } }, |
| | 28634 | .clobbers = .{ .eflags = true }, |
| | 28635 | .each = .{ .once = &.{ |
| | 28636 | .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ }, |
| | 28637 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 28638 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 28639 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 28640 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 28641 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 28642 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 28643 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| | 28644 | .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ }, |
| | 28645 | .{ ._, ._l, .ro, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 28646 | .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ }, |
| | 28647 | .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 28648 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 28649 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 28650 | .{ ._, ._r, .ro, .tmp0q, .ui(1), ._, ._ }, |
| | 28651 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 28652 | } }, |
| | 28653 | }, .{ |
| | 28654 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 28655 | .src_constraints = .{ |
| | 28656 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 28657 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 28658 | .any, |
| | 28659 | }, |
| | 28660 | .patterns = &.{ |
| | 28661 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 28662 | }, |
| | 28663 | .extra_temps = .{ |
| | 28664 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 28665 | .unused, |
| | 28666 | .unused, |
| | 28667 | .unused, |
| | 28668 | .unused, |
| | 28669 | .unused, |
| | 28670 | .unused, |
| | 28671 | .unused, |
| | 28672 | .unused, |
| | 28673 | .unused, |
| | 28674 | .unused, |
| | 28675 | }, |
| | 28676 | .dst_temps = .{ .mem, .{ .rc = .general_purpose } }, |
| | 28677 | .clobbers = .{ .eflags = true }, |
| | 28678 | .each = .{ .once = &.{ |
| | 28679 | .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ }, |
| | 28680 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 28681 | .{ .@"0:", ._, .mov, .dst1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 28682 | .{ ._, ._, .adc, .dst1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 28683 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .dst1q, ._, ._ }, |
| | 28684 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 28685 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 28686 | .{ ._, ._, .mov, .dst1q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| | 28687 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 28688 | .{ ._, ._, .adc, .dst1q, .memad(.src1q, .add_size, -16), ._, ._ }, |
| | 28689 | .{ ._, ._, .bzhi, .tmp0q, .dst1q, .tmp0q, ._ }, |
| | 28690 | .{ ._, ._r, .sh, .dst1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 28691 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ }, |
| | 28692 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 28693 | } }, |
| | 28694 | }, .{ |
| | 28695 | .required_features = .{ .@"64bit", null, null, null }, |
| | 28696 | .src_constraints = .{ |
| | 28697 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 28698 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 28699 | .any, |
| | 28700 | }, |
| | 28701 | .patterns = &.{ |
| | 28702 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 28703 | }, |
| | 28704 | .extra_temps = .{ |
| | 28705 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 28706 | .unused, |
| | 28707 | .unused, |
| | 28708 | .unused, |
| | 28709 | .unused, |
| | 28710 | .unused, |
| | 28711 | .unused, |
| | 28712 | .unused, |
| | 28713 | .unused, |
| | 28714 | .unused, |
| | 28715 | .unused, |
| | 28716 | }, |
| | 28717 | .dst_temps = .{ .mem, .{ .rc = .general_purpose } }, |
| | 28718 | .clobbers = .{ .eflags = true }, |
| | 28719 | .each = .{ .once = &.{ |
| | 28720 | .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ }, |
| | 28721 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 28722 | .{ .@"0:", ._, .mov, .dst1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 28723 | .{ ._, ._, .adc, .dst1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 28724 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .dst1q, ._, ._ }, |
| | 28725 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 28726 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 28727 | .{ ._, ._, .mov, .dst1q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| | 28728 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 28729 | .{ ._, ._, .adc, .dst1q, .memad(.src1q, .add_size, -16), ._, ._ }, |
| | 28730 | .{ ._, ._, .@"and", .tmp0q, .dst1q, ._, ._ }, |
| | 28731 | .{ ._, ._r, .sh, .dst1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 28732 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ }, |
| | 28733 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 28734 | } }, |
| | 28735 | }, .{ |
| | 28736 | .required_features = .{ .@"64bit", null, null, null }, |
| | 28737 | .src_constraints = .{ |
| | 28738 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 28739 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 28740 | .any, |
| | 28741 | }, |
| | 28742 | .patterns = &.{ |
| | 28743 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 28744 | }, |
| | 28745 | .extra_temps = .{ |
| | 28746 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 28747 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 28748 | .unused, |
| | 28749 | .unused, |
| | 28750 | .unused, |
| | 28751 | .unused, |
| | 28752 | .unused, |
| | 28753 | .unused, |
| | 28754 | .unused, |
| | 28755 | .unused, |
| | 28756 | .unused, |
| | 28757 | }, |
| | 28758 | .dst_temps = .{ .mem, .{ .cc = .o } }, |
| | 28759 | .clobbers = .{ .eflags = true }, |
| | 28760 | .each = .{ .once = &.{ |
| | 28761 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 28762 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 28763 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 28764 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 28765 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 28766 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 28767 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 28768 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 28769 | .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 28770 | .{ ._, ._l, .ro, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 28771 | .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ }, |
| | 28772 | .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 28773 | .{ ._, ._r, .ro, .tmp0q, .ui(1), ._, ._ }, |
| | 28774 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 28775 | } }, |
| | 28776 | }, .{ |
| | 28777 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 28778 | .src_constraints = .{ |
| | 28779 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 28780 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 28781 | .any, |
| | 28782 | }, |
| | 28783 | .patterns = &.{ |
| | 28784 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 28785 | }, |
| | 28786 | .extra_temps = .{ |
| | 28787 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 28788 | .unused, |
| | 28789 | .unused, |
| | 28790 | .unused, |
| | 28791 | .unused, |
| | 28792 | .unused, |
| | 28793 | .unused, |
| | 28794 | .unused, |
| | 28795 | .unused, |
| | 28796 | .unused, |
| | 28797 | .unused, |
| | 28798 | }, |
| | 28799 | .dst_temps = .{ .mem, .{ .rc = .general_purpose } }, |
| | 28800 | .clobbers = .{ .eflags = true }, |
| | 28801 | .each = .{ .once = &.{ |
| | 28802 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 28803 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 28804 | .{ .@"0:", ._, .mov, .dst1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 28805 | .{ ._, ._, .adc, .dst1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 28806 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .dst1q, ._, ._ }, |
| | 28807 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 28808 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 28809 | .{ ._, ._, .mov, .dst1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 28810 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 28811 | .{ ._, ._, .adc, .dst1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 28812 | .{ ._, ._, .bzhi, .tmp0q, .dst1q, .tmp0q, ._ }, |
| | 28813 | .{ ._, ._r, .sh, .dst1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 28814 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 28815 | } }, |
| | 28816 | }, .{ |
| | 28817 | .required_features = .{ .@"64bit", null, null, null }, |
| | 28818 | .src_constraints = .{ |
| | 28819 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 28820 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 28821 | .any, |
| | 28822 | }, |
| | 28823 | .patterns = &.{ |
| | 28824 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 28825 | }, |
| | 28826 | .extra_temps = .{ |
| | 28827 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 28828 | .unused, |
| | 28829 | .unused, |
| | 28830 | .unused, |
| | 28831 | .unused, |
| | 28832 | .unused, |
| | 28833 | .unused, |
| | 28834 | .unused, |
| | 28835 | .unused, |
| | 28836 | .unused, |
| | 28837 | .unused, |
| | 28838 | }, |
| | 28839 | .dst_temps = .{ .mem, .{ .rc = .general_purpose } }, |
| | 28840 | .clobbers = .{ .eflags = true }, |
| | 28841 | .each = .{ .once = &.{ |
| | 28842 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 28843 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 28844 | .{ .@"0:", ._, .mov, .dst1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 28845 | .{ ._, ._, .adc, .dst1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 28846 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .dst1q, ._, ._ }, |
| | 28847 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 28848 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 28849 | .{ ._, ._, .mov, .dst1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 28850 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 28851 | .{ ._, ._, .adc, .dst1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 28852 | .{ ._, ._, .@"and", .tmp0q, .dst1q, ._, ._ }, |
| | 28853 | .{ ._, ._r, .sh, .dst1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 28854 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 28855 | } }, |
| | 28856 | } }) catch |err| switch (err) { |
| | 28857 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| | 28858 | @tagName(air_tag), |
| | 28859 | ty_pl.ty.toType().fmt(pt), |
| | 28860 | ops[0].tracking(cg), |
| | 28861 | ops[1].tracking(cg), |
| | 28862 | }), |
| | 28863 | else => |e| return e, |
| | 28864 | }; |
| | 28865 | try res[0].withOverflow(&res[1], cg); |
| | 28866 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| | 28867 | }, |
| | 28868 | .sub_with_overflow => |air_tag| if (use_old) try cg.airAddSubWithOverflow(inst) else fallback: { |
| | 28869 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| | 28870 | const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; |
| | 28871 | if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airAddSubWithOverflow(inst); |
| | 28872 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| | 28873 | var res: [2]Temp = undefined; |
| | 28874 | cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{ |
| | 28875 | .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any }, |
| | 28876 | .patterns = &.{ |
| | 28877 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| | 28878 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28879 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28880 | }, |
| | 28881 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 28882 | .clobbers = .{ .eflags = true }, |
| | 28883 | .each = .{ .once = &.{ |
| | 28884 | .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ }, |
| | 28885 | } }, |
| | 28886 | }, .{ |
| | 28887 | .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .exact_unsigned_int = 8 }, .any }, |
| | 28888 | .patterns = &.{ |
| | 28889 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| | 28890 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28891 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28892 | }, |
| | 28893 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 28894 | .clobbers = .{ .eflags = true }, |
| | 28895 | .each = .{ .once = &.{ |
| | 28896 | .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ }, |
| | 28897 | } }, |
| | 28898 | }, .{ |
| | 28899 | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any }, |
| | 28900 | .patterns = &.{ |
| | 28901 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| | 28902 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28903 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28904 | }, |
| | 28905 | .extra_temps = .{ |
| | 28906 | .{ .type = .i8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 28907 | .unused, |
| | 28908 | .unused, |
| | 28909 | .unused, |
| | 28910 | .unused, |
| | 28911 | .unused, |
| | 28912 | .unused, |
| | 28913 | .unused, |
| | 28914 | .unused, |
| | 28915 | .unused, |
| | 28916 | .unused, |
| | 28917 | }, |
| | 28918 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .po } }, |
| | 28919 | .clobbers = .{ .eflags = true }, |
| | 28920 | .each = .{ .once = &.{ |
| | 28921 | .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ }, |
| | 28922 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 28923 | .{ ._, ._l, .sa, .dst0b, .uia(8, .src0, .sub_bit_size), ._, ._ }, |
| | 28924 | .{ ._, ._r, .sa, .dst0b, .uia(8, .src0, .sub_bit_size), ._, ._ }, |
| | 28925 | .{ ._, ._, .@"test", .tmp0b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ }, |
| | 28926 | } }, |
| | 28927 | }, .{ |
| | 28928 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| | 28929 | .patterns = &.{ |
| | 28930 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| | 28931 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28932 | .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } }, |
| | 28933 | }, |
| | 28934 | .dst_temps = .{ .{ .ref = .src0 }, .{ .rc = .general_purpose } }, |
| | 28935 | .clobbers = .{ .eflags = true }, |
| | 28936 | .each = .{ .once = &.{ |
| | 28937 | .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ }, |
| | 28938 | .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ }, |
| | 28939 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 28940 | .{ ._, ._, .@"and", .dst0b, .ua(.src0, .add_umax), ._, ._ }, |
| | 28941 | } }, |
| | 28942 | }, .{ |
| | 28943 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| | 28944 | .patterns = &.{ |
| | 28945 | .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } }, |
| | 28946 | }, |
| | 28947 | .dst_temps = .{ .{ .ref = .src0 }, .{ .ref = .src1 } }, |
| | 28948 | .clobbers = .{ .eflags = true }, |
| | 28949 | .each = .{ .once = &.{ |
| | 28950 | .{ ._, ._, .sub, .dst0b, .src1b, ._, ._ }, |
| | 28951 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 28952 | .{ ._, ._, .@"and", .dst0b, .ua(.src0, .add_umax), ._, ._ }, |
| | 28953 | } }, |
| | 28954 | }, .{ |
| | 28955 | .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any }, |
| | 28956 | .patterns = &.{ |
| | 28957 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| | 28958 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28959 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28960 | }, |
| | 28961 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 28962 | .clobbers = .{ .eflags = true }, |
| | 28963 | .each = .{ .once = &.{ |
| | 28964 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 28965 | } }, |
| | 28966 | }, .{ |
| | 28967 | .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .{ .exact_unsigned_int = 16 }, .any }, |
| | 28968 | .patterns = &.{ |
| | 28969 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| | 28970 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 28971 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 28972 | }, |
| | 28973 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 28974 | .clobbers = .{ .eflags = true }, |
| | 28975 | .each = .{ .once = &.{ |
| | 28976 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 28977 | } }, |
| | 28978 | }, .{ |
| | 28979 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| | 28980 | .patterns = &.{ |
| | 28981 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| | 28982 | }, |
| | 28983 | .extra_temps = .{ |
| | 28984 | .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 28985 | .unused, |
| | 28986 | .unused, |
| | 28987 | .unused, |
| | 28988 | .unused, |
| | 28989 | .unused, |
| | 28990 | .unused, |
| | 28991 | .unused, |
| | 28992 | .unused, |
| | 28993 | .unused, |
| | 28994 | .unused, |
| | 28995 | }, |
| | 28996 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 28997 | .clobbers = .{ .eflags = true }, |
| | 28998 | .each = .{ .once = &.{ |
| | 28999 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 29000 | .{ ._, ._l, .ro, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29001 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 29002 | .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29003 | .{ ._, ._r, .ro, .tmp0d, .ui(1), ._, ._ }, |
| | 29004 | } }, |
| | 29005 | }, .{ |
| | 29006 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| | 29007 | .patterns = &.{ |
| | 29008 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29009 | }, |
| | 29010 | .extra_temps = .{ |
| | 29011 | .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 29012 | .unused, |
| | 29013 | .unused, |
| | 29014 | .unused, |
| | 29015 | .unused, |
| | 29016 | .unused, |
| | 29017 | .unused, |
| | 29018 | .unused, |
| | 29019 | .unused, |
| | 29020 | .unused, |
| | 29021 | .unused, |
| | 29022 | }, |
| | 29023 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 29024 | .clobbers = .{ .eflags = true }, |
| | 29025 | .each = .{ .once = &.{ |
| | 29026 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 29027 | .{ ._, ._l, .ro, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29028 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 29029 | .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29030 | .{ ._, ._r, .ro, .tmp0d, .ui(1), ._, ._ }, |
| | 29031 | } }, |
| | 29032 | }, .{ |
| | 29033 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 29034 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| | 29035 | .patterns = &.{ |
| | 29036 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| | 29037 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29038 | .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } }, |
| | 29039 | }, |
| | 29040 | .dst_temps = .{ .{ .ref = .src0 }, .{ .rc = .general_purpose } }, |
| | 29041 | .clobbers = .{ .eflags = true }, |
| | 29042 | .each = .{ .once = &.{ |
| | 29043 | .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ }, |
| | 29044 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 29045 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29046 | .{ ._, ._, .@"and", .dst0w, .ua(.src0, .add_umax), ._, ._ }, |
| | 29047 | } }, |
| | 29048 | }, .{ |
| | 29049 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 29050 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| | 29051 | .patterns = &.{ |
| | 29052 | .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } }, |
| | 29053 | }, |
| | 29054 | .dst_temps = .{ .{ .ref = .src0 }, .{ .ref = .src1 } }, |
| | 29055 | .clobbers = .{ .eflags = true }, |
| | 29056 | .each = .{ .once = &.{ |
| | 29057 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 29058 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29059 | .{ ._, ._, .@"and", .dst0w, .ua(.src0, .add_umax), ._, ._ }, |
| | 29060 | } }, |
| | 29061 | }, .{ |
| | 29062 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| | 29063 | .patterns = &.{ |
| | 29064 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| | 29065 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29066 | .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } }, |
| | 29067 | }, |
| | 29068 | .dst_temps = .{ .{ .ref = .src0 }, .{ .rc = .general_purpose } }, |
| | 29069 | .clobbers = .{ .eflags = true }, |
| | 29070 | .each = .{ .once = &.{ |
| | 29071 | .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ }, |
| | 29072 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 29073 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29074 | .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| | 29075 | } }, |
| | 29076 | }, .{ |
| | 29077 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| | 29078 | .patterns = &.{ |
| | 29079 | .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } }, |
| | 29080 | }, |
| | 29081 | .dst_temps = .{ .{ .ref = .src0 }, .{ .ref = .src1 } }, |
| | 29082 | .clobbers = .{ .eflags = true }, |
| | 29083 | .each = .{ .once = &.{ |
| | 29084 | .{ ._, ._, .sub, .dst0w, .src1w, ._, ._ }, |
| | 29085 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29086 | .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| | 29087 | } }, |
| | 29088 | }, .{ |
| | 29089 | .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any }, |
| | 29090 | .patterns = &.{ |
| | 29091 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 29092 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29093 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29094 | }, |
| | 29095 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 29096 | .clobbers = .{ .eflags = true }, |
| | 29097 | .each = .{ .once = &.{ |
| | 29098 | .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ }, |
| | 29099 | } }, |
| | 29100 | }, .{ |
| | 29101 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .{ .exact_unsigned_int = 32 }, .any }, |
| | 29102 | .patterns = &.{ |
| | 29103 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 29104 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29105 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29106 | }, |
| | 29107 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 29108 | .clobbers = .{ .eflags = true }, |
| | 29109 | .each = .{ .once = &.{ |
| | 29110 | .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ }, |
| | 29111 | } }, |
| | 29112 | }, .{ |
| | 29113 | .required_features = .{ .bmi2, null, null, null }, |
| | 29114 | .src_constraints = .{ .{ .exact_signed_int = 31 }, .{ .exact_signed_int = 31 }, .any }, |
| | 29115 | .patterns = &.{ |
| | 29116 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 29117 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29118 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29119 | }, |
| | 29120 | .extra_temps = .{ |
| | 29121 | .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 29122 | .unused, |
| | 29123 | .unused, |
| | 29124 | .unused, |
| | 29125 | .unused, |
| | 29126 | .unused, |
| | 29127 | .unused, |
| | 29128 | .unused, |
| | 29129 | .unused, |
| | 29130 | .unused, |
| | 29131 | .unused, |
| | 29132 | }, |
| | 29133 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 29134 | .clobbers = .{ .eflags = true }, |
| | 29135 | .each = .{ .once = &.{ |
| | 29136 | .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ }, |
| | 29137 | .{ ._, ._, .mov, .tmp0d, .ui(1), ._, ._ }, |
| | 29138 | .{ ._, ._, .add, .dst0d, .dst0d, ._, ._ }, |
| | 29139 | .{ ._, ._rx, .sa, .dst0d, .dst0d, .tmp0d, ._ }, |
| | 29140 | } }, |
| | 29141 | }, .{ |
| | 29142 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| | 29143 | .patterns = &.{ |
| | 29144 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 29145 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29146 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29147 | }, |
| | 29148 | .extra_temps = .{ |
| | 29149 | .{ .type = .i32, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 29150 | .unused, |
| | 29151 | .unused, |
| | 29152 | .unused, |
| | 29153 | .unused, |
| | 29154 | .unused, |
| | 29155 | .unused, |
| | 29156 | .unused, |
| | 29157 | .unused, |
| | 29158 | .unused, |
| | 29159 | .unused, |
| | 29160 | }, |
| | 29161 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 29162 | .clobbers = .{ .eflags = true }, |
| | 29163 | .each = .{ .once = &.{ |
| | 29164 | .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ }, |
| | 29165 | .{ ._, ._l, .ro, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29166 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 29167 | .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29168 | .{ ._, ._r, .ro, .tmp0d, .ui(1), ._, ._ }, |
| | 29169 | } }, |
| | 29170 | }, .{ |
| | 29171 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| | 29172 | .patterns = &.{ |
| | 29173 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| | 29174 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29175 | .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } }, |
| | 29176 | }, |
| | 29177 | .dst_temps = .{ .{ .ref = .src0 }, .{ .rc = .general_purpose } }, |
| | 29178 | .clobbers = .{ .eflags = true }, |
| | 29179 | .each = .{ .once = &.{ |
| | 29180 | .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ }, |
| | 29181 | .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ }, |
| | 29182 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29183 | .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| | 29184 | } }, |
| | 29185 | }, .{ |
| | 29186 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| | 29187 | .patterns = &.{ |
| | 29188 | .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } }, |
| | 29189 | }, |
| | 29190 | .dst_temps = .{ .{ .ref = .src0 }, .{ .ref = .src1 } }, |
| | 29191 | .clobbers = .{ .eflags = true }, |
| | 29192 | .each = .{ .once = &.{ |
| | 29193 | .{ ._, ._, .sub, .dst0d, .src1d, ._, ._ }, |
| | 29194 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29195 | .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| | 29196 | } }, |
| | 29197 | }, .{ |
| | 29198 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29199 | .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any }, |
| | 29200 | .patterns = &.{ |
| | 29201 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 29202 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29203 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29204 | }, |
| | 29205 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 29206 | .clobbers = .{ .eflags = true }, |
| | 29207 | .each = .{ .once = &.{ |
| | 29208 | .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ }, |
| | 29209 | } }, |
| | 29210 | }, .{ |
| | 29211 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29212 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .exact_unsigned_int = 64 }, .any }, |
| | 29213 | .patterns = &.{ |
| | 29214 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 29215 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29216 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29217 | }, |
| | 29218 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 29219 | .clobbers = .{ .eflags = true }, |
| | 29220 | .each = .{ .once = &.{ |
| | 29221 | .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ }, |
| | 29222 | } }, |
| | 29223 | }, .{ |
| | 29224 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 29225 | .src_constraints = .{ .{ .exact_signed_int = 63 }, .{ .exact_signed_int = 63 }, .any }, |
| | 29226 | .patterns = &.{ |
| | 29227 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 29228 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29229 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29230 | }, |
| | 29231 | .extra_temps = .{ |
| | 29232 | .{ .type = .u8, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 29233 | .unused, |
| | 29234 | .unused, |
| | 29235 | .unused, |
| | 29236 | .unused, |
| | 29237 | .unused, |
| | 29238 | .unused, |
| | 29239 | .unused, |
| | 29240 | .unused, |
| | 29241 | .unused, |
| | 29242 | .unused, |
| | 29243 | }, |
| | 29244 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 29245 | .clobbers = .{ .eflags = true }, |
| | 29246 | .each = .{ .once = &.{ |
| | 29247 | .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ }, |
| | 29248 | .{ ._, ._, .mov, .tmp0d, .ui(1), ._, ._ }, |
| | 29249 | .{ ._, ._, .add, .dst0q, .dst0q, ._, ._ }, |
| | 29250 | .{ ._, ._rx, .sa, .dst0q, .dst0q, .tmp0q, ._ }, |
| | 29251 | } }, |
| | 29252 | }, .{ |
| | 29253 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29254 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| | 29255 | .patterns = &.{ |
| | 29256 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 29257 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29258 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29259 | }, |
| | 29260 | .extra_temps = .{ |
| | 29261 | .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 29262 | .unused, |
| | 29263 | .unused, |
| | 29264 | .unused, |
| | 29265 | .unused, |
| | 29266 | .unused, |
| | 29267 | .unused, |
| | 29268 | .unused, |
| | 29269 | .unused, |
| | 29270 | .unused, |
| | 29271 | .unused, |
| | 29272 | }, |
| | 29273 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .o } }, |
| | 29274 | .clobbers = .{ .eflags = true }, |
| | 29275 | .each = .{ .once = &.{ |
| | 29276 | .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ }, |
| | 29277 | .{ ._, ._l, .ro, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ }, |
| | 29278 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| | 29279 | .{ ._, ._r, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ }, |
| | 29280 | .{ ._, ._r, .ro, .tmp0q, .ui(1), ._, ._ }, |
| | 29281 | } }, |
| | 29282 | }, .{ |
| | 29283 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 29284 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| | 29285 | .patterns = &.{ |
| | 29286 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 29287 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29288 | .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } }, |
| | 29289 | }, |
| | 29290 | .extra_temps = .{ |
| | 29291 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 29292 | .unused, |
| | 29293 | .unused, |
| | 29294 | .unused, |
| | 29295 | .unused, |
| | 29296 | .unused, |
| | 29297 | .unused, |
| | 29298 | .unused, |
| | 29299 | .unused, |
| | 29300 | .unused, |
| | 29301 | .unused, |
| | 29302 | }, |
| | 29303 | .dst_temps = .{ .{ .ref = .src0 }, .{ .rc = .general_purpose } }, |
| | 29304 | .clobbers = .{ .eflags = true }, |
| | 29305 | .each = .{ .once = &.{ |
| | 29306 | .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ }, |
| | 29307 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size), ._, ._ }, |
| | 29308 | .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ }, |
| | 29309 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29310 | .{ ._, ._, .bzhi, .dst0q, .dst0q, .tmp0q, ._ }, |
| | 29311 | } }, |
| | 29312 | }, .{ |
| | 29313 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 29314 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| | 29315 | .patterns = &.{ |
| | 29316 | .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } }, |
| | 29317 | }, |
| | 29318 | .extra_temps = .{ |
| | 29319 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 29320 | .unused, |
| | 29321 | .unused, |
| | 29322 | .unused, |
| | 29323 | .unused, |
| | 29324 | .unused, |
| | 29325 | .unused, |
| | 29326 | .unused, |
| | 29327 | .unused, |
| | 29328 | .unused, |
| | 29329 | .unused, |
| | 29330 | }, |
| | 29331 | .dst_temps = .{ .{ .ref = .src0 }, .{ .ref = .src1 } }, |
| | 29332 | .clobbers = .{ .eflags = true }, |
| | 29333 | .each = .{ .once = &.{ |
| | 29334 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size), ._, ._ }, |
| | 29335 | .{ ._, ._, .sub, .dst0q, .src1q, ._, ._ }, |
| | 29336 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29337 | .{ ._, ._, .bzhi, .dst0q, .dst0q, .tmp0q, ._ }, |
| | 29338 | } }, |
| | 29339 | }, .{ |
| | 29340 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29341 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| | 29342 | .patterns = &.{ |
| | 29343 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| | 29344 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29345 | .{ .src = .{ .to_mut_gpr, .immut_gpr, .none } }, |
| | 29346 | }, |
| | 29347 | .dst_temps = .{ .{ .rc = .general_purpose }, .{ .rc = .general_purpose } }, |
| | 29348 | .clobbers = .{ .eflags = true }, |
| | 29349 | .each = .{ .once = &.{ |
| | 29350 | .{ ._, ._, .xor, .dst1d, .dst1d, ._, ._ }, |
| | 29351 | .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 29352 | .{ ._, ._, .sub, .src0q, .src1q, ._, ._ }, |
| | 29353 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29354 | .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ }, |
| | 29355 | } }, |
| | 29356 | }, .{ |
| | 29357 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29358 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| | 29359 | .patterns = &.{ |
| | 29360 | .{ .src = .{ .to_mut_gpr, .to_mut_gpr, .none } }, |
| | 29361 | }, |
| | 29362 | .dst_temps = .{ .{ .rc = .general_purpose }, .{ .ref = .src1 } }, |
| | 29363 | .clobbers = .{ .eflags = true }, |
| | 29364 | .each = .{ .once = &.{ |
| | 29365 | .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 29366 | .{ ._, ._, .sub, .src0q, .src1q, ._, ._ }, |
| | 29367 | .{ ._, ._c, .set, .dst1b, ._, ._, ._ }, |
| | 29368 | .{ ._, ._, .@"and", .dst0q, .src0q, ._, ._ }, |
| | 29369 | } }, |
| | 29370 | }, .{ |
| | 29371 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29372 | .src_constraints = .{ |
| | 29373 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 29374 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 29375 | .any, |
| | 29376 | }, |
| | 29377 | .patterns = &.{ |
| | 29378 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29379 | }, |
| | 29380 | .extra_temps = .{ |
| | 29381 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29382 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29383 | .unused, |
| | 29384 | .unused, |
| | 29385 | .unused, |
| | 29386 | .unused, |
| | 29387 | .unused, |
| | 29388 | .unused, |
| | 29389 | .unused, |
| | 29390 | .unused, |
| | 29391 | .unused, |
| | 29392 | }, |
| | 29393 | .dst_temps = .{ .mem, .none }, |
| | 29394 | .clobbers = .{ .eflags = true }, |
| | 29395 | .each = .{ .once = &.{ |
| | 29396 | .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ }, |
| | 29397 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29398 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29399 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29400 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 29401 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29402 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29403 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| | 29404 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ }, |
| | 29405 | .{ ._, ._o, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ }, |
| | 29406 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 29407 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 29408 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29409 | } }, |
| | 29410 | }, .{ |
| | 29411 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29412 | .src_constraints = .{ |
| | 29413 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 29414 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 29415 | .any, |
| | 29416 | }, |
| | 29417 | .patterns = &.{ |
| | 29418 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29419 | }, |
| | 29420 | .extra_temps = .{ |
| | 29421 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29422 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29423 | .unused, |
| | 29424 | .unused, |
| | 29425 | .unused, |
| | 29426 | .unused, |
| | 29427 | .unused, |
| | 29428 | .unused, |
| | 29429 | .unused, |
| | 29430 | .unused, |
| | 29431 | .unused, |
| | 29432 | }, |
| | 29433 | .dst_temps = .{ .mem, .{ .cc = .c } }, |
| | 29434 | .clobbers = .{ .eflags = true }, |
| | 29435 | .each = .{ .once = &.{ |
| | 29436 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 29437 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29438 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29439 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29440 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29441 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29442 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29443 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 29444 | } }, |
| | 29445 | }, .{ |
| | 29446 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29447 | .src_constraints = .{ |
| | 29448 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 29449 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 29450 | .any, |
| | 29451 | }, |
| | 29452 | .patterns = &.{ |
| | 29453 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29454 | }, |
| | 29455 | .extra_temps = .{ |
| | 29456 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29457 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29458 | .unused, |
| | 29459 | .unused, |
| | 29460 | .unused, |
| | 29461 | .unused, |
| | 29462 | .unused, |
| | 29463 | .unused, |
| | 29464 | .unused, |
| | 29465 | .unused, |
| | 29466 | .unused, |
| | 29467 | }, |
| | 29468 | .dst_temps = .{ .mem, .{ .cc = .o } }, |
| | 29469 | .clobbers = .{ .eflags = true }, |
| | 29470 | .each = .{ .once = &.{ |
| | 29471 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 29472 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29473 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29474 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29475 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29476 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29477 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29478 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 29479 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 29480 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29481 | } }, |
| | 29482 | }, .{ |
| | 29483 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29484 | .src_constraints = .{ |
| | 29485 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 29486 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 29487 | .any, |
| | 29488 | }, |
| | 29489 | .patterns = &.{ |
| | 29490 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29491 | }, |
| | 29492 | .extra_temps = .{ |
| | 29493 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29494 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29495 | .unused, |
| | 29496 | .unused, |
| | 29497 | .unused, |
| | 29498 | .unused, |
| | 29499 | .unused, |
| | 29500 | .unused, |
| | 29501 | .unused, |
| | 29502 | .unused, |
| | 29503 | .unused, |
| | 29504 | }, |
| | 29505 | .dst_temps = .{ .mem, .{ .cc = .c } }, |
| | 29506 | .clobbers = .{ .eflags = true }, |
| | 29507 | .each = .{ .once = &.{ |
| | 29508 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| | 29509 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29510 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| | 29511 | .{ ._, ._, .sbb, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| | 29512 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_src0_size), .tmp1q, ._, ._ }, |
| | 29513 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29514 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29515 | } }, |
| | 29516 | }, .{ |
| | 29517 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29518 | .src_constraints = .{ |
| | 29519 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 29520 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 29521 | .any, |
| | 29522 | }, |
| | 29523 | .patterns = &.{ |
| | 29524 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29525 | }, |
| | 29526 | .extra_temps = .{ |
| | 29527 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29528 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29529 | .unused, |
| | 29530 | .unused, |
| | 29531 | .unused, |
| | 29532 | .unused, |
| | 29533 | .unused, |
| | 29534 | .unused, |
| | 29535 | .unused, |
| | 29536 | .unused, |
| | 29537 | .unused, |
| | 29538 | }, |
| | 29539 | .dst_temps = .{ .mem, .{ .cc = .o } }, |
| | 29540 | .clobbers = .{ .eflags = true }, |
| | 29541 | .each = .{ .once = &.{ |
| | 29542 | .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ }, |
| | 29543 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29544 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29545 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29546 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 29547 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29548 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29549 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| | 29550 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ }, |
| | 29551 | .{ ._, ._l, .ro, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 29552 | .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ }, |
| | 29553 | .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 29554 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 29555 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 29556 | .{ ._, ._r, .ro, .tmp0q, .ui(1), ._, ._ }, |
| | 29557 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29558 | } }, |
| | 29559 | }, .{ |
| | 29560 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 29561 | .src_constraints = .{ |
| | 29562 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 29563 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 29564 | .any, |
| | 29565 | }, |
| | 29566 | .patterns = &.{ |
| | 29567 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29568 | }, |
| | 29569 | .extra_temps = .{ |
| | 29570 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29571 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29572 | .unused, |
| | 29573 | .unused, |
| | 29574 | .unused, |
| | 29575 | .unused, |
| | 29576 | .unused, |
| | 29577 | .unused, |
| | 29578 | .unused, |
| | 29579 | .unused, |
| | 29580 | .unused, |
| | 29581 | }, |
| | 29582 | .dst_temps = .{ .mem, .none }, |
| | 29583 | .clobbers = .{ .eflags = true }, |
| | 29584 | .each = .{ .once = &.{ |
| | 29585 | .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ }, |
| | 29586 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29587 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29588 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29589 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 29590 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29591 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29592 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| | 29593 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 29594 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ }, |
| | 29595 | .{ ._, ._c, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ }, |
| | 29596 | .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ }, |
| | 29597 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 29598 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ }, |
| | 29599 | } }, |
| | 29600 | }, .{ |
| | 29601 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29602 | .src_constraints = .{ |
| | 29603 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 29604 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 29605 | .any, |
| | 29606 | }, |
| | 29607 | .patterns = &.{ |
| | 29608 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29609 | }, |
| | 29610 | .extra_temps = .{ |
| | 29611 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29612 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29613 | .unused, |
| | 29614 | .unused, |
| | 29615 | .unused, |
| | 29616 | .unused, |
| | 29617 | .unused, |
| | 29618 | .unused, |
| | 29619 | .unused, |
| | 29620 | .unused, |
| | 29621 | .unused, |
| | 29622 | }, |
| | 29623 | .dst_temps = .{ .mem, .none }, |
| | 29624 | .clobbers = .{ .eflags = true }, |
| | 29625 | .each = .{ .once = &.{ |
| | 29626 | .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ }, |
| | 29627 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29628 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29629 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| | 29630 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -16), .tmp1q, ._, ._ }, |
| | 29631 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29632 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29633 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| | 29634 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 29635 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ }, |
| | 29636 | .{ ._, ._c, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ }, |
| | 29637 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 29638 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 29639 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ }, |
| | 29640 | } }, |
| | 29641 | }, .{ |
| | 29642 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29643 | .src_constraints = .{ |
| | 29644 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 29645 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 29646 | .any, |
| | 29647 | }, |
| | 29648 | .patterns = &.{ |
| | 29649 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29650 | }, |
| | 29651 | .extra_temps = .{ |
| | 29652 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29653 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29654 | .unused, |
| | 29655 | .unused, |
| | 29656 | .unused, |
| | 29657 | .unused, |
| | 29658 | .unused, |
| | 29659 | .unused, |
| | 29660 | .unused, |
| | 29661 | .unused, |
| | 29662 | .unused, |
| | 29663 | }, |
| | 29664 | .dst_temps = .{ .mem, .{ .cc = .o } }, |
| | 29665 | .clobbers = .{ .eflags = true }, |
| | 29666 | .each = .{ .once = &.{ |
| | 29667 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 29668 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29669 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29670 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29671 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29672 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29673 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29674 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 29675 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 29676 | .{ ._, ._l, .ro, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 29677 | .{ ._, ._, .mov, .tmp0q, .tmp1q, ._, ._ }, |
| | 29678 | .{ ._, ._r, .sa, .tmp1q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 29679 | .{ ._, ._r, .ro, .tmp0q, .ui(1), ._, ._ }, |
| | 29680 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29681 | } }, |
| | 29682 | }, .{ |
| | 29683 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 29684 | .src_constraints = .{ |
| | 29685 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 29686 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 29687 | .any, |
| | 29688 | }, |
| | 29689 | .patterns = &.{ |
| | 29690 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29691 | }, |
| | 29692 | .extra_temps = .{ |
| | 29693 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29694 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29695 | .unused, |
| | 29696 | .unused, |
| | 29697 | .unused, |
| | 29698 | .unused, |
| | 29699 | .unused, |
| | 29700 | .unused, |
| | 29701 | .unused, |
| | 29702 | .unused, |
| | 29703 | .unused, |
| | 29704 | }, |
| | 29705 | .dst_temps = .{ .mem, .none }, |
| | 29706 | .clobbers = .{ .eflags = true }, |
| | 29707 | .each = .{ .once = &.{ |
| | 29708 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 29709 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29710 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29711 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29712 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29713 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29714 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29715 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 29716 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 29717 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 29718 | .{ ._, ._c, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ }, |
| | 29719 | .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ }, |
| | 29720 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 29721 | } }, |
| | 29722 | }, .{ |
| | 29723 | .required_features = .{ .@"64bit", null, null, null }, |
| | 29724 | .src_constraints = .{ |
| | 29725 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 29726 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 29727 | .any, |
| | 29728 | }, |
| | 29729 | .patterns = &.{ |
| | 29730 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 29731 | }, |
| | 29732 | .extra_temps = .{ |
| | 29733 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 29734 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 29735 | .unused, |
| | 29736 | .unused, |
| | 29737 | .unused, |
| | 29738 | .unused, |
| | 29739 | .unused, |
| | 29740 | .unused, |
| | 29741 | .unused, |
| | 29742 | .unused, |
| | 29743 | .unused, |
| | 29744 | }, |
| | 29745 | .dst_temps = .{ .mem, .none }, |
| | 29746 | .clobbers = .{ .eflags = true }, |
| | 29747 | .each = .{ .once = &.{ |
| | 29748 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 29749 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| | 29750 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29751 | .{ ._, ._, .sbb, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 29752 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp1q, ._, ._ }, |
| | 29753 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| | 29754 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 29755 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 29756 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 29757 | .{ ._, ._, .sbb, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 29758 | .{ ._, ._c, .set, .mema(.dst0b, .add_src0_size), ._, ._, ._ }, |
| | 29759 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 29760 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 29761 | } }, |
| | 29762 | } }) catch |err| switch (err) { |
| | 29763 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| | 29764 | @tagName(air_tag), |
| | 29765 | ty_pl.ty.toType().fmt(pt), |
| | 29766 | ops[0].tracking(cg), |
| | 29767 | ops[1].tracking(cg), |
| | 29768 | }), |
| | 29769 | else => |e| return e, |
| | 29770 | }; |
| | 29771 | try res[0].withOverflow(&res[1], cg); |
| | 29772 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| | 29773 | }, |
| | 29774 | .mul_with_overflow => |air_tag| if (use_old) try cg.airMulWithOverflow(inst) else fallback: { |
| | 29775 | const ty_pl = air_datas[@intFromEnum(inst)].ty_pl; |
| | 29776 | const bin_op = cg.air.extraData(Air.Bin, ty_pl.payload).data; |
| | 29777 | if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airMulWithOverflow(inst); |
| | 29778 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| | 29779 | var res: [2]Temp = undefined; |
| | 29780 | cg.select(&res, &.{ ty_pl.ty.toType(), .u1 }, &ops, comptime &.{ .{ |
| | 29781 | .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any }, |
| | 29782 | .patterns = &.{ |
| | 29783 | .{ .src = .{ .{ .to_reg = .al }, .mem, .none } }, |
| | 29784 | .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } }, |
| | 29785 | .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } }, |
| | 29786 | }, |
| | 29787 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 29788 | .clobbers = .{ .eflags = true }, |
| | 29789 | .each = .{ .once = &.{ |
| | 29790 | .{ ._, .i_, .mul, .src1b, ._, ._, ._ }, |
| | 29791 | } }, |
| | 29792 | }, .{ |
| | 29793 | .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .exact_unsigned_int = 8 }, .any }, |
| | 29794 | .patterns = &.{ |
| | 29795 | .{ .src = .{ .{ .to_reg = .al }, .mem, .none } }, |
| | 29796 | .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } }, |
| | 29797 | .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } }, |
| | 29798 | }, |
| | 29799 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 29800 | .clobbers = .{ .eflags = true }, |
| | 29801 | .each = .{ .once = &.{ |
| | 29802 | .{ ._, ._, .mul, .src1b, ._, ._, ._ }, |
| | 29803 | } }, |
| | 29804 | }, .{ |
| | 29805 | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any }, |
| | 29806 | .patterns = &.{ |
| | 29807 | .{ .src = .{ .{ .to_reg = .al }, .mem, .none } }, |
| | 29808 | .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } }, |
| | 29809 | .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } }, |
| | 29810 | }, |
| | 29811 | .extra_temps = .{ |
| | 29812 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 29813 | .unused, |
| | 29814 | .unused, |
| | 29815 | .unused, |
| | 29816 | .unused, |
| | 29817 | .unused, |
| | 29818 | .unused, |
| | 29819 | .unused, |
| | 29820 | .unused, |
| | 29821 | .unused, |
| | 29822 | .unused, |
| | 29823 | }, |
| | 29824 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .ne } }, |
| | 29825 | .clobbers = .{ .eflags = true }, |
| | 29826 | .each = .{ .once = &.{ |
| | 29827 | .{ ._, .i_, .mul, .src1b, ._, ._, ._ }, |
| | 29828 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 29829 | .{ ._, ._l, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29830 | .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29831 | .{ ._, ._, .cmp, .dst0w, .tmp0w, ._, ._ }, |
| | 29832 | } }, |
| | 29833 | }, .{ |
| | 29834 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| | 29835 | .patterns = &.{ |
| | 29836 | .{ .src = .{ .{ .to_reg = .al }, .mem, .none } }, |
| | 29837 | .{ .src = .{ .mem, .{ .to_reg = .al }, .none }, .commute = .{ 0, 1 } }, |
| | 29838 | .{ .src = .{ .{ .to_reg = .al }, .to_gpr, .none } }, |
| | 29839 | }, |
| | 29840 | .extra_temps = .{ |
| | 29841 | .{ .type = .i16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 29842 | .unused, |
| | 29843 | .unused, |
| | 29844 | .unused, |
| | 29845 | .unused, |
| | 29846 | .unused, |
| | 29847 | .unused, |
| | 29848 | .unused, |
| | 29849 | .unused, |
| | 29850 | .unused, |
| | 29851 | .unused, |
| | 29852 | }, |
| | 29853 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .nbe } }, |
| | 29854 | .clobbers = .{ .eflags = true }, |
| | 29855 | .each = .{ .once = &.{ |
| | 29856 | .{ ._, ._, .mul, .src1b, ._, ._, ._ }, |
| | 29857 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| | 29858 | .{ ._, ._, .@"and", .dst0b, .ua(.src0, .add_umax), ._, ._ }, |
| | 29859 | .{ ._, ._, .cmp, .tmp0w, .ua(.src0, .add_umax), ._, ._ }, |
| | 29860 | } }, |
| | 29861 | }, .{ |
| | 29862 | .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any }, |
| | 29863 | .patterns = &.{ |
| | 29864 | .{ .src = .{ .mem, .imm16, .none } }, |
| | 29865 | .{ .src = .{ .imm16, .mem, .none }, .commute = .{ 0, 1 } }, |
| | 29866 | .{ .src = .{ .to_gpr, .imm16, .none } }, |
| | 29867 | .{ .src = .{ .imm16, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 29868 | }, |
| | 29869 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .{ .cc = .c } }, |
| | 29870 | .clobbers = .{ .eflags = true }, |
| | 29871 | .each = .{ .once = &.{ |
| | 29872 | .{ ._, .i_, .mul, .dst0w, .src0w, .src1w, ._ }, |
| | 29873 | } }, |
| | 29874 | }, .{ |
| | 29875 | .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any }, |
| | 29876 | .patterns = &.{ |
| | 29877 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 29878 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 29879 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 29880 | }, |
| | 29881 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 29882 | .clobbers = .{ .eflags = true }, |
| | 29883 | .each = .{ .once = &.{ |
| | 29884 | .{ ._, .i_, .mul, .dst0w, .src1w, ._, ._ }, |
| | 29885 | } }, |
| | 29886 | }, .{ |
| | 29887 | .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .{ .exact_unsigned_int = 16 }, .any }, |
| | 29888 | .patterns = &.{ |
| | 29889 | .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } }, |
| | 29890 | .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } }, |
| | 29891 | .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } }, |
| | 29892 | }, |
| | 29893 | .extra_temps = .{ |
| | 29894 | .{ .type = .u16, .kind = .{ .reg = .dx } }, |
| | 29895 | .unused, |
| | 29896 | .unused, |
| | 29897 | .unused, |
| | 29898 | .unused, |
| | 29899 | .unused, |
| | 29900 | .unused, |
| | 29901 | .unused, |
| | 29902 | .unused, |
| | 29903 | .unused, |
| | 29904 | .unused, |
| | 29905 | }, |
| | 29906 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 29907 | .clobbers = .{ .eflags = true }, |
| | 29908 | .each = .{ .once = &.{ |
| | 29909 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 29910 | .{ ._, ._, .mul, .src1w, ._, ._, ._ }, |
| | 29911 | } }, |
| | 29912 | }, .{ |
| | 29913 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| | 29914 | .patterns = &.{ |
| | 29915 | .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } }, |
| | 29916 | .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } }, |
| | 29917 | .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } }, |
| | 29918 | }, |
| | 29919 | .extra_temps = .{ |
| | 29920 | .{ .type = .i32, .kind = .{ .reg = .edx } }, |
| | 29921 | .unused, |
| | 29922 | .unused, |
| | 29923 | .unused, |
| | 29924 | .unused, |
| | 29925 | .unused, |
| | 29926 | .unused, |
| | 29927 | .unused, |
| | 29928 | .unused, |
| | 29929 | .unused, |
| | 29930 | .unused, |
| | 29931 | }, |
| | 29932 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .ne } }, |
| | 29933 | .clobbers = .{ .eflags = true }, |
| | 29934 | .each = .{ .once = &.{ |
| | 29935 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 29936 | .{ ._, .i_, .mul, .src1w, ._, ._, ._ }, |
| | 29937 | .{ ._, ._l, .sh, .tmp0d, .ui(16), ._, ._ }, |
| | 29938 | .{ ._, ._, .mov, .tmp0w, .dst0w, ._, ._ }, |
| | 29939 | .{ ._, ._l, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29940 | .{ ._, ._r, .sa, .dst0d, .uia(32, .src0, .sub_bit_size), ._, ._ }, |
| | 29941 | .{ ._, ._, .cmp, .dst0d, .tmp0d, ._, ._ }, |
| | 29942 | } }, |
| | 29943 | }, .{ |
| | 29944 | .required_features = .{ .fast_imm16, null, null, null }, |
| | 29945 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| | 29946 | .patterns = &.{ |
| | 29947 | .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } }, |
| | 29948 | .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } }, |
| | 29949 | .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } }, |
| | 29950 | }, |
| | 29951 | .extra_temps = .{ |
| | 29952 | .{ .type = .u16, .kind = .{ .reg = .dx } }, |
| | 29953 | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 29954 | .unused, |
| | 29955 | .unused, |
| | 29956 | .unused, |
| | 29957 | .unused, |
| | 29958 | .unused, |
| | 29959 | .unused, |
| | 29960 | .unused, |
| | 29961 | .unused, |
| | 29962 | .unused, |
| | 29963 | }, |
| | 29964 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .nz } }, |
| | 29965 | .clobbers = .{ .eflags = true }, |
| | 29966 | .each = .{ .once = &.{ |
| | 29967 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 29968 | .{ ._, ._, .mul, .src1w, ._, ._, ._ }, |
| | 29969 | .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ }, |
| | 29970 | .{ ._, ._, .@"and", .dst0w, .ua(.src0, .add_umax), ._, ._ }, |
| | 29971 | .{ ._, ._, .@"and", .tmp1w, .uia(std.math.maxInt(u16), .src0, .sub_umax), ._, ._ }, |
| | 29972 | .{ ._, ._, .@"or", .tmp1w, .tmp0w, ._, ._ }, |
| | 29973 | } }, |
| | 29974 | }, .{ |
| | 29975 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| | 29976 | .patterns = &.{ |
| | 29977 | .{ .src = .{ .{ .to_reg = .ax }, .mem, .none } }, |
| | 29978 | .{ .src = .{ .mem, .{ .to_reg = .ax }, .none }, .commute = .{ 0, 1 } }, |
| | 29979 | .{ .src = .{ .{ .to_reg = .ax }, .to_gpr, .none } }, |
| | 29980 | }, |
| | 29981 | .extra_temps = .{ |
| | 29982 | .{ .type = .u16, .kind = .{ .reg = .dx } }, |
| | 29983 | .{ .type = .u16, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 29984 | .unused, |
| | 29985 | .unused, |
| | 29986 | .unused, |
| | 29987 | .unused, |
| | 29988 | .unused, |
| | 29989 | .unused, |
| | 29990 | .unused, |
| | 29991 | .unused, |
| | 29992 | .unused, |
| | 29993 | }, |
| | 29994 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .nz } }, |
| | 29995 | .clobbers = .{ .eflags = true }, |
| | 29996 | .each = .{ .once = &.{ |
| | 29997 | .{ ._, ._, .xor, .tmp0d, .tmp0d, ._, ._ }, |
| | 29998 | .{ ._, ._, .mul, .src1w, ._, ._, ._ }, |
| | 29999 | .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ }, |
| | 30000 | .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| | 30001 | .{ ._, ._, .@"and", .tmp1d, .uia(std.math.maxInt(u16), .src0, .sub_umax), ._, ._ }, |
| | 30002 | .{ ._, ._, .@"or", .tmp1d, .tmp0d, ._, ._ }, |
| | 30003 | } }, |
| | 30004 | }, .{ |
| | 30005 | .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any }, |
| | 30006 | .patterns = &.{ |
| | 30007 | .{ .src = .{ .mem, .imm32, .none } }, |
| | 30008 | .{ .src = .{ .imm32, .mem, .none }, .commute = .{ 0, 1 } }, |
| | 30009 | .{ .src = .{ .to_gpr, .imm32, .none } }, |
| | 30010 | .{ .src = .{ .imm32, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 30011 | }, |
| | 30012 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .{ .cc = .c } }, |
| | 30013 | .clobbers = .{ .eflags = true }, |
| | 30014 | .each = .{ .once = &.{ |
| | 30015 | .{ ._, .i_, .mul, .dst0d, .src0d, .src1d, ._ }, |
| | 30016 | } }, |
| | 30017 | }, .{ |
| | 30018 | .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any }, |
| | 30019 | .patterns = &.{ |
| | 30020 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 30021 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 30022 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 30023 | }, |
| | 30024 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 30025 | .clobbers = .{ .eflags = true }, |
| | 30026 | .each = .{ .once = &.{ |
| | 30027 | .{ ._, .i_, .mul, .dst0d, .src1d, ._, ._ }, |
| | 30028 | } }, |
| | 30029 | }, .{ |
| | 30030 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .{ .exact_unsigned_int = 32 }, .any }, |
| | 30031 | .patterns = &.{ |
| | 30032 | .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } }, |
| | 30033 | .{ .src = .{ .mem, .{ .to_reg = .eax }, .none }, .commute = .{ 0, 1 } }, |
| | 30034 | .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } }, |
| | 30035 | }, |
| | 30036 | .extra_temps = .{ |
| | 30037 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| | 30038 | .unused, |
| | 30039 | .unused, |
| | 30040 | .unused, |
| | 30041 | .unused, |
| | 30042 | .unused, |
| | 30043 | .unused, |
| | 30044 | .unused, |
| | 30045 | .unused, |
| | 30046 | .unused, |
| | 30047 | .unused, |
| | 30048 | }, |
| | 30049 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 30050 | .clobbers = .{ .eflags = true }, |
| | 30051 | .each = .{ .once = &.{ |
| | 30052 | .{ ._, ._, .mul, .src1d, ._, ._, ._ }, |
| | 30053 | } }, |
| | 30054 | }, .{ |
| | 30055 | .required_features = .{ .@"64bit", null, null, null }, |
| | 30056 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| | 30057 | .patterns = &.{ |
| | 30058 | .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } }, |
| | 30059 | .{ .src = .{ .mem, .{ .to_reg = .eax }, .none }, .commute = .{ 0, 1 } }, |
| | 30060 | .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } }, |
| | 30061 | }, |
| | 30062 | .extra_temps = .{ |
| | 30063 | .{ .type = .i32, .kind = .{ .reg = .edx } }, |
| | 30064 | .unused, |
| | 30065 | .unused, |
| | 30066 | .unused, |
| | 30067 | .unused, |
| | 30068 | .unused, |
| | 30069 | .unused, |
| | 30070 | .unused, |
| | 30071 | .unused, |
| | 30072 | .unused, |
| | 30073 | .unused, |
| | 30074 | }, |
| | 30075 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .ne } }, |
| | 30076 | .clobbers = .{ .eflags = true }, |
| | 30077 | .each = .{ .once = &.{ |
| | 30078 | .{ ._, .i_, .mul, .src1d, ._, ._, ._ }, |
| | 30079 | .{ ._, ._l, .sh, .tmp0q, .ui(32), ._, ._ }, |
| | 30080 | .{ ._, ._, .@"or", .tmp0q, .dst0q, ._, ._ }, |
| | 30081 | .{ ._, ._l, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ }, |
| | 30082 | .{ ._, ._r, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ }, |
| | 30083 | .{ ._, ._, .cmp, .dst0q, .tmp0q, ._, ._ }, |
| | 30084 | } }, |
| | 30085 | }, .{ |
| | 30086 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| | 30087 | .patterns = &.{ |
| | 30088 | .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } }, |
| | 30089 | .{ .src = .{ .mem, .{ .to_reg = .eax }, .none }, .commute = .{ 0, 1 } }, |
| | 30090 | .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } }, |
| | 30091 | }, |
| | 30092 | .extra_temps = .{ |
| | 30093 | .{ .type = .u32, .kind = .{ .ref = .src0 } }, |
| | 30094 | .{ .type = .u32, .kind = .{ .reg = .edx } }, |
| | 30095 | .unused, |
| | 30096 | .unused, |
| | 30097 | .unused, |
| | 30098 | .unused, |
| | 30099 | .unused, |
| | 30100 | .unused, |
| | 30101 | .unused, |
| | 30102 | .unused, |
| | 30103 | .unused, |
| | 30104 | }, |
| | 30105 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } }, .{ .cc = .nz } }, |
| | 30106 | .clobbers = .{ .eflags = true }, |
| | 30107 | .each = .{ .once = &.{ |
| | 30108 | .{ ._, ._, .mul, .src1d, ._, ._, ._ }, |
| | 30109 | .{ ._, ._, .mov, .dst0d, .tmp0d, ._, ._ }, |
| | 30110 | .{ ._, ._r, .sh, .tmp0d, .sa(.src0, .add_bit_size), ._, ._ }, |
| | 30111 | .{ ._, ._, .@"and", .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| | 30112 | .{ ._, ._, .@"or", .tmp0d, .tmp1d, ._, ._ }, |
| | 30113 | } }, |
| | 30114 | }, .{ |
| | 30115 | .required_features = .{ .@"64bit", null, null, null }, |
| | 30116 | .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any }, |
| | 30117 | .patterns = &.{ |
| | 30118 | .{ .src = .{ .mem, .simm32, .none } }, |
| | 30119 | .{ .src = .{ .simm32, .mem, .none }, .commute = .{ 0, 1 } }, |
| | 30120 | .{ .src = .{ .to_gpr, .simm32, .none } }, |
| | 30121 | .{ .src = .{ .simm32, .to_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 30122 | }, |
| | 30123 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src0, .rc = .general_purpose } }, .{ .cc = .c } }, |
| | 30124 | .clobbers = .{ .eflags = true }, |
| | 30125 | .each = .{ .once = &.{ |
| | 30126 | .{ ._, .i_, .mul, .dst0q, .src0q, .src1d, ._ }, |
| | 30127 | } }, |
| | 30128 | }, .{ |
| | 30129 | .required_features = .{ .@"64bit", null, null, null }, |
| | 30130 | .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any }, |
| | 30131 | .patterns = &.{ |
| | 30132 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| | 30133 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| | 30134 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| | 30135 | }, |
| | 30136 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 30137 | .clobbers = .{ .eflags = true }, |
| | 30138 | .each = .{ .once = &.{ |
| | 30139 | .{ ._, .i_, .mul, .dst0q, .src1q, ._, ._ }, |
| | 30140 | } }, |
| | 30141 | }, .{ |
| | 30142 | .required_features = .{ .@"64bit", null, null, null }, |
| | 30143 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .exact_unsigned_int = 64 }, .any }, |
| | 30144 | .patterns = &.{ |
| | 30145 | .{ .src = .{ .{ .to_reg = .eax }, .mem, .none } }, |
| | 30146 | .{ .src = .{ .mem, .{ .to_reg = .eax }, .none }, .commute = .{ 0, 1 } }, |
| | 30147 | .{ .src = .{ .{ .to_reg = .eax }, .to_gpr, .none } }, |
| | 30148 | }, |
| | 30149 | .extra_temps = .{ |
| | 30150 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 30151 | .unused, |
| | 30152 | .unused, |
| | 30153 | .unused, |
| | 30154 | .unused, |
| | 30155 | .unused, |
| | 30156 | .unused, |
| | 30157 | .unused, |
| | 30158 | .unused, |
| | 30159 | .unused, |
| | 30160 | .unused, |
| | 30161 | }, |
| | 30162 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .c } }, |
| | 30163 | .clobbers = .{ .eflags = true }, |
| | 30164 | .each = .{ .once = &.{ |
| | 30165 | .{ ._, ._, .mul, .src1q, ._, ._, ._ }, |
| | 30166 | } }, |
| | 30167 | }, .{ |
| | 30168 | .required_features = .{ .@"64bit", null, null, null }, |
| | 30169 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| | 30170 | .patterns = &.{ |
| | 30171 | .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } }, |
| | 30172 | .{ .src = .{ .mem, .{ .to_reg = .rax }, .none }, .commute = .{ 0, 1 } }, |
| | 30173 | .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } }, |
| | 30174 | }, |
| | 30175 | .extra_temps = .{ |
| | 30176 | .{ .type = .i64, .kind = .{ .reg = .rdx } }, |
| | 30177 | .{ .type = .i64, .kind = .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } } }, |
| | 30178 | .unused, |
| | 30179 | .unused, |
| | 30180 | .unused, |
| | 30181 | .unused, |
| | 30182 | .unused, |
| | 30183 | .unused, |
| | 30184 | .unused, |
| | 30185 | .unused, |
| | 30186 | .unused, |
| | 30187 | }, |
| | 30188 | .dst_temps = .{ .{ .ref = .src0 }, .{ .cc = .nz } }, |
| | 30189 | .clobbers = .{ .eflags = true }, |
| | 30190 | .each = .{ .once = &.{ |
| | 30191 | .{ ._, .i_, .mul, .src1q, ._, ._, ._ }, |
| | 30192 | .{ ._, ._, .sbb, .tmp0d, .tmp0d, ._, ._ }, |
| | 30193 | .{ ._, ._, .mov, .tmp1q, .dst0q, ._, ._ }, |
| | 30194 | .{ ._, ._l, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ }, |
| | 30195 | .{ ._, ._r, .sa, .dst0q, .uia(64, .src0, .sub_bit_size), ._, ._ }, |
| | 30196 | .{ ._, ._, .xor, .tmp1q, .dst0q, ._, ._ }, |
| | 30197 | .{ ._, ._, .@"or", .tmp1q, .tmp0q, ._, ._ }, |
| | 30198 | } }, |
| | 30199 | }, .{ |
| | 30200 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 30201 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| | 30202 | .patterns = &.{ |
| | 30203 | .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } }, |
| | 30204 | .{ .src = .{ .mem, .{ .to_reg = .rax }, .none }, .commute = .{ 0, 1 } }, |
| | 30205 | .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } }, |
| | 30206 | }, |
| | 30207 | .extra_temps = .{ |
| | 30208 | .{ .type = .u64, .kind = .{ .ref = .src0 } }, |
| | 30209 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 30210 | .unused, |
| | 30211 | .unused, |
| | 30212 | .unused, |
| | 30213 | .unused, |
| | 30214 | .unused, |
| | 30215 | .unused, |
| | 30216 | .unused, |
| | 30217 | .unused, |
| | 30218 | .unused, |
| | 30219 | }, |
| | 30220 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } }, .{ .cc = .nz } }, |
| | 30221 | .clobbers = .{ .eflags = true }, |
| | 30222 | .each = .{ .once = &.{ |
| | 30223 | .{ ._, ._, .mul, .src1q, ._, ._, ._ }, |
| | 30224 | .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_bit_size), ._, ._ }, |
| | 30225 | .{ ._, ._, .bzhi, .dst0q, .tmp0q, .dst0q, ._ }, |
| | 30226 | .{ ._, ._, .xor, .tmp0q, .dst0q, ._, ._ }, |
| | 30227 | .{ ._, ._, .@"or", .tmp0q, .tmp1q, ._, ._ }, |
| | 30228 | } }, |
| | 30229 | }, .{ |
| | 30230 | .required_features = .{ .@"64bit", null, null, null }, |
| | 30231 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| | 30232 | .patterns = &.{ |
| | 30233 | .{ .src = .{ .{ .to_reg = .rax }, .mem, .none } }, |
| | 30234 | .{ .src = .{ .mem, .{ .to_reg = .rax }, .none }, .commute = .{ 0, 1 } }, |
| | 30235 | .{ .src = .{ .{ .to_reg = .rax }, .to_gpr, .none } }, |
| | 30236 | }, |
| | 30237 | .extra_temps = .{ |
| | 30238 | .{ .type = .u64, .kind = .{ .ref = .src0 } }, |
| | 30239 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 30240 | .unused, |
| | 30241 | .unused, |
| | 30242 | .unused, |
| | 30243 | .unused, |
| | 30244 | .unused, |
| | 30245 | .unused, |
| | 30246 | .unused, |
| | 30247 | .unused, |
| | 30248 | .unused, |
| | 30249 | }, |
| | 30250 | .dst_temps = .{ .{ .mut_rc = .{ .ref = .src1, .rc = .general_purpose } }, .{ .cc = .nz } }, |
| | 30251 | .clobbers = .{ .eflags = true }, |
| | 30252 | .each = .{ .once = &.{ |
| | 30253 | .{ ._, ._, .mul, .src1q, ._, ._, ._ }, |
| | 30254 | .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 30255 | .{ ._, ._, .@"and", .dst0q, .tmp0q, ._, ._ }, |
| | 30256 | .{ ._, ._, .xor, .tmp0q, .dst0q, ._, ._ }, |
| | 30257 | .{ ._, ._, .@"or", .tmp0q, .tmp1q, ._, ._ }, |
| | 30258 | } }, |
| | 30259 | }, .{ |
| | 30260 | .required_features = .{ .@"64bit", .cmov, .slow_incdec, null }, |
| | 30261 | .src_constraints = .{ |
| | 30262 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 30263 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 30264 | .any, |
| | 30265 | }, |
| | 30266 | .patterns = &.{ |
| | 30267 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 30268 | }, |
| | 30269 | .extra_temps = .{ |
| | 30270 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 30271 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30272 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 30273 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30274 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30275 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 30276 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30277 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 30278 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30279 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 30280 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 30281 | }, |
| | 30282 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 30283 | .clobbers = .{ .eflags = true }, |
| | 30284 | .each = .{ .once = &.{ |
| | 30285 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 30286 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 30287 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 30288 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 30289 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 30290 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 30291 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 30292 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 30293 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 30294 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30295 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 30296 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 30297 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 30298 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 30299 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 30300 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 30301 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 30302 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 30303 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 30304 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 30305 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 30306 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 30307 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 30308 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 30309 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 30310 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 30311 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 30312 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 30313 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 30314 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 30315 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 30316 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 30317 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 30318 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 30319 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 30320 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 30321 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 30322 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 30323 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 30324 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 30325 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 30326 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30327 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 30328 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 30329 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 30330 | .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 30331 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 30332 | .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ }, |
| | 30333 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 30334 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 30335 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 30336 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 30337 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 30338 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30339 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 30340 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 30341 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 30342 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 30343 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 30344 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 30345 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 30346 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 30347 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 30348 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 30349 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 30350 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 30351 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 30352 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 30353 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 30354 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30355 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 30356 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 30357 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 30358 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 30359 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 30360 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 30361 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30362 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 30363 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 30364 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 30365 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30366 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 30367 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 30368 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 30369 | } }, |
| | 30370 | }, .{ |
| | 30371 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| | 30372 | .src_constraints = .{ |
| | 30373 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 30374 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 30375 | .any, |
| | 30376 | }, |
| | 30377 | .patterns = &.{ |
| | 30378 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 30379 | }, |
| | 30380 | .extra_temps = .{ |
| | 30381 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 30382 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30383 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 30384 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30385 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30386 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 30387 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30388 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 30389 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30390 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 30391 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 30392 | }, |
| | 30393 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 30394 | .clobbers = .{ .eflags = true }, |
| | 30395 | .each = .{ .once = &.{ |
| | 30396 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 30397 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 30398 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 30399 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 30400 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 30401 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 30402 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 30403 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 30404 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 30405 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30406 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 30407 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 30408 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 30409 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 30410 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 30411 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 30412 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 30413 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 30414 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 30415 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 30416 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 30417 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 30418 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 30419 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 30420 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 30421 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 30422 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 30423 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 30424 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 30425 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 30426 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 30427 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 30428 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 30429 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 30430 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 30431 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 30432 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 30433 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 30434 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 30435 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 30436 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 30437 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30438 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 30439 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 30440 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 30441 | .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 30442 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 30443 | .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ }, |
| | 30444 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 30445 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 30446 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 30447 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 30448 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 30449 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30450 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 30451 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 30452 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 30453 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 30454 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 30455 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 30456 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 30457 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 30458 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 30459 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 30460 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 30461 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 30462 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 30463 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 30464 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 30465 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30466 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 30467 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 30468 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 30469 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 30470 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 30471 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 30472 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30473 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 30474 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 30475 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 30476 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30477 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 30478 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 30479 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 30480 | } }, |
| | 30481 | }, .{ |
| | 30482 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| | 30483 | .src_constraints = .{ |
| | 30484 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 30485 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 30486 | .any, |
| | 30487 | }, |
| | 30488 | .patterns = &.{ |
| | 30489 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 30490 | }, |
| | 30491 | .extra_temps = .{ |
| | 30492 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 30493 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30494 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 30495 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30496 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30497 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 30498 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30499 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 30500 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30501 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 30502 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 30503 | }, |
| | 30504 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 30505 | .clobbers = .{ .eflags = true }, |
| | 30506 | .each = .{ .once = &.{ |
| | 30507 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 30508 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 30509 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 30510 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 30511 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 30512 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 30513 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 30514 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 30515 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 30516 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30517 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 30518 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 30519 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 30520 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 30521 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 30522 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 30523 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 30524 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 30525 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 30526 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 30527 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 30528 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 30529 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 30530 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 30531 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 30532 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 30533 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 30534 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 30535 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 30536 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 30537 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 30538 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 30539 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 30540 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 30541 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 30542 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 30543 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 30544 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 30545 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 30546 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 30547 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 30548 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30549 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 30550 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 30551 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 30552 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 30553 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 30554 | .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 30555 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 30556 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 30557 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 30558 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 30559 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 30560 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30561 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 30562 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 30563 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 30564 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 30565 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 30566 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 30567 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 30568 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 30569 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 30570 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 30571 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 30572 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 30573 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 30574 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 30575 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 30576 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30577 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 30578 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 30579 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 30580 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 30581 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 30582 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 30583 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30584 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 30585 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 30586 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 30587 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30588 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 30589 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 30590 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 30591 | } }, |
| | 30592 | }, .{ |
| | 30593 | .required_features = .{ .@"64bit", null, null, null }, |
| | 30594 | .src_constraints = .{ |
| | 30595 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 30596 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 30597 | .any, |
| | 30598 | }, |
| | 30599 | .patterns = &.{ |
| | 30600 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 30601 | }, |
| | 30602 | .extra_temps = .{ |
| | 30603 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 30604 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30605 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 30606 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30607 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30608 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 30609 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30610 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 30611 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30612 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 30613 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 30614 | }, |
| | 30615 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 30616 | .clobbers = .{ .eflags = true }, |
| | 30617 | .each = .{ .once = &.{ |
| | 30618 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 30619 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 30620 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 30621 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 30622 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 30623 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 30624 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 30625 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 30626 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 30627 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30628 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 30629 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 30630 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 30631 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 30632 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 30633 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 30634 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 30635 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 30636 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 30637 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 30638 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 30639 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 30640 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 30641 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 30642 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 30643 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 30644 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 30645 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 30646 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 30647 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 30648 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 30649 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 30650 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 30651 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 30652 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 30653 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 30654 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 30655 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 30656 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 30657 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 30658 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 30659 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30660 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 30661 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 30662 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 30663 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 30664 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 30665 | .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 30666 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 30667 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 30668 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 30669 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 30670 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 30671 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30672 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 30673 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 30674 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 30675 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 30676 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 30677 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 30678 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 30679 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 30680 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 30681 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 30682 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 30683 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 30684 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 30685 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 30686 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 30687 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30688 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 30689 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 30690 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 30691 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 30692 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 30693 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 30694 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30695 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 30696 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 30697 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 30698 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30699 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 30700 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 30701 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 30702 | } }, |
| | 30703 | }, .{ |
| | 30704 | .required_features = .{ .@"64bit", .cmov, .slow_incdec, null }, |
| | 30705 | .src_constraints = .{ |
| | 30706 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 30707 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 30708 | .any, |
| | 30709 | }, |
| | 30710 | .patterns = &.{ |
| | 30711 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 30712 | }, |
| | 30713 | .extra_temps = .{ |
| | 30714 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 30715 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30716 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 30717 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30718 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30719 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 30720 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30721 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 30722 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30723 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 30724 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 30725 | }, |
| | 30726 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 30727 | .clobbers = .{ .eflags = true }, |
| | 30728 | .each = .{ .once = &.{ |
| | 30729 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 30730 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 30731 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 30732 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 30733 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 30734 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 30735 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 30736 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 30737 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 30738 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30739 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 30740 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 30741 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 30742 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 30743 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 30744 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 30745 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 30746 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 30747 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 30748 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 30749 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 30750 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 30751 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 30752 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 30753 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 30754 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 30755 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 30756 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 30757 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 30758 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 30759 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 30760 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 30761 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 30762 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 30763 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 30764 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 30765 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 30766 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 30767 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 30768 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 30769 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 30770 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30771 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 30772 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 30773 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 30774 | .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 30775 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 30776 | .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ }, |
| | 30777 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 30778 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 30779 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 30780 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 30781 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 30782 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30783 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 30784 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 30785 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 30786 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 30787 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 30788 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 30789 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 30790 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 30791 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 30792 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 30793 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 30794 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 30795 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 30796 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 30797 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 30798 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30799 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 30800 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 30801 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 30802 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 30803 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 30804 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 30805 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30806 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 30807 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 30808 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 30809 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30810 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 30811 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 30812 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 30813 | .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ }, |
| | 30814 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| | 30815 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 30816 | .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 30817 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 30818 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 30819 | } }, |
| | 30820 | }, .{ |
| | 30821 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| | 30822 | .src_constraints = .{ |
| | 30823 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 30824 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 30825 | .any, |
| | 30826 | }, |
| | 30827 | .patterns = &.{ |
| | 30828 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 30829 | }, |
| | 30830 | .extra_temps = .{ |
| | 30831 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 30832 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30833 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 30834 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30835 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30836 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 30837 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30838 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 30839 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30840 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 30841 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 30842 | }, |
| | 30843 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 30844 | .clobbers = .{ .eflags = true }, |
| | 30845 | .each = .{ .once = &.{ |
| | 30846 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 30847 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 30848 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 30849 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 30850 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 30851 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 30852 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 30853 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 30854 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 30855 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30856 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 30857 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 30858 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 30859 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 30860 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 30861 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 30862 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 30863 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 30864 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 30865 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 30866 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 30867 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 30868 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 30869 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 30870 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 30871 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 30872 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 30873 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 30874 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 30875 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 30876 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 30877 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 30878 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 30879 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 30880 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 30881 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 30882 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 30883 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 30884 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 30885 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 30886 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 30887 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30888 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 30889 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 30890 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 30891 | .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 30892 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 30893 | .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ }, |
| | 30894 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 30895 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 30896 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 30897 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 30898 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 30899 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30900 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 30901 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 30902 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 30903 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 30904 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 30905 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 30906 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 30907 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 30908 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 30909 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 30910 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 30911 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 30912 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 30913 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 30914 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 30915 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30916 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 30917 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 30918 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 30919 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 30920 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 30921 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 30922 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30923 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 30924 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 30925 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 30926 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 30927 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 30928 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 30929 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 30930 | .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ }, |
| | 30931 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| | 30932 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 30933 | .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 30934 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 30935 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 30936 | } }, |
| | 30937 | }, .{ |
| | 30938 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| | 30939 | .src_constraints = .{ |
| | 30940 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 30941 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 30942 | .any, |
| | 30943 | }, |
| | 30944 | .patterns = &.{ |
| | 30945 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 30946 | }, |
| | 30947 | .extra_temps = .{ |
| | 30948 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 30949 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30950 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 30951 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30952 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30953 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 30954 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30955 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 30956 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 30957 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 30958 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 30959 | }, |
| | 30960 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 30961 | .clobbers = .{ .eflags = true }, |
| | 30962 | .each = .{ .once = &.{ |
| | 30963 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 30964 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 30965 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 30966 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 30967 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 30968 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 30969 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 30970 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 30971 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 30972 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 30973 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 30974 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 30975 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 30976 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 30977 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 30978 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 30979 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 30980 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 30981 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 30982 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 30983 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 30984 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 30985 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 30986 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 30987 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 30988 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 30989 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 30990 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 30991 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 30992 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 30993 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 30994 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 30995 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 30996 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 30997 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 30998 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 30999 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 31000 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 31001 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 31002 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31003 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 31004 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31005 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 31006 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 31007 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 31008 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31009 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 31010 | .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 31011 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31012 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 31013 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31014 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31015 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31016 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31017 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31018 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31019 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31020 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 31021 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31022 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 31023 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31024 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31025 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 31026 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 31027 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31028 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31029 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31030 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31031 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31032 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31033 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31034 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31035 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 31036 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31037 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31038 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31039 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31040 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31041 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31042 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31043 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31044 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31045 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 31046 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 31047 | .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ }, |
| | 31048 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| | 31049 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 31050 | .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31051 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 31052 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 31053 | } }, |
| | 31054 | }, .{ |
| | 31055 | .required_features = .{ .@"64bit", null, null, null }, |
| | 31056 | .src_constraints = .{ |
| | 31057 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 31058 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 31059 | .any, |
| | 31060 | }, |
| | 31061 | .patterns = &.{ |
| | 31062 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 31063 | }, |
| | 31064 | .extra_temps = .{ |
| | 31065 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31066 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31067 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 31068 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31069 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31070 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31071 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31072 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 31073 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31074 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 31075 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 31076 | }, |
| | 31077 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 31078 | .clobbers = .{ .eflags = true }, |
| | 31079 | .each = .{ .once = &.{ |
| | 31080 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 31081 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31082 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 31083 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31084 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 31085 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 31086 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 31087 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 31088 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 31089 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31090 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 31091 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 31092 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 31093 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 31094 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 31095 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 31096 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 31097 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 31098 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31099 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 31100 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 31101 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 31102 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 31103 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 31104 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 31105 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 31106 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 31107 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 31108 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31109 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31110 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 31111 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 31112 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 31113 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 31114 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 31115 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 31116 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 31117 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 31118 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 31119 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31120 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 31121 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31122 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 31123 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 31124 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 31125 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31126 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 31127 | .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 31128 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31129 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 31130 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31131 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31132 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31133 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31134 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31135 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31136 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31137 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 31138 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31139 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 31140 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31141 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31142 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 31143 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 31144 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31145 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31146 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31147 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31148 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31149 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31150 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31151 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31152 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 31153 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31154 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31155 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31156 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31157 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31158 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31159 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31160 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31161 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31162 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 31163 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 31164 | .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ }, |
| | 31165 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| | 31166 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 31167 | .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31168 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 31169 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 31170 | } }, |
| | 31171 | }, .{ |
| | 31172 | .required_features = .{ .@"64bit", .cmov, .slow_incdec, null }, |
| | 31173 | .src_constraints = .{ |
| | 31174 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 31175 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 31176 | .any, |
| | 31177 | }, |
| | 31178 | .patterns = &.{ |
| | 31179 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 31180 | }, |
| | 31181 | .extra_temps = .{ |
| | 31182 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31183 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31184 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 31185 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31186 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31187 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31188 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31189 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 31190 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31191 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 31192 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 31193 | }, |
| | 31194 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 31195 | .clobbers = .{ .eflags = true }, |
| | 31196 | .each = .{ .once = &.{ |
| | 31197 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 31198 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31199 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 31200 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31201 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 31202 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 31203 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 31204 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 31205 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 31206 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31207 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 31208 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 31209 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 31210 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 31211 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 31212 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 31213 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 31214 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 31215 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31216 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 31217 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 31218 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 31219 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 31220 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 31221 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 31222 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 31223 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 31224 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 31225 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31226 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31227 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 31228 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 31229 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 31230 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 31231 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 31232 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 31233 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 31234 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 31235 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 31236 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31237 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 31238 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31239 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 31240 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 31241 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 31242 | .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 31243 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31244 | .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ }, |
| | 31245 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31246 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 31247 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31248 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31249 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31250 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31251 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31252 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31253 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31254 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 31255 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31256 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 31257 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31258 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31259 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 31260 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 31261 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31262 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31263 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31264 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31265 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31266 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31267 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31268 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31269 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 31270 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31271 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31272 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31273 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31274 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31275 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31276 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31277 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31278 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31279 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 31280 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 31281 | .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ }, |
| | 31282 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 31283 | .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 31284 | .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 31285 | .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, |
| | 31286 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ }, |
| | 31287 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| | 31288 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 31289 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 31290 | .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31291 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 31292 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 31293 | } }, |
| | 31294 | }, .{ |
| | 31295 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| | 31296 | .src_constraints = .{ |
| | 31297 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 31298 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 31299 | .any, |
| | 31300 | }, |
| | 31301 | .patterns = &.{ |
| | 31302 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 31303 | }, |
| | 31304 | .extra_temps = .{ |
| | 31305 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31306 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31307 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 31308 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31309 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31310 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31311 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31312 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 31313 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31314 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 31315 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 31316 | }, |
| | 31317 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 31318 | .clobbers = .{ .eflags = true }, |
| | 31319 | .each = .{ .once = &.{ |
| | 31320 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 31321 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31322 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 31323 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31324 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 31325 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 31326 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 31327 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 31328 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 31329 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31330 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 31331 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 31332 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 31333 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 31334 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 31335 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 31336 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 31337 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 31338 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31339 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 31340 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 31341 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 31342 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 31343 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 31344 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 31345 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 31346 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 31347 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 31348 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31349 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31350 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 31351 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 31352 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 31353 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 31354 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 31355 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 31356 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 31357 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 31358 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 31359 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31360 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 31361 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31362 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 31363 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 31364 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 31365 | .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 31366 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31367 | .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ }, |
| | 31368 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31369 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 31370 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31371 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31372 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31373 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31374 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31375 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31376 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31377 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 31378 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31379 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 31380 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31381 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31382 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 31383 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 31384 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31385 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31386 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31387 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31388 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31389 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31390 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31391 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31392 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 31393 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31394 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31395 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31396 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31397 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31398 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31399 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31400 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31401 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31402 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 31403 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 31404 | .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ }, |
| | 31405 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 31406 | .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 31407 | .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 31408 | .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, |
| | 31409 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ }, |
| | 31410 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| | 31411 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 31412 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 31413 | .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31414 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 31415 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 31416 | } }, |
| | 31417 | }, .{ |
| | 31418 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| | 31419 | .src_constraints = .{ |
| | 31420 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 31421 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 31422 | .any, |
| | 31423 | }, |
| | 31424 | .patterns = &.{ |
| | 31425 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 31426 | }, |
| | 31427 | .extra_temps = .{ |
| | 31428 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31429 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31430 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 31431 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31432 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31433 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31434 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31435 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 31436 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31437 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 31438 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 31439 | }, |
| | 31440 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 31441 | .clobbers = .{ .eflags = true }, |
| | 31442 | .each = .{ .once = &.{ |
| | 31443 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 31444 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31445 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 31446 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31447 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 31448 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 31449 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 31450 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 31451 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 31452 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31453 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 31454 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 31455 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 31456 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 31457 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 31458 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 31459 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 31460 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 31461 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31462 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 31463 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 31464 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 31465 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 31466 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 31467 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 31468 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 31469 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 31470 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 31471 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31472 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31473 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 31474 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 31475 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 31476 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 31477 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 31478 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 31479 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 31480 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 31481 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 31482 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31483 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 31484 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31485 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 31486 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 31487 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 31488 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31489 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 31490 | .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 31491 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31492 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 31493 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31494 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31495 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31496 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31497 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31498 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31499 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31500 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 31501 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31502 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 31503 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31504 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31505 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 31506 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 31507 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31508 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31509 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31510 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31511 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31512 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31513 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31514 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31515 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 31516 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31517 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31518 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31519 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31520 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31521 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31522 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31523 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31524 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31525 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 31526 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 31527 | .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ }, |
| | 31528 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 31529 | .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 31530 | .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 31531 | .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, |
| | 31532 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ }, |
| | 31533 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| | 31534 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 31535 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 31536 | .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31537 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 31538 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 31539 | } }, |
| | 31540 | }, .{ |
| | 31541 | .required_features = .{ .@"64bit", null, null, null }, |
| | 31542 | .src_constraints = .{ |
| | 31543 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 31544 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| | 31545 | .any, |
| | 31546 | }, |
| | 31547 | .patterns = &.{ |
| | 31548 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 31549 | }, |
| | 31550 | .extra_temps = .{ |
| | 31551 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31552 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31553 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 31554 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31555 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31556 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31557 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31558 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 31559 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31560 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 31561 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 31562 | }, |
| | 31563 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 31564 | .clobbers = .{ .eflags = true }, |
| | 31565 | .each = .{ .once = &.{ |
| | 31566 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 31567 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31568 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 31569 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31570 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 31571 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 31572 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 31573 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 31574 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 31575 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31576 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 31577 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 31578 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 31579 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 31580 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 31581 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 31582 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 31583 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 31584 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31585 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 31586 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 31587 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 31588 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 31589 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 31590 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 31591 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 31592 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 31593 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 31594 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31595 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31596 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 31597 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 31598 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 31599 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 31600 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 31601 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 31602 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 31603 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 31604 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 31605 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31606 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 31607 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31608 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 31609 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 31610 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 31611 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31612 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 31613 | .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 31614 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31615 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 31616 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31617 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31618 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31619 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31620 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31621 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31622 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31623 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 31624 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31625 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 31626 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31627 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31628 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 31629 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 31630 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31631 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31632 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31633 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31634 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31635 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31636 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31637 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31638 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 31639 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31640 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31641 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31642 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31643 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31644 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31645 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31646 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31647 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31648 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 31649 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 31650 | .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -16), ._, ._ }, |
| | 31651 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 31652 | .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 31653 | .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 31654 | .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, |
| | 31655 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ }, |
| | 31656 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| | 31657 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 31658 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 31659 | .{ ._, ._, .xor, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31660 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 31661 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 31662 | } }, |
| | 31663 | }, .{ |
| | 31664 | .required_features = .{ .@"64bit", .cmov, .slow_incdec, null }, |
| | 31665 | .src_constraints = .{ |
| | 31666 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 31667 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 31668 | .any, |
| | 31669 | }, |
| | 31670 | .patterns = &.{ |
| | 31671 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 31672 | }, |
| | 31673 | .extra_temps = .{ |
| | 31674 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31675 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31676 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 31677 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31678 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31679 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31680 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31681 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 31682 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31683 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 31684 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 31685 | }, |
| | 31686 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 31687 | .clobbers = .{ .eflags = true }, |
| | 31688 | .each = .{ .once = &.{ |
| | 31689 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 31690 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31691 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 31692 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31693 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 31694 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 31695 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 31696 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 31697 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 31698 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31699 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 31700 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 31701 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 31702 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 31703 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 31704 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 31705 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 31706 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 31707 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31708 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 31709 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 31710 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 31711 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 31712 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 31713 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 31714 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 31715 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 31716 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 31717 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31718 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31719 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 31720 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 31721 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 31722 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 31723 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 31724 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 31725 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 31726 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 31727 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 31728 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31729 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 31730 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31731 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 31732 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 31733 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 31734 | .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 31735 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31736 | .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ }, |
| | 31737 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31738 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 31739 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31740 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31741 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31742 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31743 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31744 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31745 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31746 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 31747 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31748 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 31749 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31750 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31751 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 31752 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 31753 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31754 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31755 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31756 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31757 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31758 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31759 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31760 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31761 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 31762 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31763 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31764 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31765 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31766 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31767 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31768 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31769 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31770 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31771 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 31772 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 31773 | .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31774 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 31775 | .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 31776 | .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 31777 | .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, |
| | 31778 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 31779 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 31780 | } }, |
| | 31781 | }, .{ |
| | 31782 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| | 31783 | .src_constraints = .{ |
| | 31784 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 31785 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 31786 | .any, |
| | 31787 | }, |
| | 31788 | .patterns = &.{ |
| | 31789 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 31790 | }, |
| | 31791 | .extra_temps = .{ |
| | 31792 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31793 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31794 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 31795 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31796 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31797 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31798 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31799 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 31800 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31801 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 31802 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 31803 | }, |
| | 31804 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 31805 | .clobbers = .{ .eflags = true }, |
| | 31806 | .each = .{ .once = &.{ |
| | 31807 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 31808 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31809 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 31810 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31811 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 31812 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 31813 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 31814 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 31815 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 31816 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31817 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 31818 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 31819 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 31820 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 31821 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 31822 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 31823 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 31824 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 31825 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31826 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 31827 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 31828 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 31829 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 31830 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 31831 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 31832 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 31833 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 31834 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 31835 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31836 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31837 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 31838 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 31839 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 31840 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 31841 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 31842 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 31843 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 31844 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 31845 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 31846 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31847 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 31848 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31849 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 31850 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 31851 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 31852 | .{ ._, ._, .lea, .tmp8q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 31853 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31854 | .{ ._, ._nz, .cmov, .tmp2q, .tmp8q, ._, ._ }, |
| | 31855 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31856 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 31857 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31858 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31859 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31860 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31861 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31862 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31863 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31864 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 31865 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31866 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 31867 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31868 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31869 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 31870 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 31871 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31872 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31873 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31874 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31875 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31876 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31877 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31878 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31879 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 31880 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31881 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31882 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31883 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31884 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31885 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31886 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 31887 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31888 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 31889 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 31890 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 31891 | .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31892 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 31893 | .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 31894 | .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 31895 | .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, |
| | 31896 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 31897 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 31898 | } }, |
| | 31899 | }, .{ |
| | 31900 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| | 31901 | .src_constraints = .{ |
| | 31902 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 31903 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 31904 | .any, |
| | 31905 | }, |
| | 31906 | .patterns = &.{ |
| | 31907 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 31908 | }, |
| | 31909 | .extra_temps = .{ |
| | 31910 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31911 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31912 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 31913 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31914 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31915 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 31916 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31917 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 31918 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 31919 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 31920 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 31921 | }, |
| | 31922 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 31923 | .clobbers = .{ .eflags = true }, |
| | 31924 | .each = .{ .once = &.{ |
| | 31925 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 31926 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31927 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 31928 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 31929 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 31930 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 31931 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 31932 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 31933 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 31934 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31935 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 31936 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 31937 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 31938 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 31939 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 31940 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 31941 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 31942 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 31943 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31944 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 31945 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 31946 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 31947 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 31948 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 31949 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 31950 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 31951 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 31952 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 31953 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31954 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 31955 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 31956 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 31957 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 31958 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 31959 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 31960 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 31961 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 31962 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 31963 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 31964 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 31965 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 31966 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 31967 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 31968 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 31969 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 31970 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31971 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 31972 | .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 31973 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31974 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 31975 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31976 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31977 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31978 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31979 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31980 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31981 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 31982 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 31983 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 31984 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 31985 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 31986 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 31987 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 31988 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 31989 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 31990 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31991 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 31992 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 31993 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 31994 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 31995 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 31996 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 31997 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 31998 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 31999 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 32000 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 32001 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 32002 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 32003 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 32004 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 32005 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 32006 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 32007 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 32008 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 32009 | .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 32010 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 32011 | .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 32012 | .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 32013 | .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, |
| | 32014 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 32015 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 32016 | } }, |
| | 32017 | }, .{ |
| | 32018 | .required_features = .{ .@"64bit", null, null, null }, |
| | 32019 | .src_constraints = .{ |
| | 32020 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 32021 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| | 32022 | .any, |
| | 32023 | }, |
| | 32024 | .patterns = &.{ |
| | 32025 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 32026 | }, |
| | 32027 | .extra_temps = .{ |
| | 32028 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32029 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32030 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32031 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32032 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32033 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32034 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32035 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 32036 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32037 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 32038 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 32039 | }, |
| | 32040 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 32041 | .clobbers = .{ .eflags = true }, |
| | 32042 | .each = .{ .once = &.{ |
| | 32043 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 32044 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 32045 | .{ ._, ._, .lea, .tmp2p, .memd(.src1, 8), ._, ._ }, |
| | 32046 | .{ ._, ._, .mov, .tmp3q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 32047 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 32048 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| | 32049 | .{ ._, ._r, .sa, .tmp3q, .ui(63), ._, ._ }, |
| | 32050 | .{ .@"0:", ._, .lea, .tmp5p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 32051 | .{ ._, ._, .mov, .tmp6q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 32052 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 32053 | .{ ._, ._, .xor, .tmp8d, .tmp8d, ._, ._ }, |
| | 32054 | .{ ._, ._, .xor, .tmp6q, .tmp1q, ._, ._ }, |
| | 32055 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 32056 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp6q, ._, ._ }, |
| | 32057 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 32058 | .{ .@"1:", ._, .adc, .tmp10q, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), ._, ._ }, |
| | 32059 | .{ ._, ._, .adc, .tmp7b, .si(0), ._, ._ }, |
| | 32060 | .{ ._, ._, .mov, .tmp8q, .tmp10q, ._, ._ }, |
| | 32061 | .{ .@"2:", ._, .mov, .tmp9q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 32062 | .{ ._, ._, .xor, .tmp9q, .tmp3q, ._, ._ }, |
| | 32063 | .{ ._, ._, .mul, .tmp6q, ._, ._, ._ }, |
| | 32064 | .{ ._, ._l, .sh, .tmp7b, .ui(4), ._, ._ }, |
| | 32065 | .{ ._, ._, .adc, .tmp9q, .tmp8q, ._, ._ }, |
| | 32066 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp5, .add_src0_size), .tmp9q, ._, ._ }, |
| | 32067 | .{ ._, ._c, .in, .tmp5p, ._, ._, ._ }, |
| | 32068 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 32069 | .{ ._, ._, .mov, .tmp5d, .tmp0d, ._, ._ }, |
| | 32070 | .{ ._, ._, .adc, .tmp10q, .si(0), ._, ._ }, |
| | 32071 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32072 | .{ .@"1:", ._, .mov, .tmp6q, .leasi(.tmp2q, .@"8", .tmp5), ._, ._ }, |
| | 32073 | .{ ._, ._, .xor, .tmp6q, .tmp3q, ._, ._ }, |
| | 32074 | .{ ._, ._, .@"or", .tmp10q, .tmp6q, ._, ._ }, |
| | 32075 | .{ .@"2:", ._c, .de, .tmp5d, ._, ._, ._ }, |
| | 32076 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 32077 | .{ ._, ._, .@"or", .tmp4q, .tmp10q, ._, ._ }, |
| | 32078 | .{ .@"3:", ._, .lea, .tmp2p, .lead(.tmp2, 8), ._, ._ }, |
| | 32079 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 32080 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 32081 | .{ ._, ._, .mov, .tmp0q, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| | 32082 | .{ ._, ._, .mov, .tmp5q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 32083 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 32084 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 32085 | .{ ._, ._, .cmp, .tmp1b, .tmp3b, ._, ._ }, |
| | 32086 | .{ ._, ._e, .j, .@"1f", ._, ._, ._ }, |
| | 32087 | .{ ._, ._, .lea, .tmp2q, .memad(.src0, .add_size, -8), ._, ._ }, |
| | 32088 | .{ ._, ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 32089 | .{ ._, ._z, .j, .@"0f", ._, ._, ._ }, |
| | 32090 | .{ ._, ._, .lea, .tmp2q, .memad(.src1, .add_size, -8), ._, ._ }, |
| | 32091 | .{ .@"0:", ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 32092 | .{ ._, ._, .sbb, .tmp8q, .leasi(.tmp2q, .@"8", .tmp0), ._, ._ }, |
| | 32093 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 32094 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 32095 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 32096 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 32097 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 32098 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 32099 | .{ ._, ._, .mov, .tmp8d, .tmp7d, ._, ._ }, |
| | 32100 | .{ ._, ._, .sbb, .tmp8q, .lea(.tmp2q), ._, ._ }, |
| | 32101 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 32102 | .{ ._, ._, .sbb, .tmp8q, .tmp5q, ._, ._ }, |
| | 32103 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32104 | .{ .@"1:", ._, .@"test", .tmp1b, .tmp1b, ._, ._ }, |
| | 32105 | .{ ._, ._z, .j, .@"1f", ._, ._, ._ }, |
| | 32106 | .{ ._, ._c, .st, ._, ._, ._, ._ }, |
| | 32107 | .{ .@"0:", ._, .mov, .tmp8q, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), ._, ._ }, |
| | 32108 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 32109 | .{ ._, ._, .adc, .tmp6b, .tmp6b, ._, ._ }, |
| | 32110 | .{ ._, ._, .sbb, .tmp8q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| | 32111 | .{ ._, ._r, .rc, .tmp6b, .ui(1), ._, ._ }, |
| | 32112 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 32113 | .{ ._, ._c, .in, .tmp0q, ._, ._, ._ }, |
| | 32114 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| | 32115 | .{ ._, ._, .mov, .tmp8q, .tmp5q, ._, ._ }, |
| | 32116 | .{ ._, ._, .sbb, .tmp8q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| | 32117 | .{ ._, ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 32118 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 32119 | .{ ._, ._, .xor, .tmp7d, .tmp7d, ._, ._ }, |
| | 32120 | .{ ._, ._, .add, .tmp6b, .tmp6b, ._, ._ }, |
| | 32121 | .{ ._, ._, .sbb, .tmp8q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| | 32122 | .{ .@"2:", ._o, .set, .tmp7b, ._, ._, ._ }, |
| | 32123 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp8q, ._, ._ }, |
| | 32124 | .{ ._, ._, .@"or", .tmp4b, .tmp7b, ._, ._ }, |
| | 32125 | .{ .@"1:", ._r, .sh, .tmp5q, .ui(63), ._, ._ }, |
| | 32126 | .{ ._, ._, .@"or", .tmp4q, .tmp5q, ._, ._ }, |
| | 32127 | .{ ._, ._, .mov, .tmp0q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 32128 | .{ ._, ._, .mov, .tmp1q, .tmp0q, ._, ._ }, |
| | 32129 | .{ ._, ._l, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 32130 | .{ ._, ._r, .sa, .tmp0q, .uia(64, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| | 32131 | .{ ._, ._, .xor, .tmp1q, .tmp0q, ._, ._ }, |
| | 32132 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 32133 | .{ ._, ._, .@"or", .tmp4q, .tmp1q, ._, ._ }, |
| | 32134 | } }, |
| | 32135 | }, .{ |
| | 32136 | .required_features = .{ .@"64bit", .bmi2, .adx, null }, |
| | 32137 | .src_constraints = .{ |
| | 32138 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 32139 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 32140 | .any, |
| | 32141 | }, |
| | 32142 | .patterns = &.{ |
| | 32143 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 32144 | }, |
| | 32145 | .extra_temps = .{ |
| | 32146 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32147 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32148 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32149 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32150 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 32151 | .{ .type = .isize, .kind = .{ .reg = .rcx } }, |
| | 32152 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32153 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32154 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32155 | .unused, |
| | 32156 | .unused, |
| | 32157 | }, |
| | 32158 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 32159 | .clobbers = .{ .eflags = true }, |
| | 32160 | .each = .{ .once = &.{ |
| | 32161 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, |
| | 32162 | .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, |
| | 32163 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 32164 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| | 32165 | .{ .@"0:", ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 32166 | .{ ._, ._, .@"or", .tmp4q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 32167 | .{ ._, ._z, .j, .@"2f", ._, ._, ._ }, |
| | 32168 | .{ ._, ._, .lea, .tmp5p, .leaad(.tmp0, .sub_src0_size, 8), ._, ._ }, |
| | 32169 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 32170 | .{ .@"1:", ._x, .mul, .tmp8q, .tmp7q, .leai(.tmp1q, .tmp5), ._ }, |
| | 32171 | .{ ._, ._x, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 32172 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp5, .add_src0_size, -8), .tmp7q, ._, ._ }, |
| | 32173 | .{ ._, ._rcxz, .j, .@"1f", ._, ._, ._ }, |
| | 32174 | .{ ._, ._x, .ado, .tmp8q, .memia(.dst0q, .tmp5, .add_src0_size), ._, ._ }, |
| | 32175 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 32176 | .{ ._, ._, .lea, .tmp5p, .lead(.tmp5, 8), ._, ._ }, |
| | 32177 | .{ ._, ._mp, .j, .@"1b", ._, ._, ._ }, |
| | 32178 | .{ .@"2:", ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ }, |
| | 32179 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 32180 | .{ .@"1:", ._, .mov, .tmp4d, .tmp0d, ._, ._ }, |
| | 32181 | .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ }, |
| | 32182 | .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ }, |
| | 32183 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32184 | .{ .@"1:", ._, .@"or", .tmp8q, .leaid(.tmp1q, .tmp4, 8), ._, ._ }, |
| | 32185 | .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ }, |
| | 32186 | .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, |
| | 32187 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| | 32188 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 32189 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 32190 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 32191 | .{ ._, ._, .@"test", .tmp2q, .tmp2q, ._, ._ }, |
| | 32192 | } }, |
| | 32193 | }, .{ |
| | 32194 | .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null }, |
| | 32195 | .src_constraints = .{ |
| | 32196 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 32197 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 32198 | .any, |
| | 32199 | }, |
| | 32200 | .patterns = &.{ |
| | 32201 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 32202 | }, |
| | 32203 | .extra_temps = .{ |
| | 32204 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32205 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32206 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32207 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32208 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 32209 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 32210 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32211 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32212 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32213 | .unused, |
| | 32214 | .unused, |
| | 32215 | }, |
| | 32216 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 32217 | .clobbers = .{ .eflags = true }, |
| | 32218 | .each = .{ .once = &.{ |
| | 32219 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 32220 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 32221 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 32222 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 32223 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 32224 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 32225 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 32226 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 32227 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 32228 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 32229 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 32230 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 32231 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 32232 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 32233 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 32234 | .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ }, |
| | 32235 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 32236 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 32237 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 32238 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 32239 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 32240 | .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ }, |
| | 32241 | .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ }, |
| | 32242 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32243 | .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 32244 | .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ }, |
| | 32245 | .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, |
| | 32246 | .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ }, |
| | 32247 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 32248 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 32249 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 32250 | .{ ._, ._, .@"test", .tmp2q, .tmp2q, ._, ._ }, |
| | 32251 | } }, |
| | 32252 | }, .{ |
| | 32253 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 32254 | .src_constraints = .{ |
| | 32255 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 32256 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 32257 | .any, |
| | 32258 | }, |
| | 32259 | .patterns = &.{ |
| | 32260 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 32261 | }, |
| | 32262 | .extra_temps = .{ |
| | 32263 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32264 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32265 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32266 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32267 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 32268 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 32269 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32270 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32271 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32272 | .unused, |
| | 32273 | .unused, |
| | 32274 | }, |
| | 32275 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 32276 | .clobbers = .{ .eflags = true }, |
| | 32277 | .each = .{ .once = &.{ |
| | 32278 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 32279 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 32280 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 32281 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 32282 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 32283 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 32284 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 32285 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 32286 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 32287 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 32288 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 32289 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 32290 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 32291 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 32292 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 32293 | .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ }, |
| | 32294 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 32295 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 32296 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 32297 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 32298 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 32299 | .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ }, |
| | 32300 | .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ }, |
| | 32301 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32302 | .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 32303 | .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ }, |
| | 32304 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 32305 | .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ }, |
| | 32306 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 32307 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 32308 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 32309 | .{ ._, ._, .@"test", .tmp2q, .tmp2q, ._, ._ }, |
| | 32310 | } }, |
| | 32311 | }, .{ |
| | 32312 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| | 32313 | .src_constraints = .{ |
| | 32314 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 32315 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 32316 | .any, |
| | 32317 | }, |
| | 32318 | .patterns = &.{ |
| | 32319 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 32320 | }, |
| | 32321 | .extra_temps = .{ |
| | 32322 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32323 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32324 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32325 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32326 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32327 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 32328 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32329 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 32330 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 32331 | .unused, |
| | 32332 | .unused, |
| | 32333 | }, |
| | 32334 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 32335 | .clobbers = .{ .eflags = true }, |
| | 32336 | .each = .{ .once = &.{ |
| | 32337 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 32338 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 32339 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 32340 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 32341 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 32342 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 32343 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 32344 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 32345 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 32346 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 32347 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 32348 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 32349 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 32350 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 32351 | .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ }, |
| | 32352 | .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ }, |
| | 32353 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 32354 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 32355 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 32356 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 32357 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 32358 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 32359 | .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ }, |
| | 32360 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32361 | .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 32362 | .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ }, |
| | 32363 | .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, |
| | 32364 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| | 32365 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 32366 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 32367 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 32368 | .{ ._, ._, .@"test", .tmp2q, .tmp2q, ._, ._ }, |
| | 32369 | } }, |
| | 32370 | }, .{ |
| | 32371 | .required_features = .{ .@"64bit", null, null, null }, |
| | 32372 | .src_constraints = .{ |
| | 32373 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 32374 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 32375 | .any, |
| | 32376 | }, |
| | 32377 | .patterns = &.{ |
| | 32378 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 32379 | }, |
| | 32380 | .extra_temps = .{ |
| | 32381 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32382 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32383 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32384 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32385 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32386 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 32387 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32388 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 32389 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 32390 | .unused, |
| | 32391 | .unused, |
| | 32392 | }, |
| | 32393 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 32394 | .clobbers = .{ .eflags = true }, |
| | 32395 | .each = .{ .once = &.{ |
| | 32396 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 32397 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 32398 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 32399 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 32400 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 32401 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 32402 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 32403 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 32404 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 32405 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 32406 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 32407 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 32408 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 32409 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 32410 | .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ }, |
| | 32411 | .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ }, |
| | 32412 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 32413 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 32414 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 32415 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 32416 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 32417 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 32418 | .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ }, |
| | 32419 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32420 | .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 32421 | .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ }, |
| | 32422 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 32423 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| | 32424 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 32425 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 32426 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 32427 | .{ ._, ._, .@"test", .tmp2q, .tmp2q, ._, ._ }, |
| | 32428 | } }, |
| | 32429 | }, .{ |
| | 32430 | .required_features = .{ .@"64bit", .bmi2, .adx, null }, |
| | 32431 | .src_constraints = .{ |
| | 32432 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32433 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32434 | .any, |
| | 32435 | }, |
| | 32436 | .patterns = &.{ |
| | 32437 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 32438 | }, |
| | 32439 | .extra_temps = .{ |
| | 32440 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32441 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32442 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32443 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32444 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 32445 | .{ .type = .isize, .kind = .{ .reg = .rcx } }, |
| | 32446 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32447 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32448 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32449 | .unused, |
| | 32450 | .unused, |
| | 32451 | }, |
| | 32452 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 32453 | .clobbers = .{ .eflags = true }, |
| | 32454 | .each = .{ .once = &.{ |
| | 32455 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, |
| | 32456 | .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, |
| | 32457 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 32458 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| | 32459 | .{ .@"0:", ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 32460 | .{ ._, ._, .@"or", .tmp4q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 32461 | .{ ._, ._z, .j, .@"2f", ._, ._, ._ }, |
| | 32462 | .{ ._, ._, .lea, .tmp5p, .leaad(.tmp0, .sub_src0_size, 8), ._, ._ }, |
| | 32463 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 32464 | .{ .@"1:", ._x, .mul, .tmp8q, .tmp7q, .leai(.tmp1q, .tmp5), ._ }, |
| | 32465 | .{ ._, ._x, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 32466 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp5, .add_src0_size, -8), .tmp7q, ._, ._ }, |
| | 32467 | .{ ._, ._rcxz, .j, .@"1f", ._, ._, ._ }, |
| | 32468 | .{ ._, ._x, .ado, .tmp8q, .memia(.dst0q, .tmp5, .add_src0_size), ._, ._ }, |
| | 32469 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 32470 | .{ ._, ._, .lea, .tmp5p, .lead(.tmp5, 8), ._, ._ }, |
| | 32471 | .{ ._, ._mp, .j, .@"1b", ._, ._, ._ }, |
| | 32472 | .{ .@"2:", ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ }, |
| | 32473 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 32474 | .{ .@"1:", ._, .mov, .tmp4d, .tmp0d, ._, ._ }, |
| | 32475 | .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ }, |
| | 32476 | .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ }, |
| | 32477 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32478 | .{ .@"1:", ._, .@"or", .tmp8q, .leai(.tmp1q, .tmp4), ._, ._ }, |
| | 32479 | .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ }, |
| | 32480 | .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, |
| | 32481 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| | 32482 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 32483 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 32484 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 32485 | .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 32486 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 32487 | } }, |
| | 32488 | }, .{ |
| | 32489 | .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null }, |
| | 32490 | .src_constraints = .{ |
| | 32491 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32492 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32493 | .any, |
| | 32494 | }, |
| | 32495 | .patterns = &.{ |
| | 32496 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 32497 | }, |
| | 32498 | .extra_temps = .{ |
| | 32499 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32500 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32501 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32502 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32503 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 32504 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 32505 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32506 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32507 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32508 | .unused, |
| | 32509 | .unused, |
| | 32510 | }, |
| | 32511 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 32512 | .clobbers = .{ .eflags = true }, |
| | 32513 | .each = .{ .once = &.{ |
| | 32514 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 32515 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 32516 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 32517 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 32518 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 32519 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 32520 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 32521 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 32522 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 32523 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 32524 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 32525 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 32526 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 32527 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 32528 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 32529 | .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ }, |
| | 32530 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 32531 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 32532 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 32533 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 32534 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 32535 | .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ }, |
| | 32536 | .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ }, |
| | 32537 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32538 | .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 32539 | .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ }, |
| | 32540 | .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, |
| | 32541 | .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ }, |
| | 32542 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 32543 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 32544 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 32545 | .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 32546 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 32547 | } }, |
| | 32548 | }, .{ |
| | 32549 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 32550 | .src_constraints = .{ |
| | 32551 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32552 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32553 | .any, |
| | 32554 | }, |
| | 32555 | .patterns = &.{ |
| | 32556 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 32557 | }, |
| | 32558 | .extra_temps = .{ |
| | 32559 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32560 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32561 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32562 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32563 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 32564 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 32565 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32566 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32567 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32568 | .unused, |
| | 32569 | .unused, |
| | 32570 | }, |
| | 32571 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 32572 | .clobbers = .{ .eflags = true }, |
| | 32573 | .each = .{ .once = &.{ |
| | 32574 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 32575 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 32576 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 32577 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 32578 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 32579 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 32580 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 32581 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 32582 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 32583 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 32584 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 32585 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 32586 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 32587 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 32588 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 32589 | .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ }, |
| | 32590 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 32591 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 32592 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 32593 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 32594 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 32595 | .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ }, |
| | 32596 | .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ }, |
| | 32597 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32598 | .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 32599 | .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ }, |
| | 32600 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 32601 | .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ }, |
| | 32602 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 32603 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 32604 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 32605 | .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 32606 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 32607 | } }, |
| | 32608 | }, .{ |
| | 32609 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| | 32610 | .src_constraints = .{ |
| | 32611 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32612 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32613 | .any, |
| | 32614 | }, |
| | 32615 | .patterns = &.{ |
| | 32616 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 32617 | }, |
| | 32618 | .extra_temps = .{ |
| | 32619 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32620 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32621 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32622 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32623 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32624 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 32625 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32626 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 32627 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 32628 | .unused, |
| | 32629 | .unused, |
| | 32630 | }, |
| | 32631 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 32632 | .clobbers = .{ .eflags = true }, |
| | 32633 | .each = .{ .once = &.{ |
| | 32634 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 32635 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 32636 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 32637 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 32638 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 32639 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 32640 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 32641 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 32642 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 32643 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 32644 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 32645 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 32646 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 32647 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 32648 | .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ }, |
| | 32649 | .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ }, |
| | 32650 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 32651 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 32652 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 32653 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 32654 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 32655 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 32656 | .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ }, |
| | 32657 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32658 | .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 32659 | .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ }, |
| | 32660 | .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, |
| | 32661 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| | 32662 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 32663 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 32664 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 32665 | .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 32666 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 32667 | } }, |
| | 32668 | }, .{ |
| | 32669 | .required_features = .{ .@"64bit", null, null, null }, |
| | 32670 | .src_constraints = .{ |
| | 32671 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32672 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32673 | .any, |
| | 32674 | }, |
| | 32675 | .patterns = &.{ |
| | 32676 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 32677 | }, |
| | 32678 | .extra_temps = .{ |
| | 32679 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32680 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32681 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32682 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32683 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32684 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 32685 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32686 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 32687 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 32688 | .unused, |
| | 32689 | .unused, |
| | 32690 | }, |
| | 32691 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 32692 | .clobbers = .{ .eflags = true }, |
| | 32693 | .each = .{ .once = &.{ |
| | 32694 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 32695 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 32696 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 32697 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 32698 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 32699 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 32700 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 32701 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 32702 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 32703 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 32704 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 32705 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 32706 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 32707 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 32708 | .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ }, |
| | 32709 | .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ }, |
| | 32710 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 32711 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 32712 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 32713 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 32714 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 32715 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 32716 | .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ }, |
| | 32717 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32718 | .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 32719 | .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ }, |
| | 32720 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 32721 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| | 32722 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 32723 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 32724 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 32725 | .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 32726 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 32727 | } }, |
| | 32728 | }, .{ |
| | 32729 | .required_features = .{ .@"64bit", .bmi2, .adx, null }, |
| | 32730 | .src_constraints = .{ |
| | 32731 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32732 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32733 | .any, |
| | 32734 | }, |
| | 32735 | .patterns = &.{ |
| | 32736 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 32737 | }, |
| | 32738 | .extra_temps = .{ |
| | 32739 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32740 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32741 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32742 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32743 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 32744 | .{ .type = .isize, .kind = .{ .reg = .rcx } }, |
| | 32745 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32746 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32747 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32748 | .unused, |
| | 32749 | .unused, |
| | 32750 | }, |
| | 32751 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 32752 | .clobbers = .{ .eflags = true }, |
| | 32753 | .each = .{ .once = &.{ |
| | 32754 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, |
| | 32755 | .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, |
| | 32756 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 32757 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| | 32758 | .{ .@"0:", ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 32759 | .{ ._, ._, .@"or", .tmp4q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 32760 | .{ ._, ._z, .j, .@"2f", ._, ._, ._ }, |
| | 32761 | .{ ._, ._, .lea, .tmp5p, .leaad(.tmp0, .sub_src0_size, 8), ._, ._ }, |
| | 32762 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 32763 | .{ .@"1:", ._x, .mul, .tmp8q, .tmp7q, .leai(.tmp1q, .tmp5), ._ }, |
| | 32764 | .{ ._, ._x, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 32765 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp5, .add_src0_size, -8), .tmp7q, ._, ._ }, |
| | 32766 | .{ ._, ._rcxz, .j, .@"1f", ._, ._, ._ }, |
| | 32767 | .{ ._, ._x, .ado, .tmp8q, .memia(.dst0q, .tmp5, .add_src0_size), ._, ._ }, |
| | 32768 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 32769 | .{ ._, ._, .lea, .tmp5p, .lead(.tmp5, 8), ._, ._ }, |
| | 32770 | .{ ._, ._mp, .j, .@"1b", ._, ._, ._ }, |
| | 32771 | .{ .@"2:", ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ }, |
| | 32772 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 32773 | .{ .@"1:", ._, .mov, .tmp4d, .tmp0d, ._, ._ }, |
| | 32774 | .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ }, |
| | 32775 | .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ }, |
| | 32776 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32777 | .{ .@"1:", ._, .@"or", .tmp8q, .leai(.tmp1q, .tmp4), ._, ._ }, |
| | 32778 | .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ }, |
| | 32779 | .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, |
| | 32780 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| | 32781 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 32782 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 32783 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 32784 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 32785 | .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -16), ._, ._ }, |
| | 32786 | .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 32787 | .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ }, |
| | 32788 | .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 32789 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ }, |
| | 32790 | .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ }, |
| | 32791 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 32792 | } }, |
| | 32793 | }, .{ |
| | 32794 | .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null }, |
| | 32795 | .src_constraints = .{ |
| | 32796 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32797 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32798 | .any, |
| | 32799 | }, |
| | 32800 | .patterns = &.{ |
| | 32801 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 32802 | }, |
| | 32803 | .extra_temps = .{ |
| | 32804 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32805 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32806 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32807 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32808 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 32809 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 32810 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32811 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32812 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32813 | .unused, |
| | 32814 | .unused, |
| | 32815 | }, |
| | 32816 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 32817 | .clobbers = .{ .eflags = true }, |
| | 32818 | .each = .{ .once = &.{ |
| | 32819 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 32820 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 32821 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 32822 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 32823 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 32824 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 32825 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 32826 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 32827 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 32828 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 32829 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 32830 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 32831 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 32832 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 32833 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 32834 | .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ }, |
| | 32835 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 32836 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 32837 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 32838 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 32839 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 32840 | .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ }, |
| | 32841 | .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ }, |
| | 32842 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32843 | .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 32844 | .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ }, |
| | 32845 | .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, |
| | 32846 | .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ }, |
| | 32847 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 32848 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 32849 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 32850 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 32851 | .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -16), ._, ._ }, |
| | 32852 | .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 32853 | .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ }, |
| | 32854 | .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 32855 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ }, |
| | 32856 | .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ }, |
| | 32857 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 32858 | } }, |
| | 32859 | }, .{ |
| | 32860 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 32861 | .src_constraints = .{ |
| | 32862 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32863 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32864 | .any, |
| | 32865 | }, |
| | 32866 | .patterns = &.{ |
| | 32867 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 32868 | }, |
| | 32869 | .extra_temps = .{ |
| | 32870 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32871 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32872 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32873 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32874 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 32875 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 32876 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32877 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32878 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32879 | .unused, |
| | 32880 | .unused, |
| | 32881 | }, |
| | 32882 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 32883 | .clobbers = .{ .eflags = true }, |
| | 32884 | .each = .{ .once = &.{ |
| | 32885 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 32886 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 32887 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 32888 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 32889 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 32890 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 32891 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 32892 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 32893 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 32894 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 32895 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 32896 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 32897 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 32898 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 32899 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 32900 | .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ }, |
| | 32901 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 32902 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 32903 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 32904 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 32905 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 32906 | .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ }, |
| | 32907 | .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ }, |
| | 32908 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32909 | .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 32910 | .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ }, |
| | 32911 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 32912 | .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ }, |
| | 32913 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 32914 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 32915 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 32916 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 32917 | .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -16), ._, ._ }, |
| | 32918 | .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 32919 | .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ }, |
| | 32920 | .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 32921 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ }, |
| | 32922 | .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ }, |
| | 32923 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 32924 | } }, |
| | 32925 | }, .{ |
| | 32926 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| | 32927 | .src_constraints = .{ |
| | 32928 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32929 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32930 | .any, |
| | 32931 | }, |
| | 32932 | .patterns = &.{ |
| | 32933 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 32934 | }, |
| | 32935 | .extra_temps = .{ |
| | 32936 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32937 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 32938 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32939 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 32940 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32941 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 32942 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 32943 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 32944 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 32945 | .unused, |
| | 32946 | .unused, |
| | 32947 | }, |
| | 32948 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 32949 | .clobbers = .{ .eflags = true }, |
| | 32950 | .each = .{ .once = &.{ |
| | 32951 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 32952 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 32953 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 32954 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 32955 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 32956 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 32957 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 32958 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 32959 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 32960 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 32961 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 32962 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 32963 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 32964 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 32965 | .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ }, |
| | 32966 | .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ }, |
| | 32967 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 32968 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 32969 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 32970 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 32971 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 32972 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 32973 | .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ }, |
| | 32974 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 32975 | .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 32976 | .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ }, |
| | 32977 | .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, |
| | 32978 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| | 32979 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 32980 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 32981 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 32982 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 32983 | .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -16), ._, ._ }, |
| | 32984 | .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 32985 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 32986 | .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 32987 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ }, |
| | 32988 | .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ }, |
| | 32989 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 32990 | } }, |
| | 32991 | }, .{ |
| | 32992 | .required_features = .{ .@"64bit", null, null, null }, |
| | 32993 | .src_constraints = .{ |
| | 32994 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32995 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| | 32996 | .any, |
| | 32997 | }, |
| | 32998 | .patterns = &.{ |
| | 32999 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 33000 | }, |
| | 33001 | .extra_temps = .{ |
| | 33002 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 33003 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33004 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33005 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 33006 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33007 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 33008 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33009 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 33010 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 33011 | .unused, |
| | 33012 | .unused, |
| | 33013 | }, |
| | 33014 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 33015 | .clobbers = .{ .eflags = true }, |
| | 33016 | .each = .{ .once = &.{ |
| | 33017 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 33018 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 33019 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 33020 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 33021 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 33022 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 33023 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 33024 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 33025 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 33026 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 33027 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 33028 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 33029 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 33030 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 33031 | .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ }, |
| | 33032 | .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ }, |
| | 33033 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 33034 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 33035 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 33036 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 33037 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 33038 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 33039 | .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ }, |
| | 33040 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 33041 | .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 33042 | .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ }, |
| | 33043 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 33044 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| | 33045 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 33046 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 33047 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 33048 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 33049 | .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -16), ._, ._ }, |
| | 33050 | .{ ._, ._, .@"or", .tmp2q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 33051 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 33052 | .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 33053 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -16), .tmp0q, ._, ._ }, |
| | 33054 | .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ }, |
| | 33055 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .ui(0), ._, ._ }, |
| | 33056 | } }, |
| | 33057 | }, .{ |
| | 33058 | .required_features = .{ .@"64bit", .bmi2, .adx, null }, |
| | 33059 | .src_constraints = .{ |
| | 33060 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 33061 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 33062 | .any, |
| | 33063 | }, |
| | 33064 | .patterns = &.{ |
| | 33065 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 33066 | }, |
| | 33067 | .extra_temps = .{ |
| | 33068 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 33069 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33070 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33071 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33072 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 33073 | .{ .type = .isize, .kind = .{ .reg = .rcx } }, |
| | 33074 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33075 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33076 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33077 | .unused, |
| | 33078 | .unused, |
| | 33079 | }, |
| | 33080 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 33081 | .clobbers = .{ .eflags = true }, |
| | 33082 | .each = .{ .once = &.{ |
| | 33083 | .{ ._, ._, .mov, .tmp0d, .sia(-8, .src0, .add_size), ._, ._ }, |
| | 33084 | .{ ._, ._, .lea, .tmp1p, .mem(.src1), ._, ._ }, |
| | 33085 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 33086 | .{ ._, ._, .xor, .tmp3d, .tmp3d, ._, ._ }, |
| | 33087 | .{ .@"0:", ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 33088 | .{ ._, ._, .@"or", .tmp4q, .memi(.src0q, .tmp0), ._, ._ }, |
| | 33089 | .{ ._, ._z, .j, .@"2f", ._, ._, ._ }, |
| | 33090 | .{ ._, ._, .lea, .tmp5p, .leaad(.tmp0, .sub_src0_size, 8), ._, ._ }, |
| | 33091 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 33092 | .{ .@"1:", ._x, .mul, .tmp8q, .tmp7q, .leai(.tmp1q, .tmp5), ._ }, |
| | 33093 | .{ ._, ._x, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 33094 | .{ ._, ._, .mov, .memiad(.dst0q, .tmp5, .add_src0_size, -8), .tmp7q, ._, ._ }, |
| | 33095 | .{ ._, ._rcxz, .j, .@"1f", ._, ._, ._ }, |
| | 33096 | .{ ._, ._x, .ado, .tmp8q, .memia(.dst0q, .tmp5, .add_src0_size), ._, ._ }, |
| | 33097 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 33098 | .{ ._, ._, .lea, .tmp5p, .lead(.tmp5, 8), ._, ._ }, |
| | 33099 | .{ ._, ._mp, .j, .@"1b", ._, ._, ._ }, |
| | 33100 | .{ .@"2:", ._, .mov, .memi(.dst0q, .tmp0), .tmp4q, ._, ._ }, |
| | 33101 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 33102 | .{ .@"1:", ._, .mov, .tmp4d, .tmp0d, ._, ._ }, |
| | 33103 | .{ ._, ._x, .ado, .tmp8q, .tmp3q, ._, ._ }, |
| | 33104 | .{ ._, ._x, .adc, .tmp8q, .tmp3q, ._, ._ }, |
| | 33105 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 33106 | .{ .@"1:", ._, .@"or", .tmp8q, .leai(.tmp1q, .tmp4), ._, ._ }, |
| | 33107 | .{ .@"2:", ._, .sub, .tmp4d, .si(8), ._, ._ }, |
| | 33108 | .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, |
| | 33109 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| | 33110 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 33111 | .{ ._, ._, .sub, .tmp0d, .si(8), ._, ._ }, |
| | 33112 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 33113 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 33114 | .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 33115 | .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ }, |
| | 33116 | .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 33117 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 33118 | .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ }, |
| | 33119 | } }, |
| | 33120 | }, .{ |
| | 33121 | .required_features = .{ .@"64bit", .bmi2, .slow_incdec, null }, |
| | 33122 | .src_constraints = .{ |
| | 33123 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 33124 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 33125 | .any, |
| | 33126 | }, |
| | 33127 | .patterns = &.{ |
| | 33128 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 33129 | }, |
| | 33130 | .extra_temps = .{ |
| | 33131 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 33132 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33133 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33134 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 33135 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 33136 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 33137 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33138 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33139 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33140 | .unused, |
| | 33141 | .unused, |
| | 33142 | }, |
| | 33143 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 33144 | .clobbers = .{ .eflags = true }, |
| | 33145 | .each = .{ .once = &.{ |
| | 33146 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 33147 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 33148 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 33149 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 33150 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 33151 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 33152 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 33153 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 33154 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 33155 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 33156 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 33157 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 33158 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 33159 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 33160 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 33161 | .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ }, |
| | 33162 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 33163 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 33164 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 33165 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 33166 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 33167 | .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ }, |
| | 33168 | .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ }, |
| | 33169 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 33170 | .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 33171 | .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ }, |
| | 33172 | .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, |
| | 33173 | .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ }, |
| | 33174 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 33175 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 33176 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 33177 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 33178 | .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 33179 | .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ }, |
| | 33180 | .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 33181 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 33182 | .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ }, |
| | 33183 | } }, |
| | 33184 | }, .{ |
| | 33185 | .required_features = .{ .@"64bit", .bmi2, null, null }, |
| | 33186 | .src_constraints = .{ |
| | 33187 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 33188 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 33189 | .any, |
| | 33190 | }, |
| | 33191 | .patterns = &.{ |
| | 33192 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 33193 | }, |
| | 33194 | .extra_temps = .{ |
| | 33195 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 33196 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33197 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33198 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 33199 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 33200 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 33201 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33202 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33203 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33204 | .unused, |
| | 33205 | .unused, |
| | 33206 | }, |
| | 33207 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 33208 | .clobbers = .{ .eflags = true }, |
| | 33209 | .each = .{ .once = &.{ |
| | 33210 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 33211 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 33212 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 33213 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 33214 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 33215 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 33216 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 33217 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 33218 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 33219 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 33220 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 33221 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 33222 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 33223 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 33224 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 33225 | .{ .@"2:", ._x, .mul, .tmp8q, .tmp7q, .leasi(.tmp1q, .@"8", .tmp3), ._ }, |
| | 33226 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 33227 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 33228 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 33229 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 33230 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 33231 | .{ ._, ._, .adc, .tmp5d, .tmp5d, ._, ._ }, |
| | 33232 | .{ ._, ._, .@"or", .tmp5q, .tmp8q, ._, ._ }, |
| | 33233 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 33234 | .{ .@"1:", ._, .@"or", .tmp5q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 33235 | .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ }, |
| | 33236 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 33237 | .{ ._, ._, .@"or", .tmp2q, .tmp5q, ._, ._ }, |
| | 33238 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 33239 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 33240 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 33241 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 33242 | .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 33243 | .{ ._, ._, .bzhi, .tmp0q, .tmp1q, .tmp0q, ._ }, |
| | 33244 | .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 33245 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 33246 | .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ }, |
| | 33247 | } }, |
| | 33248 | }, .{ |
| | 33249 | .required_features = .{ .@"64bit", .slow_incdec, null, null }, |
| | 33250 | .src_constraints = .{ |
| | 33251 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 33252 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 33253 | .any, |
| | 33254 | }, |
| | 33255 | .patterns = &.{ |
| | 33256 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 33257 | }, |
| | 33258 | .extra_temps = .{ |
| | 33259 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 33260 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33261 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33262 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 33263 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33264 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 33265 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33266 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 33267 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 33268 | .unused, |
| | 33269 | .unused, |
| | 33270 | }, |
| | 33271 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 33272 | .clobbers = .{ .eflags = true }, |
| | 33273 | .each = .{ .once = &.{ |
| | 33274 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 33275 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 33276 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 33277 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 33278 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 33279 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 33280 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 33281 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 33282 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 33283 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 33284 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 33285 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 33286 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 33287 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 33288 | .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ }, |
| | 33289 | .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ }, |
| | 33290 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 33291 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 33292 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 33293 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 33294 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 33295 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 33296 | .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ }, |
| | 33297 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 33298 | .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 33299 | .{ .@"2:", ._, .sub, .tmp3d, .si(1), ._, ._ }, |
| | 33300 | .{ ._, ._ae, .j, .@"1b", ._, ._, ._ }, |
| | 33301 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| | 33302 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 33303 | .{ ._, ._, .sub, .tmp0d, .si(1), ._, ._ }, |
| | 33304 | .{ ._, ._ae, .j, .@"0b", ._, ._, ._ }, |
| | 33305 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 33306 | .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 33307 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 33308 | .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 33309 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 33310 | .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ }, |
| | 33311 | } }, |
| | 33312 | }, .{ |
| | 33313 | .required_features = .{ .@"64bit", null, null, null }, |
| | 33314 | .src_constraints = .{ |
| | 33315 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 33316 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| | 33317 | .any, |
| | 33318 | }, |
| | 33319 | .patterns = &.{ |
| | 33320 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| | 33321 | }, |
| | 33322 | .extra_temps = .{ |
| | 33323 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 33324 | .{ .type = .usize, .kind = .{ .rc = .general_purpose } }, |
| | 33325 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33326 | .{ .type = .isize, .kind = .{ .rc = .general_purpose } }, |
| | 33327 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33328 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| | 33329 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 33330 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| | 33331 | .{ .type = .u64, .kind = .{ .reg = .rdx } }, |
| | 33332 | .unused, |
| | 33333 | .unused, |
| | 33334 | }, |
| | 33335 | .dst_temps = .{ .mem, .{ .cc = .nz } }, |
| | 33336 | .clobbers = .{ .eflags = true }, |
| | 33337 | .each = .{ .once = &.{ |
| | 33338 | .{ ._, ._, .mov, .tmp0d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| | 33339 | .{ ._, ._, .lea, .tmp1p, .memd(.src1, 8), ._, ._ }, |
| | 33340 | .{ ._, ._, .xor, .tmp2d, .tmp2d, ._, ._ }, |
| | 33341 | .{ .@"0:", ._, .lea, .tmp3p, .leaa(.tmp0, .sub_src0_size_div_8), ._, ._ }, |
| | 33342 | .{ ._, ._, .xor, .tmp4d, .tmp4d, ._, ._ }, |
| | 33343 | .{ ._, ._, .xor, .tmp5d, .tmp5d, ._, ._ }, |
| | 33344 | .{ ._, ._, .xor, .tmp6d, .tmp6d, ._, ._ }, |
| | 33345 | .{ ._, ._, .@"or", .tmp4q, .memsi(.src0q, .@"8", .tmp0), ._, ._ }, |
| | 33346 | .{ ._, ._nz, .j, .@"2f", ._, ._, ._ }, |
| | 33347 | .{ ._, ._, .mov, .memsi(.dst0q, .@"8", .tmp0), .tmp4q, ._, ._ }, |
| | 33348 | .{ ._, ._mp, .j, .@"3f", ._, ._, ._ }, |
| | 33349 | .{ .@"1:", ._, .adc, .tmp8q, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), ._, ._ }, |
| | 33350 | .{ ._, ._, .adc, .tmp5b, .si(0), ._, ._ }, |
| | 33351 | .{ ._, ._, .mov, .tmp6q, .tmp8q, ._, ._ }, |
| | 33352 | .{ .@"2:", ._, .mov, .tmp7q, .tmp4q, ._, ._ }, |
| | 33353 | .{ ._, ._, .mul, .leasi(.tmp1q, .@"8", .tmp3), ._, ._, ._ }, |
| | 33354 | .{ ._, ._l, .sh, .tmp5b, .ui(4), ._, ._ }, |
| | 33355 | .{ ._, ._, .adc, .tmp7q, .tmp6q, ._, ._ }, |
| | 33356 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp3, .add_src0_size), .tmp7q, ._, ._ }, |
| | 33357 | .{ ._, ._c, .in, .tmp3p, ._, ._, ._ }, |
| | 33358 | .{ ._, ._nz, .j, .@"1b", ._, ._, ._ }, |
| | 33359 | .{ ._, ._, .mov, .tmp3d, .tmp0d, ._, ._ }, |
| | 33360 | .{ ._, ._, .adc, .tmp8q, .si(0), ._, ._ }, |
| | 33361 | .{ ._, ._mp, .j, .@"2f", ._, ._, ._ }, |
| | 33362 | .{ .@"1:", ._, .@"or", .tmp8q, .leasi(.tmp1q, .@"8", .tmp3), ._, ._ }, |
| | 33363 | .{ .@"2:", ._c, .de, .tmp3d, ._, ._, ._ }, |
| | 33364 | .{ ._, ._ns, .j, .@"1b", ._, ._, ._ }, |
| | 33365 | .{ ._, ._, .@"or", .tmp2q, .tmp8q, ._, ._ }, |
| | 33366 | .{ .@"3:", ._, .lea, .tmp1p, .lead(.tmp1, 8), ._, ._ }, |
| | 33367 | .{ ._, ._c, .de, .tmp0d, ._, ._, ._ }, |
| | 33368 | .{ ._, ._ns, .j, .@"0b", ._, ._, ._ }, |
| | 33369 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| | 33370 | .{ ._, ._, .mov, .tmp1q, .memad(.dst0q, .add_src0_size, -8), ._, ._ }, |
| | 33371 | .{ ._, ._, .@"and", .tmp0q, .tmp1q, ._, ._ }, |
| | 33372 | .{ ._, ._r, .sh, .tmp1q, .ua(.src0, .add_bit_size_rem_64), ._, ._ }, |
| | 33373 | .{ ._, ._, .mov, .memad(.dst0q, .add_src0_size, -8), .tmp0q, ._, ._ }, |
| | 33374 | .{ ._, ._, .@"or", .tmp2q, .tmp1q, ._, ._ }, |
| | 33375 | } }, |
| | 33376 | } }) catch |err| switch (err) { |
| | 33377 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| | 33378 | @tagName(air_tag), |
| | 33379 | ty_pl.ty.toType().fmt(pt), |
| | 33380 | ops[0].tracking(cg), |
| | 33381 | ops[1].tracking(cg), |
| | 33382 | }), |
| | 33383 | else => |e| return e, |
| | 33384 | }; |
| | 33385 | try res[0].withOverflow(&res[1], cg); |
| | 33386 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| | 33387 | }, |
| 28022 | .alloc => if (use_old) try cg.airAlloc(inst) else { | 33388 | .alloc => if (use_old) try cg.airAlloc(inst) else { |
| 28023 | const ty = air_datas[@intFromEnum(inst)].ty; | 33389 | const ty = air_datas[@intFromEnum(inst)].ty; |
| 28024 | const slot = try cg.tempInit(ty, .{ .lea_frame = .{ | 33390 | const slot = try cg.tempInit(ty, .{ .lea_frame = .{ |
| ... | @@ -97522,9 +102888,6 @@ fn lowerSwitchBr( | ... | @@ -97522,9 +102888,6 @@ fn lowerSwitchBr( |
| 97522 | const relocs = try allocator.alloc(Mir.Inst.Index, case.items.len + case.ranges.len); | 102888 | const relocs = try allocator.alloc(Mir.Inst.Index, case.items.len + case.ranges.len); |
| 97523 | defer allocator.free(relocs); | 102889 | defer allocator.free(relocs); |
| 97524 | | 102890 | |
| 97525 | var cond_temp = try cg.tempInit(condition_ty, condition); | | |
| 97526 | const reset_index = cg.next_temp_index; | | |
| 97527 | | | |
| 97528 | try cg.spillEflagsIfOccupied(); | 102891 | try cg.spillEflagsIfOccupied(); |
| 97529 | for (case.items, relocs[0..case.items.len]) |item, *reloc| { | 102892 | for (case.items, relocs[0..case.items.len]) |item, *reloc| { |
| 97530 | const item_mcv = try cg.resolveInst(item); | 102893 | const item_mcv = try cg.resolveInst(item); |
| ... | @@ -97535,6 +102898,7 @@ fn lowerSwitchBr( | ... | @@ -97535,6 +102898,7 @@ fn lowerSwitchBr( |
| 97535 | else => unreachable, | 102898 | else => unreachable, |
| 97536 | }, | 102899 | }, |
| 97537 | else => cc: { | 102900 | else => cc: { |
| | 102901 | var cond_temp = try cg.tempInit(condition_ty, condition); |
| 97538 | var item_temp = try cg.tempInit(condition_ty, item_mcv); | 102902 | var item_temp = try cg.tempInit(condition_ty, item_mcv); |
| 97539 | const cc_temp = cond_temp.cmpInts(.eq, &item_temp, cg) catch |err| switch (err) { | 102903 | const cc_temp = cond_temp.cmpInts(.eq, &item_temp, cg) catch |err| switch (err) { |
| 97540 | error.SelectFailed => unreachable, | 102904 | error.SelectFailed => unreachable, |
| ... | @@ -97543,7 +102907,8 @@ fn lowerSwitchBr( | ... | @@ -97543,7 +102907,8 @@ fn lowerSwitchBr( |
| 97543 | try item_temp.die(cg); | 102907 | try item_temp.die(cg); |
| 97544 | const cc = cc_temp.tracking(cg).short.eflags; | 102908 | const cc = cc_temp.tracking(cg).short.eflags; |
| 97545 | try cc_temp.die(cg); | 102909 | try cc_temp.die(cg); |
| 97546 | try cg.resetTemps(reset_index); | 102910 | try cond_temp.die(cg); |
| | 102911 | try cg.resetTemps(@enumFromInt(0)); |
| 97547 | break :cc cc; | 102912 | break :cc cc; |
| 97548 | }, | 102913 | }, |
| 97549 | }; | 102914 | }; |
| ... | @@ -97551,6 +102916,7 @@ fn lowerSwitchBr( | ... | @@ -97551,6 +102916,7 @@ fn lowerSwitchBr( |
| 97551 | } | 102916 | } |
| 97552 | | 102917 | |
| 97553 | for (case.ranges, relocs[case.items.len..]) |range, *reloc| { | 102918 | for (case.ranges, relocs[case.items.len..]) |range, *reloc| { |
| | 102919 | var cond_temp = try cg.tempInit(condition_ty, condition); |
| 97554 | const min_mcv = try cg.resolveInst(range[0]); | 102920 | const min_mcv = try cg.resolveInst(range[0]); |
| 97555 | const max_mcv = try cg.resolveInst(range[1]); | 102921 | const max_mcv = try cg.resolveInst(range[1]); |
| 97556 | // `null` means always false. | 102922 | // `null` means always false. |
| ... | @@ -97594,7 +102960,8 @@ fn lowerSwitchBr( | ... | @@ -97594,7 +102960,8 @@ fn lowerSwitchBr( |
| 97594 | break :cc cc; | 102960 | break :cc cc; |
| 97595 | }, | 102961 | }, |
| 97596 | }; | 102962 | }; |
| 97597 | try cg.resetTemps(reset_index); | 102963 | try cond_temp.die(cg); |
| | 102964 | try cg.resetTemps(@enumFromInt(0)); |
| 97598 | // "Success" case is in `reloc`.... | 102965 | // "Success" case is in `reloc`.... |
| 97599 | if (lte_max) |cc| { | 102966 | if (lte_max) |cc| { |
| 97600 | reloc.* = try cg.asmJccReloc(cc, undefined); | 102967 | reloc.* = try cg.asmJccReloc(cc, undefined); |
| ... | @@ -97605,8 +102972,6 @@ fn lowerSwitchBr( | ... | @@ -97605,8 +102972,6 @@ fn lowerSwitchBr( |
| 97605 | if (lt_min_reloc) |r| cg.performReloc(r); | 102972 | if (lt_min_reloc) |r| cg.performReloc(r); |
| 97606 | } | 102973 | } |
| 97607 | | 102974 | |
| 97608 | try cond_temp.die(cg); | | |
| 97609 | try cg.resetTemps(@enumFromInt(0)); | | |
| 97610 | cg.checkInvariantsAfterAirInst(); | 102975 | cg.checkInvariantsAfterAirInst(); |
| 97611 | | 102976 | |
| 97612 | // The jump to skip this case if the conditions all failed. | 102977 | // The jump to skip this case if the conditions all failed. |
| ... | @@ -97813,6 +103178,19 @@ fn performReloc(self: *CodeGen, reloc: Mir.Inst.Index) void { | ... | @@ -97813,6 +103178,19 @@ fn performReloc(self: *CodeGen, reloc: Mir.Inst.Index) void { |
| 97813 | .pseudo_j_z_and_np_inst, .pseudo_j_nz_or_p_inst => {}, | 103178 | .pseudo_j_z_and_np_inst, .pseudo_j_nz_or_p_inst => {}, |
| 97814 | else => unreachable, | 103179 | else => unreachable, |
| 97815 | }, | 103180 | }, |
| | 103181 | .lea => switch (self.mir_instructions.items(.ops)[reloc]) { |
| | 103182 | .rm => { |
| | 103183 | const rx = self.mir_instructions.items(.data)[reloc].rx; |
| | 103184 | assert(rx.fixes == ._); |
| | 103185 | const mem_info: Mir.Memory.Info = @bitCast( |
| | 103186 | self.mir_extra.items[rx.payload + std.meta.fieldIndex(Mir.Memory, "info").?], |
| | 103187 | ); |
| | 103188 | assert(mem_info.base == .rip_inst); |
| | 103189 | self.mir_extra.items[rx.payload + std.meta.fieldIndex(Mir.Memory, "base").?] = next_inst; |
| | 103190 | return; |
| | 103191 | }, |
| | 103192 | else => unreachable, |
| | 103193 | }, |
| 97816 | else => unreachable, | 103194 | else => unreachable, |
| 97817 | } | 103195 | } |
| 97818 | self.mir_instructions.items(.data)[reloc].inst.inst = next_inst; | 103196 | self.mir_instructions.items(.data)[reloc].inst.inst = next_inst; |
| ... | @@ -98096,7 +103474,10 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -98096,7 +103474,10 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 98096 | // for the string, we still use the next u32 for the null terminator. | 103474 | // for the string, we still use the next u32 for the null terminator. |
| 98097 | extra_i += clobber.len / 4 + 1; | 103475 | extra_i += clobber.len / 4 + 1; |
| 98098 | | 103476 | |
| 98099 | if (std.mem.eql(u8, clobber, "") or std.mem.eql(u8, clobber, "memory")) { | 103477 | if (std.mem.eql(u8, clobber, "") or std.mem.eql(u8, clobber, "memory") or |
| | 103478 | std.mem.eql(u8, clobber, "fpsr") or std.mem.eql(u8, clobber, "fpcr") or |
| | 103479 | std.mem.eql(u8, clobber, "mxcsr") or std.mem.eql(u8, clobber, "dirflag")) |
| | 103480 | { |
| 98100 | // ok, sure | 103481 | // ok, sure |
| 98101 | } else if (std.mem.eql(u8, clobber, "cc") or | 103482 | } else if (std.mem.eql(u8, clobber, "cc") or |
| 98102 | std.mem.eql(u8, clobber, "flags") or | 103483 | std.mem.eql(u8, clobber, "flags") or |
| ... | @@ -98361,7 +103742,24 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -98361,7 +103742,24 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 98361 | else | 103742 | else |
| 98362 | .@"1"; | 103743 | .@"1"; |
| 98363 | if (sib_it.next()) |_| return self.fail("invalid memory operand: '{s}'", .{op_str}); | 103744 | if (sib_it.next()) |_| return self.fail("invalid memory operand: '{s}'", .{op_str}); |
| 98364 | op.* = if (std.mem.eql(u8, base_str, "%%dx") and index_str.len == 0) .{ .reg = .dx } else .{ .mem = .{ | 103745 | op.* = if (std.mem.eql(u8, base_str, "%%dx") and index_str.len == 0) |
| | 103746 | .{ .reg = .dx } |
| | 103747 | else if (std.mem.eql(u8, base_str, "%%rip") and index_str.len == 0 and |
| | 103748 | Label.isValid(.reference, op_str[0..open])) |
| | 103749 | op: { |
| | 103750 | const anon = std.ascii.isDigit(op_str[0]); |
| | 103751 | const label_gop = try labels.getOrPut(self.gpa, op_str[0..if (anon) 1 else open]); |
| | 103752 | if (anon and (op_str[1] == 'b' or op_str[1] == 'B') and !label_gop.found_existing) |
| | 103753 | return self.fail("undefined label: '{s}'", .{op_str}); |
| | 103754 | if (!label_gop.found_existing) label_gop.value_ptr.* = .{}; |
| | 103755 | const pending_relocs = &label_gop.value_ptr.pending_relocs; |
| | 103756 | if (if (anon) |
| | 103757 | op_str[1] == 'f' or op_str[1] == 'F' |
| | 103758 | else |
| | 103759 | !label_gop.found_existing or pending_relocs.items.len > 0) |
| | 103760 | try pending_relocs.append(self.gpa, @intCast(self.mir_instructions.len)); |
| | 103761 | break :op .{ .mem = .{ .base = .{ .rip_inst = label_gop.value_ptr.target } } }; |
| | 103762 | } else .{ .mem = .{ |
| 98365 | .base = if (base_str.len > 0) | 103763 | .base = if (base_str.len > 0) |
| 98366 | .{ .reg = parseRegName(base_str["%%".len..]) orelse | 103764 | .{ .reg = parseRegName(base_str["%%".len..]) orelse |
| 98367 | return self.fail("invalid base register: '{s}'", .{base_str}) } | 103765 | return self.fail("invalid base register: '{s}'", .{base_str}) } |
| ... | @@ -98405,9 +103803,9 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -98405,9 +103803,9 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 98405 | } else if (Label.isValid(.reference, op_str)) { | 103803 | } else if (Label.isValid(.reference, op_str)) { |
| 98406 | const anon = std.ascii.isDigit(op_str[0]); | 103804 | const anon = std.ascii.isDigit(op_str[0]); |
| 98407 | const label_gop = try labels.getOrPut(self.gpa, op_str[0..if (anon) 1 else op_str.len]); | 103805 | const label_gop = try labels.getOrPut(self.gpa, op_str[0..if (anon) 1 else op_str.len]); |
| 98408 | if (!label_gop.found_existing) label_gop.value_ptr.* = .{}; | | |
| 98409 | if (anon and (op_str[1] == 'b' or op_str[1] == 'B') and !label_gop.found_existing) | 103806 | if (anon and (op_str[1] == 'b' or op_str[1] == 'B') and !label_gop.found_existing) |
| 98410 | return self.fail("undefined label: '{s}'", .{op_str}); | 103807 | return self.fail("undefined label: '{s}'", .{op_str}); |
| | 103808 | if (!label_gop.found_existing) label_gop.value_ptr.* = .{}; |
| 98411 | const pending_relocs = &label_gop.value_ptr.pending_relocs; | 103809 | const pending_relocs = &label_gop.value_ptr.pending_relocs; |
| 98412 | if (if (anon) | 103810 | if (if (anon) |
| 98413 | op_str[1] == 'f' or op_str[1] == 'F' | 103811 | op_str[1] == 'f' or op_str[1] == 'F' |
| ... | @@ -99643,7 +105041,7 @@ fn genSetMem( | ... | @@ -99643,7 +105041,7 @@ fn genSetMem( |
| 99643 | .none => .{ .immediate = @bitCast(@as(i64, disp)) }, | 105041 | .none => .{ .immediate = @bitCast(@as(i64, disp)) }, |
| 99644 | .reg => |base_reg| .{ .register_offset = .{ .reg = base_reg, .off = disp } }, | 105042 | .reg => |base_reg| .{ .register_offset = .{ .reg = base_reg, .off = disp } }, |
| 99645 | .frame => |base_frame_index| .{ .lea_frame = .{ .index = base_frame_index, .off = disp } }, | 105043 | .frame => |base_frame_index| .{ .lea_frame = .{ .index = base_frame_index, .off = disp } }, |
| 99646 | .table => unreachable, | 105044 | .table, .rip_inst => unreachable, |
| 99647 | .reloc => |sym_index| .{ .lea_symbol = .{ .sym_index = sym_index, .off = disp } }, | 105045 | .reloc => |sym_index| .{ .lea_symbol = .{ .sym_index = sym_index, .off = disp } }, |
| 99648 | }; | 105046 | }; |
| 99649 | switch (src_mcv) { | 105047 | switch (src_mcv) { |
| ... | @@ -99753,7 +105151,7 @@ fn genSetMem( | ... | @@ -99753,7 +105151,7 @@ fn genSetMem( |
| 99753 | .index = frame_index, | 105151 | .index = frame_index, |
| 99754 | .off = disp, | 105152 | .off = disp, |
| 99755 | }).compare(.gte, src_align), | 105153 | }).compare(.gte, src_align), |
| 99756 | .table => unreachable, | 105154 | .table, .rip_inst => unreachable, |
| 99757 | .reloc => false, | 105155 | .reloc => false, |
| 99758 | })).write( | 105156 | })).write( |
| 99759 | self, | 105157 | self, |
| ... | @@ -100402,7 +105800,7 @@ fn airCmpxchg(self: *CodeGen, inst: Air.Inst.Index) !void { | ... | @@ -100402,7 +105800,7 @@ fn airCmpxchg(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 100402 | const ptr_lock = switch (ptr_mem.base) { | 105800 | const ptr_lock = switch (ptr_mem.base) { |
| 100403 | .none, .frame, .reloc => null, | 105801 | .none, .frame, .reloc => null, |
| 100404 | .reg => |reg| self.register_manager.lockReg(reg), | 105802 | .reg => |reg| self.register_manager.lockReg(reg), |
| 100405 | .table => unreachable, | 105803 | .table, .rip_inst => unreachable, |
| 100406 | }; | 105804 | }; |
| 100407 | defer if (ptr_lock) |lock| self.register_manager.unlockReg(lock); | 105805 | defer if (ptr_lock) |lock| self.register_manager.unlockReg(lock); |
| 100408 | | 105806 | |
| ... | @@ -100485,7 +105883,7 @@ fn atomicOp( | ... | @@ -100485,7 +105883,7 @@ fn atomicOp( |
| 100485 | const mem_lock = switch (ptr_mem.base) { | 105883 | const mem_lock = switch (ptr_mem.base) { |
| 100486 | .none, .frame, .reloc => null, | 105884 | .none, .frame, .reloc => null, |
| 100487 | .reg => |reg| self.register_manager.lockReg(reg), | 105885 | .reg => |reg| self.register_manager.lockReg(reg), |
| 100488 | .table => unreachable, | 105886 | .table, .rip_inst => unreachable, |
| 100489 | }; | 105887 | }; |
| 100490 | defer if (mem_lock) |lock| self.register_manager.unlockReg(lock); | 105888 | defer if (mem_lock) |lock| self.register_manager.unlockReg(lock); |
| 100491 | | 105889 | |
| ... | @@ -103624,40 +109022,35 @@ fn resolveInst(self: *CodeGen, ref: Air.Inst.Ref) InnerError!MCValue { | ... | @@ -103624,40 +109022,35 @@ fn resolveInst(self: *CodeGen, ref: Air.Inst.Ref) InnerError!MCValue { |
| 103624 | // If the type has no codegen bits, no need to store it. | 109022 | // If the type has no codegen bits, no need to store it. |
| 103625 | if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return .none; | 109023 | if (!ty.hasRuntimeBitsIgnoreComptime(zcu)) return .none; |
| 103626 | | 109024 | |
| 103627 | const mcv = if (ref.toIndex()) |inst| mcv: { | 109025 | const mcv: MCValue = if (ref.toIndex()) |inst| mcv: { |
| 103628 | break :mcv self.inst_tracking.getPtr(inst).?.short; | 109026 | break :mcv self.inst_tracking.getPtr(inst).?.short; |
| 103629 | } else mcv: { | 109027 | } else mcv: { |
| 103630 | const ip_index = ref.toInterned().?; | 109028 | const const_mcv = try self.genTypedValue(.fromInterned(ref.toInterned().?)); |
| 103631 | const gop = try self.const_tracking.getOrPut(self.gpa, ip_index); | 109029 | switch (const_mcv) { |
| 103632 | if (!gop.found_existing) gop.value_ptr.* = .init(init: { | 109030 | .lea_tlv => |tlv_sym| switch (self.bin_file.tag) { |
| 103633 | const const_mcv = try self.genTypedValue(.fromInterned(ip_index)); | 109031 | .elf, .macho => { |
| 103634 | switch (const_mcv) { | 109032 | if (self.mod.pic) { |
| 103635 | .lea_tlv => |tlv_sym| switch (self.bin_file.tag) { | 109033 | try self.spillRegisters(&.{ .rdi, .rax }); |
| 103636 | .elf, .macho => { | 109034 | } else { |
| 103637 | if (self.mod.pic) { | 109035 | try self.spillRegisters(&.{.rax}); |
| 103638 | try self.spillRegisters(&.{ .rdi, .rax }); | 109036 | } |
| 103639 | } else { | 109037 | const frame_index = try self.allocFrameIndex(.init(.{ |
| 103640 | try self.spillRegisters(&.{.rax}); | 109038 | .size = 8, |
| 103641 | } | 109039 | .alignment = .@"8", |
| 103642 | const frame_index = try self.allocFrameIndex(.init(.{ | 109040 | })); |
| 103643 | .size = 8, | 109041 | try self.genSetMem( |
| 103644 | .alignment = .@"8", | 109042 | .{ .frame = frame_index }, |
| 103645 | })); | 109043 | 0, |
| 103646 | try self.genSetMem( | 109044 | .usize, |
| 103647 | .{ .frame = frame_index }, | 109045 | .{ .lea_symbol = .{ .sym_index = tlv_sym } }, |
| 103648 | 0, | 109046 | .{}, |
| 103649 | .usize, | 109047 | ); |
| 103650 | .{ .lea_symbol = .{ .sym_index = tlv_sym } }, | 109048 | break :mcv .{ .load_frame = .{ .index = frame_index } }; |
| 103651 | .{}, | | |
| 103652 | ); | | |
| 103653 | break :init .{ .load_frame = .{ .index = frame_index } }; | | |
| 103654 | }, | | |
| 103655 | else => break :init const_mcv, | | |
| 103656 | }, | 109049 | }, |
| 103657 | else => break :init const_mcv, | 109050 | else => break :mcv const_mcv, |
| 103658 | } | 109051 | }, |
| 103659 | }); | 109052 | else => break :mcv const_mcv, |
| 103660 | break :mcv gop.value_ptr.short; | 109053 | } |
| 103661 | }; | 109054 | }; |
| 103662 | | 109055 | |
| 103663 | switch (mcv) { | 109056 | switch (mcv) { |
| ... | @@ -104205,13 +109598,21 @@ fn memSize(self: *CodeGen, ty: Type) Memory.Size { | ... | @@ -104205,13 +109598,21 @@ fn memSize(self: *CodeGen, ty: Type) Memory.Size { |
| 104205 | fn splitType(self: *CodeGen, comptime parts_len: usize, ty: Type) ![parts_len]Type { | 109598 | fn splitType(self: *CodeGen, comptime parts_len: usize, ty: Type) ![parts_len]Type { |
| 104206 | const pt = self.pt; | 109599 | const pt = self.pt; |
| 104207 | const zcu = pt.zcu; | 109600 | const zcu = pt.zcu; |
| | 109601 | const ip = &zcu.intern_pool; |
| 104208 | var parts: [parts_len]Type = undefined; | 109602 | var parts: [parts_len]Type = undefined; |
| 104209 | if (ty.isVector(zcu)) if (std.math.divExact(u32, ty.vectorLen(zcu), parts_len)) |vec_len| return .{ | 109603 | switch (ip.indexToKey(ty.toIntern())) { |
| 104210 | try pt.vectorType(.{ .len = vec_len, .child = ty.scalarType(zcu).toIntern() }), | 109604 | .vector_type => |vector_type| if (std.math.divExact(u32, vector_type.len, parts_len)) |vec_len| return .{ |
| 104211 | } ** parts_len else |err| switch (err) { | 109605 | try pt.vectorType(.{ .len = vec_len, .child = vector_type.child }), |
| 104212 | error.DivisionByZero => unreachable, | 109606 | } ** parts_len else |err| switch (err) { |
| 104213 | error.UnexpectedRemainder => {}, | 109607 | error.DivisionByZero => unreachable, |
| 104214 | }; | 109608 | error.UnexpectedRemainder => {}, |
| | 109609 | }, |
| | 109610 | .tuple_type => |tuple_type| if (tuple_type.types.len == parts_len) { |
| | 109611 | for (&parts, tuple_type.types.get(ip)) |*part, part_ty| part.* = .fromInterned(part_ty); |
| | 109612 | return parts; |
| | 109613 | }, |
| | 109614 | else => {}, |
| | 109615 | } |
| 104215 | const classes = std.mem.sliceTo(&abi.classifySystemV(ty, zcu, self.target, .other), .none); | 109616 | const classes = std.mem.sliceTo(&abi.classifySystemV(ty, zcu, self.target, .other), .none); |
| 104216 | if (classes.len == parts_len) for (&parts, classes, 0..) |*part, class, part_i| { | 109617 | if (classes.len == parts_len) for (&parts, classes, 0..) |*part, class, part_i| { |
| 104217 | part.* = switch (class) { | 109618 | part.* = switch (class) { |
| ... | @@ -104896,6 +110297,52 @@ const Temp = struct { | ... | @@ -104896,6 +110297,52 @@ const Temp = struct { |
| 104896 | second_temp.* = result_temp; | 110297 | second_temp.* = result_temp; |
| 104897 | } | 110298 | } |
| 104898 | | 110299 | |
| | 110300 | fn withOverflow(temp: *Temp, overflow_temp: *Temp, cg: *CodeGen) InnerError!void { |
| | 110301 | const temp_index = temp.unwrap(cg).temp; |
| | 110302 | const temp_tracking = temp_index.tracking(cg); |
| | 110303 | const overflow_temp_tracking = overflow_temp.unwrap(cg).temp.tracking(cg); |
| | 110304 | switch (temp_tracking.short) { |
| | 110305 | .register => |reg| switch (overflow_temp_tracking.short) { |
| | 110306 | .eflags => |overflow_cc| { |
| | 110307 | const result_temp_index = cg.next_temp_index; |
| | 110308 | const result_temp: Temp = .{ .index = result_temp_index.toIndex() }; |
| | 110309 | assert(cg.reuseTemp(result_temp.index, temp.index, temp_tracking)); |
| | 110310 | assert(cg.reuseTemp(result_temp.index, overflow_temp.index, overflow_temp_tracking)); |
| | 110311 | result_temp_index.tracking(cg).* = .init(.{ .register_overflow = .{ .reg = reg, .eflags = overflow_cc } }); |
| | 110312 | cg.temp_type[@intFromEnum(result_temp_index)] = .slice_const_u8; |
| | 110313 | cg.next_temp_index = @enumFromInt(@intFromEnum(result_temp_index) + 1); |
| | 110314 | temp.* = result_temp; |
| | 110315 | overflow_temp.* = result_temp; |
| | 110316 | return; |
| | 110317 | }, |
| | 110318 | .register => |overflow_reg| { |
| | 110319 | const result_temp_index = cg.next_temp_index; |
| | 110320 | const result_temp: Temp = .{ .index = result_temp_index.toIndex() }; |
| | 110321 | assert(cg.reuseTemp(result_temp.index, temp.index, temp_tracking)); |
| | 110322 | assert(cg.reuseTemp(result_temp.index, overflow_temp.index, overflow_temp_tracking)); |
| | 110323 | result_temp_index.tracking(cg).* = .init(.{ .register_pair = .{ reg, overflow_reg } }); |
| | 110324 | cg.temp_type[@intFromEnum(result_temp_index)] = .slice_const_u8; |
| | 110325 | cg.next_temp_index = @enumFromInt(@intFromEnum(result_temp_index) + 1); |
| | 110326 | temp.* = result_temp; |
| | 110327 | overflow_temp.* = result_temp; |
| | 110328 | return; |
| | 110329 | }, |
| | 110330 | else => {}, |
| | 110331 | }, |
| | 110332 | .load_frame => { |
| | 110333 | const zcu = cg.pt.zcu; |
| | 110334 | const ip = &zcu.intern_pool; |
| | 110335 | const field_tys = ip.indexToKey(temp_index.typeOf(cg).toIntern()).tuple_type.types.get(ip); |
| | 110336 | try temp.write(overflow_temp, .{ .disp = @intCast(Type.fromInterned(field_tys[0]).abiSize(zcu)) }, cg); |
| | 110337 | try overflow_temp.die(cg); |
| | 110338 | overflow_temp.* = temp.*; |
| | 110339 | return; |
| | 110340 | }, |
| | 110341 | else => {}, |
| | 110342 | } |
| | 110343 | std.debug.panic("{s}: {} {}\n", .{ @src().fn_name, temp_tracking, overflow_temp_tracking }); |
| | 110344 | } |
| | 110345 | |
| 104899 | fn asMask(temp: Temp, info: MaskInfo, cg: *CodeGen) void { | 110346 | fn asMask(temp: Temp, info: MaskInfo, cg: *CodeGen) void { |
| 104900 | assert(info.scalar != .none); | 110347 | assert(info.scalar != .none); |
| 104901 | const mcv = &temp.unwrap(cg).temp.tracking(cg).short; | 110348 | const mcv = &temp.unwrap(cg).temp.tracking(cg).short; |
| ... | @@ -105581,6 +111028,42 @@ const Temp = struct { | ... | @@ -105581,6 +111028,42 @@ const Temp = struct { |
| 105581 | }, | 111028 | }, |
| 105582 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, | 111029 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 105583 | .each = .{ .once = &.{} }, | 111030 | .each = .{ .once = &.{} }, |
| | 111031 | }, .{ |
| | 111032 | .required_features = .{ .@"64bit", null, null, null }, |
| | 111033 | .src_constraints = .{ .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| | 111034 | .patterns = &.{ |
| | 111035 | .{ .src = .{ .mut_mem, .none, .none } }, |
| | 111036 | }, |
| | 111037 | .extra_temps = .{ |
| | 111038 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| | 111039 | .unused, |
| | 111040 | .unused, |
| | 111041 | .unused, |
| | 111042 | .unused, |
| | 111043 | .unused, |
| | 111044 | .unused, |
| | 111045 | .unused, |
| | 111046 | .unused, |
| | 111047 | .unused, |
| | 111048 | .unused, |
| | 111049 | }, |
| | 111050 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 111051 | .clobbers = .{ .eflags = true }, |
| | 111052 | .each = .{ .once = &.{ |
| | 111053 | .{ ._, ._, .mov, .tmp0q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| | 111054 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| | 111055 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp0q, ._, ._ }, |
| | 111056 | } }, |
| | 111057 | }, .{ |
| | 111058 | .required_features = .{ .@"64bit", null, null, null }, |
| | 111059 | .src_constraints = .{ .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| | 111060 | .patterns = &.{ |
| | 111061 | .{ .src = .{ .mut_mem, .none, .none } }, |
| | 111062 | }, |
| | 111063 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| | 111064 | .each = .{ .once = &.{ |
| | 111065 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| | 111066 | } }, |
| 105584 | }, .{ | 111067 | }, .{ |
| 105585 | .required_features = .{ .@"64bit", null, null, null }, | 111068 | .required_features = .{ .@"64bit", null, null, null }, |
| 105586 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any }, | 111069 | .src_constraints = .{ .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, .any, .any }, |
| ... | @@ -109803,8 +115286,7 @@ fn tempFromOperand(cg: *CodeGen, op_ref: Air.Inst.Ref, op_dies: bool) InnerError | ... | @@ -109803,8 +115286,7 @@ fn tempFromOperand(cg: *CodeGen, op_ref: Air.Inst.Ref, op_dies: bool) InnerError |
| 109803 | | 115286 | |
| 109804 | if (op_ref.toIndex()) |op_inst| return .{ .index = op_inst }; | 115287 | if (op_ref.toIndex()) |op_inst| return .{ .index = op_inst }; |
| 109805 | const val = op_ref.toInterned().?; | 115288 | const val = op_ref.toInterned().?; |
| 109806 | const gop = try cg.const_tracking.getOrPut(cg.gpa, val); | 115289 | return cg.tempInit(.fromInterned(ip.typeOf(val)), init: { |
| 109807 | if (!gop.found_existing) gop.value_ptr.* = .init(init: { | | |
| 109808 | const const_mcv = try cg.genTypedValue(.fromInterned(val)); | 115290 | const const_mcv = try cg.genTypedValue(.fromInterned(val)); |
| 109809 | switch (const_mcv) { | 115291 | switch (const_mcv) { |
| 109810 | .lea_tlv => |tlv_sym| switch (cg.bin_file.tag) { | 115292 | .lea_tlv => |tlv_sym| switch (cg.bin_file.tag) { |
| ... | @@ -109832,7 +115314,6 @@ fn tempFromOperand(cg: *CodeGen, op_ref: Air.Inst.Ref, op_dies: bool) InnerError | ... | @@ -109832,7 +115314,6 @@ fn tempFromOperand(cg: *CodeGen, op_ref: Air.Inst.Ref, op_dies: bool) InnerError |
| 109832 | else => break :init const_mcv, | 115314 | else => break :init const_mcv, |
| 109833 | } | 115315 | } |
| 109834 | }); | 115316 | }); |
| 109835 | return cg.tempInit(.fromInterned(ip.typeOf(val)), gop.value_ptr.short); | | |
| 109836 | } | 115317 | } |
| 109837 | | 115318 | |
| 109838 | fn tempsFromOperandsInner( | 115319 | fn tempsFromOperandsInner( |
| ... | @@ -110330,6 +115811,7 @@ const Select = struct { | ... | @@ -110330,6 +115811,7 @@ const Select = struct { |
| 110330 | mut_mem, | 115811 | mut_mem, |
| 110331 | to_mut_mem, | 115812 | to_mut_mem, |
| 110332 | gpr, | 115813 | gpr, |
| | 115814 | immut_gpr, |
| 110333 | to_gpr, | 115815 | to_gpr, |
| 110334 | mut_gpr, | 115816 | mut_gpr, |
| 110335 | to_mut_gpr, | 115817 | to_mut_gpr, |
| ... | @@ -110362,15 +115844,18 @@ const Select = struct { | ... | @@ -110362,15 +115844,18 @@ const Select = struct { |
| 110362 | return switch (src) { | 115844 | return switch (src) { |
| 110363 | .none => temp.tracking(cg).short == .none, | 115845 | .none => temp.tracking(cg).short == .none, |
| 110364 | .imm8 => switch (temp.tracking(cg).short) { | 115846 | .imm8 => switch (temp.tracking(cg).short) { |
| 110365 | .immediate => |imm| std.math.cast(u8, imm) != null, | 115847 | .immediate => |imm| std.math.cast(u8, imm) != null or |
| | 115848 | std.math.cast(i8, @as(i64, @bitCast(imm))) != null, |
| 110366 | else => false, | 115849 | else => false, |
| 110367 | }, | 115850 | }, |
| 110368 | .imm16 => switch (temp.tracking(cg).short) { | 115851 | .imm16 => switch (temp.tracking(cg).short) { |
| 110369 | .immediate => |imm| std.math.cast(u16, imm) != null, | 115852 | .immediate => |imm| std.math.cast(u16, imm) != null or |
| | 115853 | std.math.cast(i16, @as(i64, @bitCast(imm))) != null, |
| 110370 | else => false, | 115854 | else => false, |
| 110371 | }, | 115855 | }, |
| 110372 | .imm32 => switch (temp.tracking(cg).short) { | 115856 | .imm32 => switch (temp.tracking(cg).short) { |
| 110373 | .immediate => |imm| std.math.cast(u32, imm) != null, | 115857 | .immediate => |imm| std.math.cast(u32, imm) != null or |
| | 115858 | std.math.cast(i32, @as(i64, @bitCast(imm))) != null, |
| 110374 | else => false, | 115859 | else => false, |
| 110375 | }, | 115860 | }, |
| 110376 | .simm32 => switch (temp.tracking(cg).short) { | 115861 | .simm32 => switch (temp.tracking(cg).short) { |
| ... | @@ -110386,6 +115871,11 @@ const Select = struct { | ... | @@ -110386,6 +115871,11 @@ const Select = struct { |
| 110386 | .register_offset => |reg_off| reg_off.reg.class() == .general_purpose and reg_off.off == 0, | 115871 | .register_offset => |reg_off| reg_off.reg.class() == .general_purpose and reg_off.off == 0, |
| 110387 | else => false, | 115872 | else => false, |
| 110388 | }, | 115873 | }, |
| | 115874 | .immut_gpr => !temp.isMut(cg) and temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8 and switch (temp.tracking(cg).short) { |
| | 115875 | .register => |reg| reg.class() == .general_purpose, |
| | 115876 | .register_offset => |reg_off| reg_off.reg.class() == .general_purpose and reg_off.off == 0, |
| | 115877 | else => false, |
| | 115878 | }, |
| 110389 | .mut_gpr => temp.isMut(cg) and temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8 and switch (temp.tracking(cg).short) { | 115879 | .mut_gpr => temp.isMut(cg) and temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8 and switch (temp.tracking(cg).short) { |
| 110390 | .register => |reg| reg.class() == .general_purpose, | 115880 | .register => |reg| reg.class() == .general_purpose, |
| 110391 | .register_offset => |reg_off| reg_off.reg.class() == .general_purpose and reg_off.off == 0, | 115881 | .register_offset => |reg_off| reg_off.reg.class() == .general_purpose and reg_off.off == 0, |
| ... | @@ -110472,7 +115962,7 @@ const Select = struct { | ... | @@ -110472,7 +115962,7 @@ const Select = struct { |
| 110472 | .to_param_gpr_pair => |param_spec| try temp.toRegPair(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index..][0..2].*, cg), | 115962 | .to_param_gpr_pair => |param_spec| try temp.toRegPair(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index..][0..2].*, cg), |
| 110473 | .to_ret_gpr => |ret_spec| try temp.toReg(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index], cg), | 115963 | .to_ret_gpr => |ret_spec| try temp.toReg(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index], cg), |
| 110474 | .to_ret_gpr_pair => |ret_spec| try temp.toRegPair(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*, cg), | 115964 | .to_ret_gpr_pair => |ret_spec| try temp.toRegPair(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index..][0..2].*, cg), |
| 110475 | .gpr, .to_gpr => try temp.toRegClass(false, .general_purpose, cg), | 115965 | .gpr, .immut_gpr, .to_gpr => try temp.toRegClass(false, .general_purpose, cg), |
| 110476 | .mut_gpr, .to_mut_gpr => try temp.toRegClass(true, .general_purpose, cg), | 115966 | .mut_gpr, .to_mut_gpr => try temp.toRegClass(true, .general_purpose, cg), |
| 110477 | .x87, .to_x87 => try temp.toRegClass(false, .x87, cg), | 115967 | .x87, .to_x87 => try temp.toRegClass(false, .x87, cg), |
| 110478 | .mut_x87, .to_mut_x87 => try temp.toRegClass(true, .x87, cg), | 115968 | .mut_x87, .to_mut_x87 => try temp.toRegClass(true, .x87, cg), |
| ... | @@ -110494,6 +115984,8 @@ const Select = struct { | ... | @@ -110494,6 +115984,8 @@ const Select = struct { |
| 110494 | const Kind = union(enum) { | 115984 | const Kind = union(enum) { |
| 110495 | unused, | 115985 | unused, |
| 110496 | any, | 115986 | any, |
| | 115987 | none, |
| | 115988 | undef, |
| 110497 | cc: Condition, | 115989 | cc: Condition, |
| 110498 | ref: Select.Operand.Ref, | 115990 | ref: Select.Operand.Ref, |
| 110499 | reg: Register, | 115991 | reg: Register, |
| ... | @@ -110580,6 +116072,8 @@ const Select = struct { | ... | @@ -110580,6 +116072,8 @@ const Select = struct { |
| 110580 | return switch (spec.kind) { | 116072 | return switch (spec.kind) { |
| 110581 | .unused => .{ undefined, false }, | 116073 | .unused => .{ undefined, false }, |
| 110582 | .any => .{ try cg.tempAlloc(spec.type), true }, | 116074 | .any => .{ try cg.tempAlloc(spec.type), true }, |
| | 116075 | .none => .{ try cg.tempInit(spec.type, .none), true }, |
| | 116076 | .undef => .{ try cg.tempInit(spec.type, .undef), true }, |
| 110583 | .cc => |cc| .{ try cg.tempInit(spec.type, .{ .eflags = cc }), true }, | 116077 | .cc => |cc| .{ try cg.tempInit(spec.type, .{ .eflags = cc }), true }, |
| 110584 | .ref => |ref| .{ ref.tempOf(s), false }, | 116078 | .ref => |ref| .{ ref.tempOf(s), false }, |
| 110585 | .reg => |reg| .{ try cg.tempInit(spec.type, .{ .register = reg }), true }, | 116079 | .reg => |reg| .{ try cg.tempInit(spec.type, .{ .register = reg }), true }, |
| ... | @@ -110812,10 +116306,17 @@ const Select = struct { | ... | @@ -110812,10 +116306,17 @@ const Select = struct { |
| 110812 | }, | 116306 | }, |
| 110813 | .frame => |frame_index| .{ try cg.tempInit(spec.type, .{ .load_frame = .{ .index = frame_index } }), true }, | 116307 | .frame => |frame_index| .{ try cg.tempInit(spec.type, .{ .load_frame = .{ .index = frame_index } }), true }, |
| 110814 | .lazy_symbol => |lazy_symbol_spec| { | 116308 | .lazy_symbol => |lazy_symbol_spec| { |
| | 116309 | const ip = &pt.zcu.intern_pool; |
| 110815 | const ty = if (lazy_symbol_spec.ref == .none) spec.type else lazy_symbol_spec.ref.typeOf(s); | 116310 | const ty = if (lazy_symbol_spec.ref == .none) spec.type else lazy_symbol_spec.ref.typeOf(s); |
| 110816 | const lazy_symbol: link.File.LazySymbol = .{ | 116311 | const lazy_symbol: link.File.LazySymbol = .{ |
| 110817 | .kind = lazy_symbol_spec.kind, | 116312 | .kind = lazy_symbol_spec.kind, |
| 110818 | .ty = ty.toIntern(), | 116313 | .ty = switch (ip.indexToKey(ty.toIntern())) { |
| | 116314 | .inferred_error_set_type => |func_index| switch (ip.funcIesResolvedUnordered(func_index)) { |
| | 116315 | .none => unreachable, // unresolved inferred error set |
| | 116316 | else => |ty_index| ty_index, |
| | 116317 | }, |
| | 116318 | else => ty.toIntern(), |
| | 116319 | }, |
| 110819 | }; | 116320 | }; |
| 110820 | return .{ try cg.tempInit(.usize, .{ .lea_symbol = .{ | 116321 | return .{ try cg.tempInit(.usize, .{ .lea_symbol = .{ |
| 110821 | .sym_index = if (cg.bin_file.cast(.elf)) |elf_file| | 116322 | .sym_index = if (cg.bin_file.cast(.elf)) |elf_file| |
| ... | @@ -110922,6 +116423,7 @@ const Select = struct { | ... | @@ -110922,6 +116423,7 @@ const Select = struct { |
| 110922 | const sub_size: Adjust = .{ .sign = .neg, .lhs = .size, .op = .mul, .rhs = .@"1" }; | 116423 | const sub_size: Adjust = .{ .sign = .neg, .lhs = .size, .op = .mul, .rhs = .@"1" }; |
| 110923 | const sub_src0_size_div_8: Adjust = .{ .sign = .neg, .lhs = .src0_size, .op = .div, .rhs = .@"8" }; | 116424 | const sub_src0_size_div_8: Adjust = .{ .sign = .neg, .lhs = .src0_size, .op = .div, .rhs = .@"8" }; |
| 110924 | const sub_src0_size: Adjust = .{ .sign = .neg, .lhs = .src0_size, .op = .mul, .rhs = .@"1" }; | 116425 | const sub_src0_size: Adjust = .{ .sign = .neg, .lhs = .src0_size, .op = .mul, .rhs = .@"1" }; |
| | 116426 | const add_src0_size: Adjust = .{ .sign = .pos, .lhs = .src0_size, .op = .mul, .rhs = .@"1" }; |
| 110925 | const add_8_src0_size: Adjust = .{ .sign = .pos, .lhs = .src0_size, .op = .mul, .rhs = .@"8" }; | 116427 | const add_8_src0_size: Adjust = .{ .sign = .pos, .lhs = .src0_size, .op = .mul, .rhs = .@"8" }; |
| 110926 | const add_delta_size_div_8: Adjust = .{ .sign = .pos, .lhs = .delta_size, .op = .div, .rhs = .@"8" }; | 116428 | const add_delta_size_div_8: Adjust = .{ .sign = .pos, .lhs = .delta_size, .op = .div, .rhs = .@"8" }; |
| 110927 | const add_delta_elem_size: Adjust = .{ .sign = .pos, .lhs = .delta_elem_size, .op = .mul, .rhs = .@"1" }; | 116429 | const add_delta_elem_size: Adjust = .{ .sign = .pos, .lhs = .delta_elem_size, .op = .mul, .rhs = .@"1" }; |
| ... | @@ -110965,7 +116467,9 @@ const Select = struct { | ... | @@ -110965,7 +116467,9 @@ const Select = struct { |
| 110965 | const add_dst0_elem_size: Adjust = .{ .sign = .pos, .lhs = .dst0_elem_size, .op = .mul, .rhs = .@"1" }; | 116467 | const add_dst0_elem_size: Adjust = .{ .sign = .pos, .lhs = .dst0_elem_size, .op = .mul, .rhs = .@"1" }; |
| 110966 | const add_elem_limbs: Adjust = .{ .sign = .pos, .lhs = .elem_limbs, .op = .mul, .rhs = .@"1" }; | 116468 | const add_elem_limbs: Adjust = .{ .sign = .pos, .lhs = .elem_limbs, .op = .mul, .rhs = .@"1" }; |
| 110967 | const add_smin: Adjust = .{ .sign = .pos, .lhs = .smin, .op = .mul, .rhs = .@"1" }; | 116469 | const add_smin: Adjust = .{ .sign = .pos, .lhs = .smin, .op = .mul, .rhs = .@"1" }; |
| | 116470 | const sub_smin: Adjust = .{ .sign = .neg, .lhs = .smin, .op = .mul, .rhs = .@"1" }; |
| 110968 | const add_umax: Adjust = .{ .sign = .pos, .lhs = .umax, .op = .mul, .rhs = .@"1" }; | 116471 | const add_umax: Adjust = .{ .sign = .pos, .lhs = .umax, .op = .mul, .rhs = .@"1" }; |
| | 116472 | const sub_umax: Adjust = .{ .sign = .neg, .lhs = .umax, .op = .mul, .rhs = .@"1" }; |
| 110969 | const repeat: Adjust = .{ .sign = .pos, .lhs = .repeat, .op = .mul, .rhs = .@"1" }; | 116473 | const repeat: Adjust = .{ .sign = .pos, .lhs = .repeat, .op = .mul, .rhs = .@"1" }; |
| 110970 | }; | 116474 | }; |
| 110971 | const Ref = enum(u5) { | 116475 | const Ref = enum(u5) { |
| ... | @@ -111783,6 +117287,7 @@ fn select( | ... | @@ -111783,6 +117287,7 @@ fn select( |
| 111783 | if (std.debug.runtime_safety) { | 117287 | if (std.debug.runtime_safety) { |
| 111784 | for (case.src_constraints[src_temps.len..]) |src_constraint| assert(src_constraint == .any); | 117288 | for (case.src_constraints[src_temps.len..]) |src_constraint| assert(src_constraint == .any); |
| 111785 | for (case.dst_constraints[dst_temps.len..]) |dst_constraint| assert(dst_constraint == .any); | 117289 | for (case.dst_constraints[dst_temps.len..]) |dst_constraint| assert(dst_constraint == .any); |
| | 117290 | for (case.dst_temps[dst_temps.len..]) |dst_temp| assert(dst_temp == .unused); |
| 111786 | } | 117291 | } |
| 111787 | patterns: for (case.patterns) |pattern| { | 117292 | patterns: for (case.patterns) |pattern| { |
| 111788 | for (pattern.src[0..src_temps.len], src_temps) |src_pattern, src_temp| if (!src_pattern.matches(src_temp, cg)) continue :patterns; | 117293 | for (pattern.src[0..src_temps.len], src_temps) |src_pattern, src_temp| if (!src_pattern.matches(src_temp, cg)) continue :patterns; |
Jacob Young <jacobly@ziglang.org> 2025-04-11 05:21:44-04:00
GitHub <noreply@github.com> 2025-04-11 05:21:44-04:00
Signed by PGP key B5690EEEBB952194
lib