| ... | ... | @@ -83,7 +83,6 @@ end_di_column: u32, |
| 83 | 83 | epilogue_relocs: std.ArrayListUnmanaged(Mir.Inst.Index) = .empty, |
| 84 | 84 | |
| 85 | 85 | reused_operands: std.StaticBitSet(Liveness.bpi - 1) = undefined, |
| 86 | | const_tracking: ConstTrackingMap = .empty, |
| 87 | 86 | inst_tracking: InstTrackingMap = .empty, |
| 88 | 87 | |
| 89 | 88 | // Key is the block instruction |
| ... | ... | @@ -926,7 +925,6 @@ pub fn generate( |
| 926 | 925 | while (block_it.next()) |block| block.deinit(gpa); |
| 927 | 926 | function.blocks.deinit(gpa); |
| 928 | 927 | function.inst_tracking.deinit(gpa); |
| 929 | | function.const_tracking.deinit(gpa); |
| 930 | 928 | function.epilogue_relocs.deinit(gpa); |
| 931 | 929 | function.mir_instructions.deinit(gpa); |
| 932 | 930 | function.mir_extra.deinit(gpa); |
| ... | ... | @@ -2418,7 +2416,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2418 | 2416 | } |
| 2419 | 2417 | |
| 2420 | 2418 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2421 | | @setEvalBranchQuota(13_900); |
| 2419 | @setEvalBranchQuota(15_100); |
| 2422 | 2420 | const pt = cg.pt; |
| 2423 | 2421 | const zcu = pt.zcu; |
| 2424 | 2422 | const ip = &zcu.intern_pool; |
| ... | ... | @@ -2459,9 +2457,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2459 | 2457 | .mul_sat => try cg.airMulSat(inst), |
| 2460 | 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 | 2460 | .shl_with_overflow => try cg.airShlWithOverflow(inst), |
| 2466 | 2461 | |
| 2467 | 2462 | .bitcast => try cg.airBitCast(inst), |
| ... | ... | @@ -28019,6 +28014,5377 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 28019 | 28014 | }; |
| 28020 | 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 | 33388 | .alloc => if (use_old) try cg.airAlloc(inst) else { |
| 28023 | 33389 | const ty = air_datas[@intFromEnum(inst)].ty; |
| 28024 | 33390 | const slot = try cg.tempInit(ty, .{ .lea_frame = .{ |
| ... | ... | @@ -97522,9 +102888,6 @@ fn lowerSwitchBr( |
| 97522 | 102888 | const relocs = try allocator.alloc(Mir.Inst.Index, case.items.len + case.ranges.len); |
| 97523 | 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 | 102891 | try cg.spillEflagsIfOccupied(); |
| 97529 | 102892 | for (case.items, relocs[0..case.items.len]) |item, *reloc| { |
| 97530 | 102893 | const item_mcv = try cg.resolveInst(item); |
| ... | ... | @@ -97535,6 +102898,7 @@ fn lowerSwitchBr( |
| 97535 | 102898 | else => unreachable, |
| 97536 | 102899 | }, |
| 97537 | 102900 | else => cc: { |
| 102901 | var cond_temp = try cg.tempInit(condition_ty, condition); |
| 97538 | 102902 | var item_temp = try cg.tempInit(condition_ty, item_mcv); |
| 97539 | 102903 | const cc_temp = cond_temp.cmpInts(.eq, &item_temp, cg) catch |err| switch (err) { |
| 97540 | 102904 | error.SelectFailed => unreachable, |
| ... | ... | @@ -97543,7 +102907,8 @@ fn lowerSwitchBr( |
| 97543 | 102907 | try item_temp.die(cg); |
| 97544 | 102908 | const cc = cc_temp.tracking(cg).short.eflags; |
| 97545 | 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 | 102912 | break :cc cc; |
| 97548 | 102913 | }, |
| 97549 | 102914 | }; |
| ... | ... | @@ -97551,6 +102916,7 @@ fn lowerSwitchBr( |
| 97551 | 102916 | } |
| 97552 | 102917 | |
| 97553 | 102918 | for (case.ranges, relocs[case.items.len..]) |range, *reloc| { |
| 102919 | var cond_temp = try cg.tempInit(condition_ty, condition); |
| 97554 | 102920 | const min_mcv = try cg.resolveInst(range[0]); |
| 97555 | 102921 | const max_mcv = try cg.resolveInst(range[1]); |
| 97556 | 102922 | // `null` means always false. |
| ... | ... | @@ -97594,7 +102960,8 @@ fn lowerSwitchBr( |
| 97594 | 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 | 102965 | // "Success" case is in `reloc`.... |
| 97599 | 102966 | if (lte_max) |cc| { |
| 97600 | 102967 | reloc.* = try cg.asmJccReloc(cc, undefined); |
| ... | ... | @@ -97605,8 +102972,6 @@ fn lowerSwitchBr( |
| 97605 | 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 | 102975 | cg.checkInvariantsAfterAirInst(); |
| 97611 | 102976 | |
| 97612 | 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 | 103178 | .pseudo_j_z_and_np_inst, .pseudo_j_nz_or_p_inst => {}, |
| 97814 | 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 | 103194 | else => unreachable, |
| 97817 | 103195 | } |
| 97818 | 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 | 103474 | // for the string, we still use the next u32 for the null terminator. |
| 98097 | 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 | 103481 | // ok, sure |
| 98101 | 103482 | } else if (std.mem.eql(u8, clobber, "cc") or |
| 98102 | 103483 | std.mem.eql(u8, clobber, "flags") or |
| ... | ... | @@ -98361,7 +103742,24 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 98361 | 103742 | else |
| 98362 | 103743 | .@"1"; |
| 98363 | 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 | 103763 | .base = if (base_str.len > 0) |
| 98366 | 103764 | .{ .reg = parseRegName(base_str["%%".len..]) orelse |
| 98367 | 103765 | return self.fail("invalid base register: '{s}'", .{base_str}) } |
| ... | ... | @@ -98405,9 +103803,9 @@ fn airAsm(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 98405 | 103803 | } else if (Label.isValid(.reference, op_str)) { |
| 98406 | 103804 | const anon = std.ascii.isDigit(op_str[0]); |
| 98407 | 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 | 103806 | if (anon and (op_str[1] == 'b' or op_str[1] == 'B') and !label_gop.found_existing) |
| 98410 | 103807 | return self.fail("undefined label: '{s}'", .{op_str}); |
| 103808 | if (!label_gop.found_existing) label_gop.value_ptr.* = .{}; |
| 98411 | 103809 | const pending_relocs = &label_gop.value_ptr.pending_relocs; |
| 98412 | 103810 | if (if (anon) |
| 98413 | 103811 | op_str[1] == 'f' or op_str[1] == 'F' |
| ... | ... | @@ -99643,7 +105041,7 @@ fn genSetMem( |
| 99643 | 105041 | .none => .{ .immediate = @bitCast(@as(i64, disp)) }, |
| 99644 | 105042 | .reg => |base_reg| .{ .register_offset = .{ .reg = base_reg, .off = disp } }, |
| 99645 | 105043 | .frame => |base_frame_index| .{ .lea_frame = .{ .index = base_frame_index, .off = disp } }, |
| 99646 | | .table => unreachable, |
| 105044 | .table, .rip_inst => unreachable, |
| 99647 | 105045 | .reloc => |sym_index| .{ .lea_symbol = .{ .sym_index = sym_index, .off = disp } }, |
| 99648 | 105046 | }; |
| 99649 | 105047 | switch (src_mcv) { |
| ... | ... | @@ -99753,7 +105151,7 @@ fn genSetMem( |
| 99753 | 105151 | .index = frame_index, |
| 99754 | 105152 | .off = disp, |
| 99755 | 105153 | }).compare(.gte, src_align), |
| 99756 | | .table => unreachable, |
| 105154 | .table, .rip_inst => unreachable, |
| 99757 | 105155 | .reloc => false, |
| 99758 | 105156 | })).write( |
| 99759 | 105157 | self, |
| ... | ... | @@ -100402,7 +105800,7 @@ fn airCmpxchg(self: *CodeGen, inst: Air.Inst.Index) !void { |
| 100402 | 105800 | const ptr_lock = switch (ptr_mem.base) { |
| 100403 | 105801 | .none, .frame, .reloc => null, |
| 100404 | 105802 | .reg => |reg| self.register_manager.lockReg(reg), |
| 100405 | | .table => unreachable, |
| 105803 | .table, .rip_inst => unreachable, |
| 100406 | 105804 | }; |
| 100407 | 105805 | defer if (ptr_lock) |lock| self.register_manager.unlockReg(lock); |
| 100408 | 105806 | |
| ... | ... | @@ -100485,7 +105883,7 @@ fn atomicOp( |
| 100485 | 105883 | const mem_lock = switch (ptr_mem.base) { |
| 100486 | 105884 | .none, .frame, .reloc => null, |
| 100487 | 105885 | .reg => |reg| self.register_manager.lockReg(reg), |
| 100488 | | .table => unreachable, |
| 105886 | .table, .rip_inst => unreachable, |
| 100489 | 105887 | }; |
| 100490 | 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 | 109022 | // If the type has no codegen bits, no need to store it. |
| 103625 | 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 | 109026 | break :mcv self.inst_tracking.getPtr(inst).?.short; |
| 103629 | 109027 | } else mcv: { |
| 103630 | | const ip_index = ref.toInterned().?; |
| 103631 | | const gop = try self.const_tracking.getOrPut(self.gpa, ip_index); |
| 103632 | | if (!gop.found_existing) gop.value_ptr.* = .init(init: { |
| 103633 | | const const_mcv = try self.genTypedValue(.fromInterned(ip_index)); |
| 103634 | | switch (const_mcv) { |
| 103635 | | .lea_tlv => |tlv_sym| switch (self.bin_file.tag) { |
| 103636 | | .elf, .macho => { |
| 103637 | | if (self.mod.pic) { |
| 103638 | | try self.spillRegisters(&.{ .rdi, .rax }); |
| 103639 | | } else { |
| 103640 | | try self.spillRegisters(&.{.rax}); |
| 103641 | | } |
| 103642 | | const frame_index = try self.allocFrameIndex(.init(.{ |
| 103643 | | .size = 8, |
| 103644 | | .alignment = .@"8", |
| 103645 | | })); |
| 103646 | | try self.genSetMem( |
| 103647 | | .{ .frame = frame_index }, |
| 103648 | | 0, |
| 103649 | | .usize, |
| 103650 | | .{ .lea_symbol = .{ .sym_index = tlv_sym } }, |
| 103651 | | .{}, |
| 103652 | | ); |
| 103653 | | break :init .{ .load_frame = .{ .index = frame_index } }; |
| 103654 | | }, |
| 103655 | | else => break :init const_mcv, |
| 109028 | const const_mcv = try self.genTypedValue(.fromInterned(ref.toInterned().?)); |
| 109029 | switch (const_mcv) { |
| 109030 | .lea_tlv => |tlv_sym| switch (self.bin_file.tag) { |
| 109031 | .elf, .macho => { |
| 109032 | if (self.mod.pic) { |
| 109033 | try self.spillRegisters(&.{ .rdi, .rax }); |
| 109034 | } else { |
| 109035 | try self.spillRegisters(&.{.rax}); |
| 109036 | } |
| 109037 | const frame_index = try self.allocFrameIndex(.init(.{ |
| 109038 | .size = 8, |
| 109039 | .alignment = .@"8", |
| 109040 | })); |
| 109041 | try self.genSetMem( |
| 109042 | .{ .frame = frame_index }, |
| 109043 | 0, |
| 109044 | .usize, |
| 109045 | .{ .lea_symbol = .{ .sym_index = tlv_sym } }, |
| 109046 | .{}, |
| 109047 | ); |
| 109048 | break :mcv .{ .load_frame = .{ .index = frame_index } }; |
| 103656 | 109049 | }, |
| 103657 | | else => break :init const_mcv, |
| 103658 | | } |
| 103659 | | }); |
| 103660 | | break :mcv gop.value_ptr.short; |
| 109050 | else => break :mcv const_mcv, |
| 109051 | }, |
| 109052 | else => break :mcv const_mcv, |
| 109053 | } |
| 103661 | 109054 | }; |
| 103662 | 109055 | |
| 103663 | 109056 | switch (mcv) { |
| ... | ... | @@ -104205,13 +109598,21 @@ fn memSize(self: *CodeGen, ty: Type) Memory.Size { |
| 104205 | 109598 | fn splitType(self: *CodeGen, comptime parts_len: usize, ty: Type) ![parts_len]Type { |
| 104206 | 109599 | const pt = self.pt; |
| 104207 | 109600 | const zcu = pt.zcu; |
| 109601 | const ip = &zcu.intern_pool; |
| 104208 | 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 .{ |
| 104210 | | try pt.vectorType(.{ .len = vec_len, .child = ty.scalarType(zcu).toIntern() }), |
| 104211 | | } ** parts_len else |err| switch (err) { |
| 104212 | | error.DivisionByZero => unreachable, |
| 104213 | | error.UnexpectedRemainder => {}, |
| 104214 | | }; |
| 109603 | switch (ip.indexToKey(ty.toIntern())) { |
| 109604 | .vector_type => |vector_type| if (std.math.divExact(u32, vector_type.len, parts_len)) |vec_len| return .{ |
| 109605 | try pt.vectorType(.{ .len = vec_len, .child = vector_type.child }), |
| 109606 | } ** parts_len else |err| switch (err) { |
| 109607 | error.DivisionByZero => unreachable, |
| 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 | 109616 | const classes = std.mem.sliceTo(&abi.classifySystemV(ty, zcu, self.target, .other), .none); |
| 104216 | 109617 | if (classes.len == parts_len) for (&parts, classes, 0..) |*part, class, part_i| { |
| 104217 | 109618 | part.* = switch (class) { |
| ... | ... | @@ -104896,6 +110297,52 @@ const Temp = struct { |
| 104896 | 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 | 110346 | fn asMask(temp: Temp, info: MaskInfo, cg: *CodeGen) void { |
| 104900 | 110347 | assert(info.scalar != .none); |
| 104901 | 110348 | const mcv = &temp.unwrap(cg).temp.tracking(cg).short; |
| ... | ... | @@ -105581,6 +111028,42 @@ const Temp = struct { |
| 105581 | 111028 | }, |
| 105582 | 111029 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 105583 | 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 | 111068 | .required_features = .{ .@"64bit", null, null, null }, |
| 105586 | 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 | 115286 | |
| 109804 | 115287 | if (op_ref.toIndex()) |op_inst| return .{ .index = op_inst }; |
| 109805 | 115288 | const val = op_ref.toInterned().?; |
| 109806 | | const gop = try cg.const_tracking.getOrPut(cg.gpa, val); |
| 109807 | | if (!gop.found_existing) gop.value_ptr.* = .init(init: { |
| 115289 | return cg.tempInit(.fromInterned(ip.typeOf(val)), init: { |
| 109808 | 115290 | const const_mcv = try cg.genTypedValue(.fromInterned(val)); |
| 109809 | 115291 | switch (const_mcv) { |
| 109810 | 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 | 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 | 115319 | fn tempsFromOperandsInner( |
| ... | ... | @@ -110330,6 +115811,7 @@ const Select = struct { |
| 110330 | 115811 | mut_mem, |
| 110331 | 115812 | to_mut_mem, |
| 110332 | 115813 | gpr, |
| 115814 | immut_gpr, |
| 110333 | 115815 | to_gpr, |
| 110334 | 115816 | mut_gpr, |
| 110335 | 115817 | to_mut_gpr, |
| ... | ... | @@ -110362,15 +115844,18 @@ const Select = struct { |
| 110362 | 115844 | return switch (src) { |
| 110363 | 115845 | .none => temp.tracking(cg).short == .none, |
| 110364 | 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 | 115849 | else => false, |
| 110367 | 115850 | }, |
| 110368 | 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 | 115854 | else => false, |
| 110371 | 115855 | }, |
| 110372 | 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 | 115859 | else => false, |
| 110375 | 115860 | }, |
| 110376 | 115861 | .simm32 => switch (temp.tracking(cg).short) { |
| ... | ... | @@ -110386,6 +115871,11 @@ const Select = struct { |
| 110386 | 115871 | .register_offset => |reg_off| reg_off.reg.class() == .general_purpose and reg_off.off == 0, |
| 110387 | 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 | 115879 | .mut_gpr => temp.isMut(cg) and temp.typeOf(cg).abiSize(cg.pt.zcu) <= 8 and switch (temp.tracking(cg).short) { |
| 110390 | 115880 | .register => |reg| reg.class() == .general_purpose, |
| 110391 | 115881 | .register_offset => |reg_off| reg_off.reg.class() == .general_purpose and reg_off.off == 0, |
| ... | ... | @@ -110472,7 +115962,7 @@ const Select = struct { |
| 110472 | 115962 | .to_param_gpr_pair => |param_spec| try temp.toRegPair(abi.getCAbiIntParamRegs(param_spec.tag(cg))[param_spec.index..][0..2].*, cg), |
| 110473 | 115963 | .to_ret_gpr => |ret_spec| try temp.toReg(abi.getCAbiIntReturnRegs(ret_spec.tag(cg))[ret_spec.index], cg), |
| 110474 | 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 | 115966 | .mut_gpr, .to_mut_gpr => try temp.toRegClass(true, .general_purpose, cg), |
| 110477 | 115967 | .x87, .to_x87 => try temp.toRegClass(false, .x87, cg), |
| 110478 | 115968 | .mut_x87, .to_mut_x87 => try temp.toRegClass(true, .x87, cg), |
| ... | ... | @@ -110494,6 +115984,8 @@ const Select = struct { |
| 110494 | 115984 | const Kind = union(enum) { |
| 110495 | 115985 | unused, |
| 110496 | 115986 | any, |
| 115987 | none, |
| 115988 | undef, |
| 110497 | 115989 | cc: Condition, |
| 110498 | 115990 | ref: Select.Operand.Ref, |
| 110499 | 115991 | reg: Register, |
| ... | ... | @@ -110580,6 +116072,8 @@ const Select = struct { |
| 110580 | 116072 | return switch (spec.kind) { |
| 110581 | 116073 | .unused => .{ undefined, false }, |
| 110582 | 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 | 116077 | .cc => |cc| .{ try cg.tempInit(spec.type, .{ .eflags = cc }), true }, |
| 110584 | 116078 | .ref => |ref| .{ ref.tempOf(s), false }, |
| 110585 | 116079 | .reg => |reg| .{ try cg.tempInit(spec.type, .{ .register = reg }), true }, |
| ... | ... | @@ -110812,10 +116306,17 @@ const Select = struct { |
| 110812 | 116306 | }, |
| 110813 | 116307 | .frame => |frame_index| .{ try cg.tempInit(spec.type, .{ .load_frame = .{ .index = frame_index } }), true }, |
| 110814 | 116308 | .lazy_symbol => |lazy_symbol_spec| { |
| 116309 | const ip = &pt.zcu.intern_pool; |
| 110815 | 116310 | const ty = if (lazy_symbol_spec.ref == .none) spec.type else lazy_symbol_spec.ref.typeOf(s); |
| 110816 | 116311 | const lazy_symbol: link.File.LazySymbol = .{ |
| 110817 | 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 | 116321 | return .{ try cg.tempInit(.usize, .{ .lea_symbol = .{ |
| 110821 | 116322 | .sym_index = if (cg.bin_file.cast(.elf)) |elf_file| |
| ... | ... | @@ -110922,6 +116423,7 @@ const Select = struct { |
| 110922 | 116423 | const sub_size: Adjust = .{ .sign = .neg, .lhs = .size, .op = .mul, .rhs = .@"1" }; |
| 110923 | 116424 | const sub_src0_size_div_8: Adjust = .{ .sign = .neg, .lhs = .src0_size, .op = .div, .rhs = .@"8" }; |
| 110924 | 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 | 116427 | const add_8_src0_size: Adjust = .{ .sign = .pos, .lhs = .src0_size, .op = .mul, .rhs = .@"8" }; |
| 110926 | 116428 | const add_delta_size_div_8: Adjust = .{ .sign = .pos, .lhs = .delta_size, .op = .div, .rhs = .@"8" }; |
| 110927 | 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 | 116467 | const add_dst0_elem_size: Adjust = .{ .sign = .pos, .lhs = .dst0_elem_size, .op = .mul, .rhs = .@"1" }; |
| 110966 | 116468 | const add_elem_limbs: Adjust = .{ .sign = .pos, .lhs = .elem_limbs, .op = .mul, .rhs = .@"1" }; |
| 110967 | 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 | 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 | 116473 | const repeat: Adjust = .{ .sign = .pos, .lhs = .repeat, .op = .mul, .rhs = .@"1" }; |
| 110970 | 116474 | }; |
| 110971 | 116475 | const Ref = enum(u5) { |
| ... | ... | @@ -111783,6 +117287,7 @@ fn select( |
| 111783 | 117287 | if (std.debug.runtime_safety) { |
| 111784 | 117288 | for (case.src_constraints[src_temps.len..]) |src_constraint| assert(src_constraint == .any); |
| 111785 | 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 | 117292 | patterns: for (case.patterns) |pattern| { |
| 111788 | 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