| ... | ... | @@ -2408,7 +2408,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2408 | 2408 | } |
| 2409 | 2409 | |
| 2410 | 2410 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2411 | | @setEvalBranchQuota(15_800); |
| 2411 | @setEvalBranchQuota(15_900); |
| 2412 | 2412 | const pt = cg.pt; |
| 2413 | 2413 | const zcu = pt.zcu; |
| 2414 | 2414 | const ip = &zcu.intern_pool; |
| ... | ... | @@ -2444,7 +2444,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2444 | 2444 | try cg.inst_tracking.ensureUnusedCapacity(cg.gpa, 1); |
| 2445 | 2445 | switch (air_tags[@intFromEnum(inst)]) { |
| 2446 | 2446 | // zig fmt: off |
| 2447 | | .add_sat => try cg.airAddSat(inst), |
| 2448 | 2447 | .sub_sat => try cg.airSubSat(inst), |
| 2449 | 2448 | .mul_sat => try cg.airMulSat(inst), |
| 2450 | 2449 | .shl_sat => try cg.airShlSat(inst), |
| ... | ... | @@ -4346,6 +4345,1864 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4346 | 4345 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 4347 | 4346 | }, |
| 4348 | 4347 | .add_safe => unreachable, |
| 4348 | .add_sat => |air_tag| if (use_old) try cg.airAddSat(inst) else fallback: { |
| 4349 | const bin_op = air_datas[@intFromEnum(inst)].bin_op; |
| 4350 | if (cg.typeOf(bin_op.lhs).isVector(zcu)) break :fallback try cg.airAddSat(inst); |
| 4351 | var ops = try cg.tempsFromOperands(inst, .{ bin_op.lhs, bin_op.rhs }); |
| 4352 | var res: [1]Temp = undefined; |
| 4353 | cg.select(&res, &.{cg.typeOf(bin_op.lhs)}, &ops, comptime &.{ .{ |
| 4354 | .required_features = .{ .cmov, null, null, null }, |
| 4355 | .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any }, |
| 4356 | .patterns = &.{ |
| 4357 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| 4358 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4359 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4360 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4361 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4362 | }, |
| 4363 | .extra_temps = .{ |
| 4364 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 4365 | .unused, |
| 4366 | .unused, |
| 4367 | .unused, |
| 4368 | .unused, |
| 4369 | .unused, |
| 4370 | .unused, |
| 4371 | .unused, |
| 4372 | .unused, |
| 4373 | .unused, |
| 4374 | .unused, |
| 4375 | }, |
| 4376 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4377 | .clobbers = .{ .eflags = true }, |
| 4378 | .each = .{ .once = &.{ |
| 4379 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4380 | .{ ._, ._r, .sa, .tmp0b, .ui(7), ._, ._ }, |
| 4381 | .{ ._, ._, .xor, .tmp0b, .sa(.src0, .add_smax), ._, ._ }, |
| 4382 | .{ ._, ._, .add, .dst0b, .src1b, ._, ._ }, |
| 4383 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 4384 | } }, |
| 4385 | }, .{ |
| 4386 | .src_constraints = .{ .{ .exact_signed_int = 8 }, .{ .exact_signed_int = 8 }, .any }, |
| 4387 | .patterns = &.{ |
| 4388 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| 4389 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4390 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4391 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4392 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4393 | }, |
| 4394 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4395 | .clobbers = .{ .eflags = true }, |
| 4396 | .each = .{ .once = &.{ |
| 4397 | .{ ._, ._, .add, .dst0b, .src1b, ._, ._ }, |
| 4398 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 4399 | .{ ._, ._r, .sa, .dst0b, .ui(7), ._, ._ }, |
| 4400 | .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_smin), ._, ._ }, |
| 4401 | } }, |
| 4402 | }, .{ |
| 4403 | .required_features = .{ .cmov, null, null, null }, |
| 4404 | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any }, |
| 4405 | .patterns = &.{ |
| 4406 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| 4407 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4408 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4409 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4410 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4411 | }, |
| 4412 | .extra_temps = .{ |
| 4413 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 4414 | .unused, |
| 4415 | .unused, |
| 4416 | .unused, |
| 4417 | .unused, |
| 4418 | .unused, |
| 4419 | .unused, |
| 4420 | .unused, |
| 4421 | .unused, |
| 4422 | .unused, |
| 4423 | .unused, |
| 4424 | }, |
| 4425 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4426 | .clobbers = .{ .eflags = true }, |
| 4427 | .each = .{ .once = &.{ |
| 4428 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4429 | .{ ._, ._r, .sa, .tmp0b, .ui(7), ._, ._ }, |
| 4430 | .{ ._, ._, .xor, .tmp0b, .sa(.src0, .add_smax), ._, ._ }, |
| 4431 | .{ ._, ._, .add, .dst0b, .src1b, ._, ._ }, |
| 4432 | .{ ._, ._, .@"test", .dst0b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ }, |
| 4433 | .{ ._, ._po, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 4434 | } }, |
| 4435 | }, .{ |
| 4436 | .src_constraints = .{ .{ .signed_int = .byte }, .{ .signed_int = .byte }, .any }, |
| 4437 | .patterns = &.{ |
| 4438 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| 4439 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4440 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4441 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4442 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4443 | }, |
| 4444 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4445 | .clobbers = .{ .eflags = true }, |
| 4446 | .each = .{ .once = &.{ |
| 4447 | .{ ._, ._, .add, .dst0b, .src1b, ._, ._ }, |
| 4448 | .{ ._, ._, .@"test", .dst0b, .sia(-1 << 7, .src0, .sub_smin), ._, ._ }, |
| 4449 | .{ ._, ._pe, .j, .@"0f", ._, ._, ._ }, |
| 4450 | .{ ._, ._r, .sa, .dst0b, .ui(7), ._, ._ }, |
| 4451 | .{ ._, ._, .xor, .dst0b, .sa(.src0, .add_smax), ._, ._ }, |
| 4452 | } }, |
| 4453 | }, .{ |
| 4454 | .src_constraints = .{ .{ .exact_unsigned_int = 8 }, .{ .exact_unsigned_int = 8 }, .any }, |
| 4455 | .patterns = &.{ |
| 4456 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| 4457 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4458 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4459 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4460 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4461 | }, |
| 4462 | .extra_temps = .{ |
| 4463 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4464 | .unused, |
| 4465 | .unused, |
| 4466 | .unused, |
| 4467 | .unused, |
| 4468 | .unused, |
| 4469 | .unused, |
| 4470 | .unused, |
| 4471 | .unused, |
| 4472 | .unused, |
| 4473 | .unused, |
| 4474 | }, |
| 4475 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4476 | .clobbers = .{ .eflags = true }, |
| 4477 | .each = .{ .once = &.{ |
| 4478 | .{ ._, ._, .add, .dst0b, .src1b, ._, ._ }, |
| 4479 | .{ ._, ._, .sbb, .tmp0d, .tmp0d, ._, ._ }, |
| 4480 | .{ ._, ._, .@"or", .dst0b, .tmp0b, ._, ._ }, |
| 4481 | } }, |
| 4482 | }, .{ |
| 4483 | .required_features = .{ .cmov, null, null, null }, |
| 4484 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| 4485 | .patterns = &.{ |
| 4486 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| 4487 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4488 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4489 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4490 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4491 | }, |
| 4492 | .extra_temps = .{ |
| 4493 | .{ .type = .u8, .kind = .{ .rc = .general_purpose } }, |
| 4494 | .unused, |
| 4495 | .unused, |
| 4496 | .unused, |
| 4497 | .unused, |
| 4498 | .unused, |
| 4499 | .unused, |
| 4500 | .unused, |
| 4501 | .unused, |
| 4502 | .unused, |
| 4503 | .unused, |
| 4504 | }, |
| 4505 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4506 | .clobbers = .{ .eflags = true }, |
| 4507 | .each = .{ .once = &.{ |
| 4508 | .{ ._, ._, .add, .dst0b, .src1b, ._, ._ }, |
| 4509 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ }, |
| 4510 | .{ ._, ._, .cmp, .dst0b, .tmp0b, ._, ._ }, |
| 4511 | .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 4512 | } }, |
| 4513 | }, .{ |
| 4514 | .src_constraints = .{ .{ .unsigned_int = .byte }, .{ .unsigned_int = .byte }, .any }, |
| 4515 | .patterns = &.{ |
| 4516 | .{ .src = .{ .to_mut_gpr, .imm8, .none } }, |
| 4517 | .{ .src = .{ .imm8, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4518 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4519 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4520 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4521 | }, |
| 4522 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4523 | .clobbers = .{ .eflags = true }, |
| 4524 | .each = .{ .once = &.{ |
| 4525 | .{ ._, ._, .add, .dst0b, .src1b, ._, ._ }, |
| 4526 | .{ ._, ._, .cmp, .dst0b, .ua(.src0, .add_umax), ._, ._ }, |
| 4527 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, |
| 4528 | .{ ._, ._, .mov, .dst0b, .ua(.src0, .add_umax), ._, ._ }, |
| 4529 | } }, |
| 4530 | }, .{ |
| 4531 | .required_features = .{ .fast_imm16, .cmov, null, null }, |
| 4532 | .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any }, |
| 4533 | .patterns = &.{ |
| 4534 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 4535 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4536 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4537 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4538 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4539 | }, |
| 4540 | .extra_temps = .{ |
| 4541 | .{ .type = .i8, .kind = .{ .rc = .general_purpose } }, |
| 4542 | .unused, |
| 4543 | .unused, |
| 4544 | .unused, |
| 4545 | .unused, |
| 4546 | .unused, |
| 4547 | .unused, |
| 4548 | .unused, |
| 4549 | .unused, |
| 4550 | .unused, |
| 4551 | .unused, |
| 4552 | }, |
| 4553 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4554 | .clobbers = .{ .eflags = true }, |
| 4555 | .each = .{ .once = &.{ |
| 4556 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4557 | .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ }, |
| 4558 | .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ }, |
| 4559 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 4560 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 4561 | } }, |
| 4562 | }, .{ |
| 4563 | .required_features = .{ .cmov, null, null, null }, |
| 4564 | .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any }, |
| 4565 | .patterns = &.{ |
| 4566 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 4567 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4568 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4569 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4570 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4571 | }, |
| 4572 | .extra_temps = .{ |
| 4573 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4574 | .unused, |
| 4575 | .unused, |
| 4576 | .unused, |
| 4577 | .unused, |
| 4578 | .unused, |
| 4579 | .unused, |
| 4580 | .unused, |
| 4581 | .unused, |
| 4582 | .unused, |
| 4583 | .unused, |
| 4584 | }, |
| 4585 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4586 | .clobbers = .{ .eflags = true }, |
| 4587 | .each = .{ .once = &.{ |
| 4588 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4589 | .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ }, |
| 4590 | .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ }, |
| 4591 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 4592 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 4593 | } }, |
| 4594 | }, .{ |
| 4595 | .required_features = .{ .fast_imm16, null, null, null }, |
| 4596 | .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any }, |
| 4597 | .patterns = &.{ |
| 4598 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 4599 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4600 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4601 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4602 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4603 | }, |
| 4604 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4605 | .clobbers = .{ .eflags = true }, |
| 4606 | .each = .{ .once = &.{ |
| 4607 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 4608 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 4609 | .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ }, |
| 4610 | .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smin), ._, ._ }, |
| 4611 | } }, |
| 4612 | }, .{ |
| 4613 | .src_constraints = .{ .{ .exact_signed_int = 16 }, .{ .exact_signed_int = 16 }, .any }, |
| 4614 | .patterns = &.{ |
| 4615 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 4616 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4617 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4618 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4619 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4620 | }, |
| 4621 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4622 | .clobbers = .{ .eflags = true }, |
| 4623 | .each = .{ .once = &.{ |
| 4624 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 4625 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 4626 | .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ }, |
| 4627 | .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smin), ._, ._ }, |
| 4628 | } }, |
| 4629 | }, .{ |
| 4630 | .required_features = .{ .fast_imm16, .cmov, null, null }, |
| 4631 | .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any }, |
| 4632 | .patterns = &.{ |
| 4633 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 4634 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4635 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4636 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4637 | }, |
| 4638 | .extra_temps = .{ |
| 4639 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4640 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4641 | .unused, |
| 4642 | .unused, |
| 4643 | .unused, |
| 4644 | .unused, |
| 4645 | .unused, |
| 4646 | .unused, |
| 4647 | .unused, |
| 4648 | .unused, |
| 4649 | .unused, |
| 4650 | }, |
| 4651 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4652 | .clobbers = .{ .eflags = true }, |
| 4653 | .each = .{ .once = &.{ |
| 4654 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4655 | .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ }, |
| 4656 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 4657 | .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ }, |
| 4658 | .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ }, |
| 4659 | .{ ._, ._, .add, .tmp1w, .tmp1w, ._, ._ }, |
| 4660 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 4661 | } }, |
| 4662 | }, .{ |
| 4663 | .required_features = .{ .fast_imm16, .cmov, null, null }, |
| 4664 | .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any }, |
| 4665 | .patterns = &.{ |
| 4666 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4667 | }, |
| 4668 | .extra_temps = .{ |
| 4669 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4670 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4671 | .unused, |
| 4672 | .unused, |
| 4673 | .unused, |
| 4674 | .unused, |
| 4675 | .unused, |
| 4676 | .unused, |
| 4677 | .unused, |
| 4678 | .unused, |
| 4679 | .unused, |
| 4680 | }, |
| 4681 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4682 | .clobbers = .{ .eflags = true }, |
| 4683 | .each = .{ .once = &.{ |
| 4684 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4685 | .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ }, |
| 4686 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 4687 | .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ }, |
| 4688 | .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ }, |
| 4689 | .{ ._, ._, .add, .tmp1w, .tmp1w, ._, ._ }, |
| 4690 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 4691 | } }, |
| 4692 | }, .{ |
| 4693 | .required_features = .{ .cmov, null, null, null }, |
| 4694 | .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any }, |
| 4695 | .patterns = &.{ |
| 4696 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4697 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4698 | }, |
| 4699 | .extra_temps = .{ |
| 4700 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4701 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4702 | .unused, |
| 4703 | .unused, |
| 4704 | .unused, |
| 4705 | .unused, |
| 4706 | .unused, |
| 4707 | .unused, |
| 4708 | .unused, |
| 4709 | .unused, |
| 4710 | .unused, |
| 4711 | }, |
| 4712 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4713 | .clobbers = .{ .eflags = true }, |
| 4714 | .each = .{ .once = &.{ |
| 4715 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4716 | .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ }, |
| 4717 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 4718 | .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ }, |
| 4719 | .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ }, |
| 4720 | .{ ._, ._, .add, .tmp1w, .tmp1w, ._, ._ }, |
| 4721 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 4722 | } }, |
| 4723 | }, .{ |
| 4724 | .required_features = .{ .cmov, null, null, null }, |
| 4725 | .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any }, |
| 4726 | .patterns = &.{ |
| 4727 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 4728 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4729 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4730 | }, |
| 4731 | .extra_temps = .{ |
| 4732 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4733 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4734 | .unused, |
| 4735 | .unused, |
| 4736 | .unused, |
| 4737 | .unused, |
| 4738 | .unused, |
| 4739 | .unused, |
| 4740 | .unused, |
| 4741 | .unused, |
| 4742 | .unused, |
| 4743 | }, |
| 4744 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4745 | .clobbers = .{ .eflags = true }, |
| 4746 | .each = .{ .once = &.{ |
| 4747 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4748 | .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ }, |
| 4749 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 4750 | .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ }, |
| 4751 | .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ }, |
| 4752 | .{ ._, ._, .add, .tmp1w, .tmp1w, ._, ._ }, |
| 4753 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 4754 | } }, |
| 4755 | }, .{ |
| 4756 | .required_features = .{ .fast_imm16, null, null, null }, |
| 4757 | .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any }, |
| 4758 | .patterns = &.{ |
| 4759 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 4760 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4761 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4762 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4763 | }, |
| 4764 | .extra_temps = .{ |
| 4765 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4766 | .unused, |
| 4767 | .unused, |
| 4768 | .unused, |
| 4769 | .unused, |
| 4770 | .unused, |
| 4771 | .unused, |
| 4772 | .unused, |
| 4773 | .unused, |
| 4774 | .unused, |
| 4775 | .unused, |
| 4776 | }, |
| 4777 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4778 | .clobbers = .{ .eflags = true }, |
| 4779 | .each = .{ .once = &.{ |
| 4780 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 4781 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4782 | .{ ._, ._, .add, .tmp0w, .tmp0w, ._, ._ }, |
| 4783 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 4784 | .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ }, |
| 4785 | .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ }, |
| 4786 | } }, |
| 4787 | }, .{ |
| 4788 | .required_features = .{ .fast_imm16, null, null, null }, |
| 4789 | .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any }, |
| 4790 | .patterns = &.{ |
| 4791 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4792 | }, |
| 4793 | .extra_temps = .{ |
| 4794 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4795 | .unused, |
| 4796 | .unused, |
| 4797 | .unused, |
| 4798 | .unused, |
| 4799 | .unused, |
| 4800 | .unused, |
| 4801 | .unused, |
| 4802 | .unused, |
| 4803 | .unused, |
| 4804 | .unused, |
| 4805 | }, |
| 4806 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4807 | .clobbers = .{ .eflags = true }, |
| 4808 | .each = .{ .once = &.{ |
| 4809 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 4810 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4811 | .{ ._, ._, .add, .tmp0w, .tmp0w, ._, ._ }, |
| 4812 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 4813 | .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ }, |
| 4814 | .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ }, |
| 4815 | } }, |
| 4816 | }, .{ |
| 4817 | .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any }, |
| 4818 | .patterns = &.{ |
| 4819 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4820 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4821 | }, |
| 4822 | .extra_temps = .{ |
| 4823 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4824 | .unused, |
| 4825 | .unused, |
| 4826 | .unused, |
| 4827 | .unused, |
| 4828 | .unused, |
| 4829 | .unused, |
| 4830 | .unused, |
| 4831 | .unused, |
| 4832 | .unused, |
| 4833 | .unused, |
| 4834 | }, |
| 4835 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4836 | .clobbers = .{ .eflags = true }, |
| 4837 | .each = .{ .once = &.{ |
| 4838 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 4839 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4840 | .{ ._, ._, .add, .tmp0w, .tmp0w, ._, ._ }, |
| 4841 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 4842 | .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ }, |
| 4843 | .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ }, |
| 4844 | } }, |
| 4845 | }, .{ |
| 4846 | .src_constraints = .{ .{ .exact_signed_int = 15 }, .{ .exact_signed_int = 15 }, .any }, |
| 4847 | .patterns = &.{ |
| 4848 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 4849 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4850 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4851 | }, |
| 4852 | .extra_temps = .{ |
| 4853 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4854 | .unused, |
| 4855 | .unused, |
| 4856 | .unused, |
| 4857 | .unused, |
| 4858 | .unused, |
| 4859 | .unused, |
| 4860 | .unused, |
| 4861 | .unused, |
| 4862 | .unused, |
| 4863 | .unused, |
| 4864 | }, |
| 4865 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4866 | .clobbers = .{ .eflags = true }, |
| 4867 | .each = .{ .once = &.{ |
| 4868 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 4869 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4870 | .{ ._, ._, .add, .tmp0w, .tmp0w, ._, ._ }, |
| 4871 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 4872 | .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ }, |
| 4873 | .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ }, |
| 4874 | } }, |
| 4875 | }, .{ |
| 4876 | .required_features = .{ .fast_imm16, .cmov, null, null }, |
| 4877 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 4878 | .patterns = &.{ |
| 4879 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 4880 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4881 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4882 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4883 | }, |
| 4884 | .extra_temps = .{ |
| 4885 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4886 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4887 | .unused, |
| 4888 | .unused, |
| 4889 | .unused, |
| 4890 | .unused, |
| 4891 | .unused, |
| 4892 | .unused, |
| 4893 | .unused, |
| 4894 | .unused, |
| 4895 | .unused, |
| 4896 | }, |
| 4897 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4898 | .clobbers = .{ .eflags = true }, |
| 4899 | .each = .{ .once = &.{ |
| 4900 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4901 | .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ }, |
| 4902 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 4903 | .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ }, |
| 4904 | .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ }, |
| 4905 | .{ ._, ._l, .sa, .tmp1d, .uia(31, .src0, .sub_bit_size), ._, ._ }, |
| 4906 | .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ }, |
| 4907 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 4908 | } }, |
| 4909 | }, .{ |
| 4910 | .required_features = .{ .fast_imm16, .cmov, null, null }, |
| 4911 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 4912 | .patterns = &.{ |
| 4913 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4914 | }, |
| 4915 | .extra_temps = .{ |
| 4916 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4917 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4918 | .unused, |
| 4919 | .unused, |
| 4920 | .unused, |
| 4921 | .unused, |
| 4922 | .unused, |
| 4923 | .unused, |
| 4924 | .unused, |
| 4925 | .unused, |
| 4926 | .unused, |
| 4927 | }, |
| 4928 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4929 | .clobbers = .{ .eflags = true }, |
| 4930 | .each = .{ .once = &.{ |
| 4931 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4932 | .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ }, |
| 4933 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 4934 | .{ ._, ._, .xor, .tmp0w, .sa(.src0, .add_smax), ._, ._ }, |
| 4935 | .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ }, |
| 4936 | .{ ._, ._l, .sa, .tmp1d, .uia(31, .src0, .sub_bit_size), ._, ._ }, |
| 4937 | .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ }, |
| 4938 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 4939 | } }, |
| 4940 | }, .{ |
| 4941 | .required_features = .{ .cmov, null, null, null }, |
| 4942 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 4943 | .patterns = &.{ |
| 4944 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 4945 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4946 | }, |
| 4947 | .extra_temps = .{ |
| 4948 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4949 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4950 | .unused, |
| 4951 | .unused, |
| 4952 | .unused, |
| 4953 | .unused, |
| 4954 | .unused, |
| 4955 | .unused, |
| 4956 | .unused, |
| 4957 | .unused, |
| 4958 | .unused, |
| 4959 | }, |
| 4960 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4961 | .clobbers = .{ .eflags = true }, |
| 4962 | .each = .{ .once = &.{ |
| 4963 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4964 | .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ }, |
| 4965 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 4966 | .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ }, |
| 4967 | .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ }, |
| 4968 | .{ ._, ._l, .sa, .tmp1d, .uia(31, .src0, .sub_bit_size), ._, ._ }, |
| 4969 | .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ }, |
| 4970 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 4971 | } }, |
| 4972 | }, .{ |
| 4973 | .required_features = .{ .cmov, null, null, null }, |
| 4974 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 4975 | .patterns = &.{ |
| 4976 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 4977 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 4978 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 4979 | }, |
| 4980 | .extra_temps = .{ |
| 4981 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4982 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 4983 | .unused, |
| 4984 | .unused, |
| 4985 | .unused, |
| 4986 | .unused, |
| 4987 | .unused, |
| 4988 | .unused, |
| 4989 | .unused, |
| 4990 | .unused, |
| 4991 | .unused, |
| 4992 | }, |
| 4993 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 4994 | .clobbers = .{ .eflags = true }, |
| 4995 | .each = .{ .once = &.{ |
| 4996 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 4997 | .{ ._, ._r, .sa, .tmp0w, .ui(15), ._, ._ }, |
| 4998 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 4999 | .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ }, |
| 5000 | .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ }, |
| 5001 | .{ ._, ._l, .sa, .tmp1d, .uia(31, .src0, .sub_bit_size), ._, ._ }, |
| 5002 | .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ }, |
| 5003 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 5004 | } }, |
| 5005 | }, .{ |
| 5006 | .required_features = .{ .fast_imm16, null, null, null }, |
| 5007 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 5008 | .patterns = &.{ |
| 5009 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 5010 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5011 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5012 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5013 | }, |
| 5014 | .extra_temps = .{ |
| 5015 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 5016 | .unused, |
| 5017 | .unused, |
| 5018 | .unused, |
| 5019 | .unused, |
| 5020 | .unused, |
| 5021 | .unused, |
| 5022 | .unused, |
| 5023 | .unused, |
| 5024 | .unused, |
| 5025 | .unused, |
| 5026 | }, |
| 5027 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5028 | .clobbers = .{ .eflags = true }, |
| 5029 | .each = .{ .once = &.{ |
| 5030 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 5031 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 5032 | .{ ._, ._l, .sa, .tmp0d, .uia(31, .src0, .sub_bit_size), ._, ._ }, |
| 5033 | .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ }, |
| 5034 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 5035 | .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ }, |
| 5036 | .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ }, |
| 5037 | } }, |
| 5038 | }, .{ |
| 5039 | .required_features = .{ .fast_imm16, null, null, null }, |
| 5040 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 5041 | .patterns = &.{ |
| 5042 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5043 | }, |
| 5044 | .extra_temps = .{ |
| 5045 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 5046 | .unused, |
| 5047 | .unused, |
| 5048 | .unused, |
| 5049 | .unused, |
| 5050 | .unused, |
| 5051 | .unused, |
| 5052 | .unused, |
| 5053 | .unused, |
| 5054 | .unused, |
| 5055 | .unused, |
| 5056 | }, |
| 5057 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5058 | .clobbers = .{ .eflags = true }, |
| 5059 | .each = .{ .once = &.{ |
| 5060 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 5061 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 5062 | .{ ._, ._l, .sa, .tmp0d, .uia(31, .src0, .sub_bit_size), ._, ._ }, |
| 5063 | .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ }, |
| 5064 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 5065 | .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ }, |
| 5066 | .{ ._, ._, .xor, .dst0w, .sa(.src0, .add_smax), ._, ._ }, |
| 5067 | } }, |
| 5068 | }, .{ |
| 5069 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 5070 | .patterns = &.{ |
| 5071 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5072 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5073 | }, |
| 5074 | .extra_temps = .{ |
| 5075 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 5076 | .unused, |
| 5077 | .unused, |
| 5078 | .unused, |
| 5079 | .unused, |
| 5080 | .unused, |
| 5081 | .unused, |
| 5082 | .unused, |
| 5083 | .unused, |
| 5084 | .unused, |
| 5085 | .unused, |
| 5086 | }, |
| 5087 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5088 | .clobbers = .{ .eflags = true }, |
| 5089 | .each = .{ .once = &.{ |
| 5090 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 5091 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 5092 | .{ ._, ._l, .sa, .tmp0d, .uia(31, .src0, .sub_bit_size), ._, ._ }, |
| 5093 | .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ }, |
| 5094 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 5095 | .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ }, |
| 5096 | .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ }, |
| 5097 | } }, |
| 5098 | }, .{ |
| 5099 | .src_constraints = .{ .{ .signed_int = .word }, .{ .signed_int = .word }, .any }, |
| 5100 | .patterns = &.{ |
| 5101 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 5102 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5103 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5104 | }, |
| 5105 | .extra_temps = .{ |
| 5106 | .{ .type = .i16, .kind = .{ .rc = .general_purpose } }, |
| 5107 | .unused, |
| 5108 | .unused, |
| 5109 | .unused, |
| 5110 | .unused, |
| 5111 | .unused, |
| 5112 | .unused, |
| 5113 | .unused, |
| 5114 | .unused, |
| 5115 | .unused, |
| 5116 | .unused, |
| 5117 | }, |
| 5118 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5119 | .clobbers = .{ .eflags = true }, |
| 5120 | .each = .{ .once = &.{ |
| 5121 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 5122 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 5123 | .{ ._, ._l, .sa, .tmp0d, .uia(31, .src0, .sub_bit_size), ._, ._ }, |
| 5124 | .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ }, |
| 5125 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 5126 | .{ ._, ._r, .sa, .dst0w, .ui(15), ._, ._ }, |
| 5127 | .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ }, |
| 5128 | } }, |
| 5129 | }, .{ |
| 5130 | .src_constraints = .{ .{ .exact_unsigned_int = 16 }, .{ .exact_unsigned_int = 16 }, .any }, |
| 5131 | .patterns = &.{ |
| 5132 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 5133 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5134 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5135 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5136 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5137 | }, |
| 5138 | .extra_temps = .{ |
| 5139 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 5140 | .unused, |
| 5141 | .unused, |
| 5142 | .unused, |
| 5143 | .unused, |
| 5144 | .unused, |
| 5145 | .unused, |
| 5146 | .unused, |
| 5147 | .unused, |
| 5148 | .unused, |
| 5149 | .unused, |
| 5150 | }, |
| 5151 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5152 | .clobbers = .{ .eflags = true }, |
| 5153 | .each = .{ .once = &.{ |
| 5154 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 5155 | .{ ._, ._, .sbb, .tmp0d, .tmp0d, ._, ._ }, |
| 5156 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| 5157 | } }, |
| 5158 | }, .{ |
| 5159 | .required_features = .{ .cmov, null, null, null }, |
| 5160 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| 5161 | .patterns = &.{ |
| 5162 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5163 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5164 | }, |
| 5165 | .extra_temps = .{ |
| 5166 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 5167 | .unused, |
| 5168 | .unused, |
| 5169 | .unused, |
| 5170 | .unused, |
| 5171 | .unused, |
| 5172 | .unused, |
| 5173 | .unused, |
| 5174 | .unused, |
| 5175 | .unused, |
| 5176 | .unused, |
| 5177 | }, |
| 5178 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5179 | .clobbers = .{ .eflags = true }, |
| 5180 | .each = .{ .once = &.{ |
| 5181 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 5182 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ }, |
| 5183 | .{ ._, ._, .cmp, .dst0w, .tmp0w, ._, ._ }, |
| 5184 | .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 5185 | } }, |
| 5186 | }, .{ |
| 5187 | .required_features = .{ .cmov, null, null, null }, |
| 5188 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| 5189 | .patterns = &.{ |
| 5190 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 5191 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5192 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5193 | }, |
| 5194 | .extra_temps = .{ |
| 5195 | .{ .type = .u16, .kind = .{ .rc = .general_purpose } }, |
| 5196 | .unused, |
| 5197 | .unused, |
| 5198 | .unused, |
| 5199 | .unused, |
| 5200 | .unused, |
| 5201 | .unused, |
| 5202 | .unused, |
| 5203 | .unused, |
| 5204 | .unused, |
| 5205 | .unused, |
| 5206 | }, |
| 5207 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5208 | .clobbers = .{ .eflags = true }, |
| 5209 | .each = .{ .once = &.{ |
| 5210 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 5211 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ }, |
| 5212 | .{ ._, ._, .cmp, .dst0w, .tmp0w, ._, ._ }, |
| 5213 | .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 5214 | } }, |
| 5215 | }, .{ |
| 5216 | .required_features = .{ .fast_imm16, null, null, null }, |
| 5217 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| 5218 | .patterns = &.{ |
| 5219 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5220 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5221 | }, |
| 5222 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5223 | .clobbers = .{ .eflags = true }, |
| 5224 | .each = .{ .once = &.{ |
| 5225 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 5226 | .{ ._, ._, .cmp, .dst0w, .ua(.src0, .add_umax), ._, ._ }, |
| 5227 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, |
| 5228 | .{ ._, ._, .mov, .dst0w, .ua(.src0, .add_umax), ._, ._ }, |
| 5229 | } }, |
| 5230 | }, .{ |
| 5231 | .required_features = .{ .fast_imm16, null, null, null }, |
| 5232 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| 5233 | .patterns = &.{ |
| 5234 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 5235 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5236 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5237 | }, |
| 5238 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5239 | .clobbers = .{ .eflags = true }, |
| 5240 | .each = .{ .once = &.{ |
| 5241 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 5242 | .{ ._, ._, .cmp, .dst0w, .ua(.src0, .add_umax), ._, ._ }, |
| 5243 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, |
| 5244 | .{ ._, ._, .mov, .dst0w, .ua(.src0, .add_umax), ._, ._ }, |
| 5245 | } }, |
| 5246 | }, .{ |
| 5247 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| 5248 | .patterns = &.{ |
| 5249 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5250 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5251 | }, |
| 5252 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5253 | .clobbers = .{ .eflags = true }, |
| 5254 | .each = .{ .once = &.{ |
| 5255 | .{ ._, ._, .add, .dst0w, .src1w, ._, ._ }, |
| 5256 | .{ ._, ._, .cmp, .dst0w, .ua(.src0, .add_umax), ._, ._ }, |
| 5257 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, |
| 5258 | .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| 5259 | } }, |
| 5260 | }, .{ |
| 5261 | .src_constraints = .{ .{ .unsigned_int = .word }, .{ .unsigned_int = .word }, .any }, |
| 5262 | .patterns = &.{ |
| 5263 | .{ .src = .{ .to_mut_gpr, .imm16, .none } }, |
| 5264 | .{ .src = .{ .imm16, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5265 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5266 | }, |
| 5267 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5268 | .clobbers = .{ .eflags = true }, |
| 5269 | .each = .{ .once = &.{ |
| 5270 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 5271 | .{ ._, ._, .cmp, .dst0w, .ua(.src0, .add_umax), ._, ._ }, |
| 5272 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, |
| 5273 | .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| 5274 | } }, |
| 5275 | }, .{ |
| 5276 | .required_features = .{ .cmov, null, null, null }, |
| 5277 | .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any }, |
| 5278 | .patterns = &.{ |
| 5279 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| 5280 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5281 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5282 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5283 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5284 | }, |
| 5285 | .extra_temps = .{ |
| 5286 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 5287 | .unused, |
| 5288 | .unused, |
| 5289 | .unused, |
| 5290 | .unused, |
| 5291 | .unused, |
| 5292 | .unused, |
| 5293 | .unused, |
| 5294 | .unused, |
| 5295 | .unused, |
| 5296 | .unused, |
| 5297 | }, |
| 5298 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5299 | .clobbers = .{ .eflags = true }, |
| 5300 | .each = .{ .once = &.{ |
| 5301 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 5302 | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, |
| 5303 | .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ }, |
| 5304 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 5305 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 5306 | } }, |
| 5307 | }, .{ |
| 5308 | .src_constraints = .{ .{ .exact_signed_int = 32 }, .{ .exact_signed_int = 32 }, .any }, |
| 5309 | .patterns = &.{ |
| 5310 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| 5311 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5312 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5313 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5314 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5315 | }, |
| 5316 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5317 | .clobbers = .{ .eflags = true }, |
| 5318 | .each = .{ .once = &.{ |
| 5319 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 5320 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 5321 | .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ }, |
| 5322 | .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smin), ._, ._ }, |
| 5323 | } }, |
| 5324 | }, .{ |
| 5325 | .required_features = .{ .cmov, null, null, null }, |
| 5326 | .src_constraints = .{ .{ .exact_signed_int = 31 }, .{ .exact_signed_int = 31 }, .any }, |
| 5327 | .patterns = &.{ |
| 5328 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| 5329 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5330 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5331 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5332 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5333 | }, |
| 5334 | .extra_temps = .{ |
| 5335 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 5336 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 5337 | .unused, |
| 5338 | .unused, |
| 5339 | .unused, |
| 5340 | .unused, |
| 5341 | .unused, |
| 5342 | .unused, |
| 5343 | .unused, |
| 5344 | .unused, |
| 5345 | .unused, |
| 5346 | }, |
| 5347 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5348 | .clobbers = .{ .eflags = true }, |
| 5349 | .each = .{ .once = &.{ |
| 5350 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 5351 | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, |
| 5352 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 5353 | .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ }, |
| 5354 | .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ }, |
| 5355 | .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ }, |
| 5356 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 5357 | } }, |
| 5358 | }, .{ |
| 5359 | .src_constraints = .{ .{ .exact_signed_int = 31 }, .{ .exact_signed_int = 31 }, .any }, |
| 5360 | .patterns = &.{ |
| 5361 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| 5362 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5363 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5364 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5365 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5366 | }, |
| 5367 | .extra_temps = .{ |
| 5368 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 5369 | .unused, |
| 5370 | .unused, |
| 5371 | .unused, |
| 5372 | .unused, |
| 5373 | .unused, |
| 5374 | .unused, |
| 5375 | .unused, |
| 5376 | .unused, |
| 5377 | .unused, |
| 5378 | .unused, |
| 5379 | }, |
| 5380 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5381 | .clobbers = .{ .eflags = true }, |
| 5382 | .each = .{ .once = &.{ |
| 5383 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 5384 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 5385 | .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ }, |
| 5386 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 5387 | .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ }, |
| 5388 | .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ }, |
| 5389 | } }, |
| 5390 | }, .{ |
| 5391 | .required_features = .{ .cmov, null, null, null }, |
| 5392 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| 5393 | .patterns = &.{ |
| 5394 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| 5395 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5396 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5397 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5398 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5399 | }, |
| 5400 | .extra_temps = .{ |
| 5401 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 5402 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 5403 | .unused, |
| 5404 | .unused, |
| 5405 | .unused, |
| 5406 | .unused, |
| 5407 | .unused, |
| 5408 | .unused, |
| 5409 | .unused, |
| 5410 | .unused, |
| 5411 | .unused, |
| 5412 | }, |
| 5413 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5414 | .clobbers = .{ .eflags = true }, |
| 5415 | .each = .{ .once = &.{ |
| 5416 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 5417 | .{ ._, ._r, .sa, .tmp0d, .ui(31), ._, ._ }, |
| 5418 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 5419 | .{ ._, ._, .xor, .tmp0d, .sa(.src0, .add_smax), ._, ._ }, |
| 5420 | .{ ._, ._, .mov, .tmp1d, .dst0d, ._, ._ }, |
| 5421 | .{ ._, ._l, .sa, .tmp1d, .uia(31, .src0, .sub_bit_size), ._, ._ }, |
| 5422 | .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ }, |
| 5423 | .{ ._, ._o, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 5424 | } }, |
| 5425 | }, .{ |
| 5426 | .src_constraints = .{ .{ .signed_int = .dword }, .{ .signed_int = .dword }, .any }, |
| 5427 | .patterns = &.{ |
| 5428 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| 5429 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5430 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5431 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5432 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5433 | }, |
| 5434 | .extra_temps = .{ |
| 5435 | .{ .type = .i32, .kind = .{ .rc = .general_purpose } }, |
| 5436 | .unused, |
| 5437 | .unused, |
| 5438 | .unused, |
| 5439 | .unused, |
| 5440 | .unused, |
| 5441 | .unused, |
| 5442 | .unused, |
| 5443 | .unused, |
| 5444 | .unused, |
| 5445 | .unused, |
| 5446 | }, |
| 5447 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5448 | .clobbers = .{ .eflags = true }, |
| 5449 | .each = .{ .once = &.{ |
| 5450 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 5451 | .{ ._, ._, .mov, .tmp0d, .dst0d, ._, ._ }, |
| 5452 | .{ ._, ._l, .sa, .tmp0d, .uia(31, .src0, .sub_bit_size), ._, ._ }, |
| 5453 | .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ }, |
| 5454 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 5455 | .{ ._, ._r, .sa, .dst0d, .ui(31), ._, ._ }, |
| 5456 | .{ ._, ._, .xor, .dst0d, .sa(.src0, .add_smax), ._, ._ }, |
| 5457 | } }, |
| 5458 | }, .{ |
| 5459 | .src_constraints = .{ .{ .exact_unsigned_int = 32 }, .{ .exact_unsigned_int = 32 }, .any }, |
| 5460 | .patterns = &.{ |
| 5461 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| 5462 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5463 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5464 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5465 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5466 | }, |
| 5467 | .extra_temps = .{ |
| 5468 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 5469 | .unused, |
| 5470 | .unused, |
| 5471 | .unused, |
| 5472 | .unused, |
| 5473 | .unused, |
| 5474 | .unused, |
| 5475 | .unused, |
| 5476 | .unused, |
| 5477 | .unused, |
| 5478 | .unused, |
| 5479 | }, |
| 5480 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5481 | .clobbers = .{ .eflags = true }, |
| 5482 | .each = .{ .once = &.{ |
| 5483 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 5484 | .{ ._, ._, .sbb, .tmp0d, .tmp0d, ._, ._ }, |
| 5485 | .{ ._, ._, .@"or", .dst0d, .tmp0d, ._, ._ }, |
| 5486 | } }, |
| 5487 | }, .{ |
| 5488 | .required_features = .{ .cmov, null, null, null }, |
| 5489 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| 5490 | .patterns = &.{ |
| 5491 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| 5492 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5493 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5494 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5495 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5496 | }, |
| 5497 | .extra_temps = .{ |
| 5498 | .{ .type = .u32, .kind = .{ .rc = .general_purpose } }, |
| 5499 | .unused, |
| 5500 | .unused, |
| 5501 | .unused, |
| 5502 | .unused, |
| 5503 | .unused, |
| 5504 | .unused, |
| 5505 | .unused, |
| 5506 | .unused, |
| 5507 | .unused, |
| 5508 | .unused, |
| 5509 | }, |
| 5510 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5511 | .clobbers = .{ .eflags = true }, |
| 5512 | .each = .{ .once = &.{ |
| 5513 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 5514 | .{ ._, ._, .mov, .tmp0d, .ua(.src0, .add_umax), ._, ._ }, |
| 5515 | .{ ._, ._, .cmp, .dst0d, .tmp0d, ._, ._ }, |
| 5516 | .{ ._, ._a, .cmov, .dst0d, .tmp0d, ._, ._ }, |
| 5517 | } }, |
| 5518 | }, .{ |
| 5519 | .src_constraints = .{ .{ .unsigned_int = .dword }, .{ .unsigned_int = .dword }, .any }, |
| 5520 | .patterns = &.{ |
| 5521 | .{ .src = .{ .to_mut_gpr, .imm32, .none } }, |
| 5522 | .{ .src = .{ .imm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5523 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5524 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5525 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5526 | }, |
| 5527 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5528 | .clobbers = .{ .eflags = true }, |
| 5529 | .each = .{ .once = &.{ |
| 5530 | .{ ._, ._, .add, .dst0d, .src1d, ._, ._ }, |
| 5531 | .{ ._, ._, .cmp, .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| 5532 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, |
| 5533 | .{ ._, ._, .mov, .dst0d, .ua(.src0, .add_umax), ._, ._ }, |
| 5534 | } }, |
| 5535 | }, .{ |
| 5536 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 5537 | .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any }, |
| 5538 | .patterns = &.{ |
| 5539 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| 5540 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5541 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5542 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5543 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5544 | }, |
| 5545 | .extra_temps = .{ |
| 5546 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 5547 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 5548 | .unused, |
| 5549 | .unused, |
| 5550 | .unused, |
| 5551 | .unused, |
| 5552 | .unused, |
| 5553 | .unused, |
| 5554 | .unused, |
| 5555 | .unused, |
| 5556 | .unused, |
| 5557 | }, |
| 5558 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5559 | .clobbers = .{ .eflags = true }, |
| 5560 | .each = .{ .once = &.{ |
| 5561 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| 5562 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 5563 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| 5564 | .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ }, |
| 5565 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| 5566 | .{ ._, ._o, .cmov, .dst0q, .tmp0q, ._, ._ }, |
| 5567 | } }, |
| 5568 | }, .{ |
| 5569 | .required_features = .{ .@"64bit", null, null, null }, |
| 5570 | .src_constraints = .{ .{ .exact_signed_int = 64 }, .{ .exact_signed_int = 64 }, .any }, |
| 5571 | .patterns = &.{ |
| 5572 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| 5573 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5574 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5575 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5576 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5577 | }, |
| 5578 | .extra_temps = .{ |
| 5579 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 5580 | .unused, |
| 5581 | .unused, |
| 5582 | .unused, |
| 5583 | .unused, |
| 5584 | .unused, |
| 5585 | .unused, |
| 5586 | .unused, |
| 5587 | .unused, |
| 5588 | .unused, |
| 5589 | .unused, |
| 5590 | }, |
| 5591 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5592 | .clobbers = .{ .eflags = true }, |
| 5593 | .each = .{ .once = &.{ |
| 5594 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| 5595 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 5596 | .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ }, |
| 5597 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smin), ._, ._ }, |
| 5598 | .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ }, |
| 5599 | } }, |
| 5600 | }, .{ |
| 5601 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 5602 | .src_constraints = .{ .{ .exact_signed_int = 63 }, .{ .exact_signed_int = 63 }, .any }, |
| 5603 | .patterns = &.{ |
| 5604 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| 5605 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5606 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5607 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5608 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5609 | }, |
| 5610 | .extra_temps = .{ |
| 5611 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 5612 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 5613 | .unused, |
| 5614 | .unused, |
| 5615 | .unused, |
| 5616 | .unused, |
| 5617 | .unused, |
| 5618 | .unused, |
| 5619 | .unused, |
| 5620 | .unused, |
| 5621 | .unused, |
| 5622 | }, |
| 5623 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5624 | .clobbers = .{ .eflags = true }, |
| 5625 | .each = .{ .once = &.{ |
| 5626 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| 5627 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 5628 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| 5629 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| 5630 | .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ }, |
| 5631 | .{ ._, ._, .mov, .tmp1q, .dst0q, ._, ._ }, |
| 5632 | .{ ._, ._, .add, .tmp1q, .tmp1q, ._, ._ }, |
| 5633 | .{ ._, ._o, .cmov, .dst0q, .tmp0q, ._, ._ }, |
| 5634 | } }, |
| 5635 | }, .{ |
| 5636 | .required_features = .{ .@"64bit", null, null, null }, |
| 5637 | .src_constraints = .{ .{ .exact_signed_int = 63 }, .{ .exact_signed_int = 63 }, .any }, |
| 5638 | .patterns = &.{ |
| 5639 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| 5640 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5641 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5642 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5643 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5644 | }, |
| 5645 | .extra_temps = .{ |
| 5646 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 5647 | .unused, |
| 5648 | .unused, |
| 5649 | .unused, |
| 5650 | .unused, |
| 5651 | .unused, |
| 5652 | .unused, |
| 5653 | .unused, |
| 5654 | .unused, |
| 5655 | .unused, |
| 5656 | .unused, |
| 5657 | }, |
| 5658 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5659 | .clobbers = .{ .eflags = true }, |
| 5660 | .each = .{ .once = &.{ |
| 5661 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| 5662 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| 5663 | .{ ._, ._, .add, .tmp0q, .tmp0q, ._, ._ }, |
| 5664 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 5665 | .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ }, |
| 5666 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smax), ._, ._ }, |
| 5667 | .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ }, |
| 5668 | } }, |
| 5669 | }, .{ |
| 5670 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 5671 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| 5672 | .patterns = &.{ |
| 5673 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| 5674 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5675 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5676 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5677 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5678 | }, |
| 5679 | .extra_temps = .{ |
| 5680 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 5681 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 5682 | .unused, |
| 5683 | .unused, |
| 5684 | .unused, |
| 5685 | .unused, |
| 5686 | .unused, |
| 5687 | .unused, |
| 5688 | .unused, |
| 5689 | .unused, |
| 5690 | .unused, |
| 5691 | }, |
| 5692 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5693 | .clobbers = .{ .eflags = true }, |
| 5694 | .each = .{ .once = &.{ |
| 5695 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| 5696 | .{ ._, ._r, .sa, .tmp0q, .ui(63), ._, ._ }, |
| 5697 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| 5698 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_smax), ._, ._ }, |
| 5699 | .{ ._, ._, .xor, .tmp0q, .tmp1q, ._, ._ }, |
| 5700 | .{ ._, ._, .mov, .tmp1q, .dst0q, ._, ._ }, |
| 5701 | .{ ._, ._r, .sh, .tmp1q, .sia(-31, .src0, .add_bit_size), ._, ._ }, |
| 5702 | .{ ._, ._, .add, .tmp1d, .tmp1d, ._, ._ }, |
| 5703 | .{ ._, ._o, .cmov, .dst0q, .tmp0q, ._, ._ }, |
| 5704 | } }, |
| 5705 | }, .{ |
| 5706 | .required_features = .{ .@"64bit", null, null, null }, |
| 5707 | .src_constraints = .{ .{ .signed_int = .qword }, .{ .signed_int = .qword }, .any }, |
| 5708 | .patterns = &.{ |
| 5709 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| 5710 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5711 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5712 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5713 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5714 | }, |
| 5715 | .extra_temps = .{ |
| 5716 | .{ .type = .i64, .kind = .{ .rc = .general_purpose } }, |
| 5717 | .unused, |
| 5718 | .unused, |
| 5719 | .unused, |
| 5720 | .unused, |
| 5721 | .unused, |
| 5722 | .unused, |
| 5723 | .unused, |
| 5724 | .unused, |
| 5725 | .unused, |
| 5726 | .unused, |
| 5727 | }, |
| 5728 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5729 | .clobbers = .{ .eflags = true }, |
| 5730 | .each = .{ .once = &.{ |
| 5731 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| 5732 | .{ ._, ._, .mov, .tmp0q, .dst0q, ._, ._ }, |
| 5733 | .{ ._, ._r, .sh, .tmp0q, .sia(-31, .src0, .add_bit_size), ._, ._ }, |
| 5734 | .{ ._, ._, .add, .tmp0d, .tmp0d, ._, ._ }, |
| 5735 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 5736 | .{ ._, ._r, .sa, .dst0q, .ui(63), ._, ._ }, |
| 5737 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_smax), ._, ._ }, |
| 5738 | .{ ._, ._, .xor, .dst0q, .tmp0q, ._, ._ }, |
| 5739 | } }, |
| 5740 | }, .{ |
| 5741 | .required_features = .{ .@"64bit", null, null, null }, |
| 5742 | .src_constraints = .{ .{ .exact_unsigned_int = 64 }, .{ .exact_unsigned_int = 64 }, .any }, |
| 5743 | .patterns = &.{ |
| 5744 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| 5745 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5746 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5747 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5748 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5749 | }, |
| 5750 | .extra_temps = .{ |
| 5751 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 5752 | .unused, |
| 5753 | .unused, |
| 5754 | .unused, |
| 5755 | .unused, |
| 5756 | .unused, |
| 5757 | .unused, |
| 5758 | .unused, |
| 5759 | .unused, |
| 5760 | .unused, |
| 5761 | .unused, |
| 5762 | }, |
| 5763 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5764 | .clobbers = .{ .eflags = true }, |
| 5765 | .each = .{ .once = &.{ |
| 5766 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| 5767 | .{ ._, ._, .sbb, .tmp0q, .tmp0q, ._, ._ }, |
| 5768 | .{ ._, ._, .@"or", .dst0q, .tmp0q, ._, ._ }, |
| 5769 | } }, |
| 5770 | }, .{ |
| 5771 | .required_features = .{ .@"64bit", .cmov, null, null }, |
| 5772 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| 5773 | .patterns = &.{ |
| 5774 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| 5775 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5776 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5777 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5778 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5779 | }, |
| 5780 | .extra_temps = .{ |
| 5781 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 5782 | .unused, |
| 5783 | .unused, |
| 5784 | .unused, |
| 5785 | .unused, |
| 5786 | .unused, |
| 5787 | .unused, |
| 5788 | .unused, |
| 5789 | .unused, |
| 5790 | .unused, |
| 5791 | .unused, |
| 5792 | }, |
| 5793 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5794 | .clobbers = .{ .eflags = true }, |
| 5795 | .each = .{ .once = &.{ |
| 5796 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| 5797 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| 5798 | .{ ._, ._, .cmp, .dst0q, .tmp0q, ._, ._ }, |
| 5799 | .{ ._, ._a, .cmov, .dst0q, .tmp0q, ._, ._ }, |
| 5800 | } }, |
| 5801 | }, .{ |
| 5802 | .required_features = .{ .@"64bit", null, null, null }, |
| 5803 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| 5804 | .patterns = &.{ |
| 5805 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| 5806 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5807 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5808 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5809 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5810 | }, |
| 5811 | .extra_temps = .{ |
| 5812 | .{ .type = .u64, .kind = .{ .rc = .general_purpose } }, |
| 5813 | .unused, |
| 5814 | .unused, |
| 5815 | .unused, |
| 5816 | .unused, |
| 5817 | .unused, |
| 5818 | .unused, |
| 5819 | .unused, |
| 5820 | .unused, |
| 5821 | .unused, |
| 5822 | .unused, |
| 5823 | }, |
| 5824 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5825 | .clobbers = .{ .eflags = true }, |
| 5826 | .each = .{ .once = &.{ |
| 5827 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| 5828 | .{ ._, ._, .mov, .tmp0q, .ua(.src0, .add_umax), ._, ._ }, |
| 5829 | .{ ._, ._, .cmp, .dst0q, .tmp0q, ._, ._ }, |
| 5830 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, |
| 5831 | .{ ._, ._, .mov, .dst0q, .tmp0q, ._, ._ }, |
| 5832 | } }, |
| 5833 | }, .{ |
| 5834 | .required_features = .{ .@"64bit", null, null, null }, |
| 5835 | .src_constraints = .{ .{ .unsigned_int = .qword }, .{ .unsigned_int = .qword }, .any }, |
| 5836 | .patterns = &.{ |
| 5837 | .{ .src = .{ .to_mut_gpr, .simm32, .none } }, |
| 5838 | .{ .src = .{ .simm32, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5839 | .{ .src = .{ .to_mut_gpr, .mem, .none } }, |
| 5840 | .{ .src = .{ .mem, .to_mut_gpr, .none }, .commute = .{ 0, 1 } }, |
| 5841 | .{ .src = .{ .to_mut_gpr, .to_gpr, .none } }, |
| 5842 | }, |
| 5843 | .dst_temps = .{ .{ .ref = .src0 }, .unused }, |
| 5844 | .clobbers = .{ .eflags = true }, |
| 5845 | .each = .{ .once = &.{ |
| 5846 | .{ ._, ._, .add, .dst0q, .src1q, ._, ._ }, |
| 5847 | .{ ._, ._, .cmp, .dst0q, .ua(.src0, .add_umax), ._, ._ }, |
| 5848 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, |
| 5849 | .{ ._, ._, .mov, .dst0q, .ua(.src0, .add_umax), ._, ._ }, |
| 5850 | } }, |
| 5851 | }, .{ |
| 5852 | .required_features = .{ .@"64bit", null, null, null }, |
| 5853 | .src_constraints = .{ |
| 5854 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| 5855 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| 5856 | .any, |
| 5857 | }, |
| 5858 | .patterns = &.{ |
| 5859 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5860 | }, |
| 5861 | .extra_temps = .{ |
| 5862 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 5863 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 5864 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 5865 | .unused, |
| 5866 | .unused, |
| 5867 | .unused, |
| 5868 | .unused, |
| 5869 | .unused, |
| 5870 | .unused, |
| 5871 | .unused, |
| 5872 | .unused, |
| 5873 | }, |
| 5874 | .dst_temps = .{ .mem, .unused }, |
| 5875 | .clobbers = .{ .eflags = true }, |
| 5876 | .each = .{ .once = &.{ |
| 5877 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| 5878 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 5879 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 5880 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 5881 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp1q, ._, ._ }, |
| 5882 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 5883 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 5884 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -8), ._, ._ }, |
| 5885 | .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -8), ._, ._ }, |
| 5886 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 5887 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 5888 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| 5889 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| 5890 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 5891 | .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ }, |
| 5892 | .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ }, |
| 5893 | .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ }, |
| 5894 | } }, |
| 5895 | }, .{ |
| 5896 | .required_features = .{ .@"64bit", null, null, null }, |
| 5897 | .src_constraints = .{ |
| 5898 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| 5899 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| 5900 | .any, |
| 5901 | }, |
| 5902 | .patterns = &.{ |
| 5903 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5904 | }, |
| 5905 | .extra_temps = .{ |
| 5906 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 5907 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 5908 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 5909 | .unused, |
| 5910 | .unused, |
| 5911 | .unused, |
| 5912 | .unused, |
| 5913 | .unused, |
| 5914 | .unused, |
| 5915 | .unused, |
| 5916 | .unused, |
| 5917 | }, |
| 5918 | .dst_temps = .{ .mem, .unused }, |
| 5919 | .clobbers = .{ .eflags = true }, |
| 5920 | .each = .{ .once = &.{ |
| 5921 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| 5922 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 5923 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 5924 | .{ ._, ._, .adc, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 5925 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 5926 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 5927 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 5928 | .{ ._, ._nc, .j, .@"0f", ._, ._, ._ }, |
| 5929 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 5930 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, |
| 5931 | .{ ._, ._, .mov, .tmp2d, .sa(.src0, .add_size_div_8), ._, ._ }, |
| 5932 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 5933 | } }, |
| 5934 | }, .{ |
| 5935 | .required_features = .{ .@"64bit", null, null, null }, |
| 5936 | .src_constraints = .{ |
| 5937 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| 5938 | .{ .exact_remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| 5939 | .any, |
| 5940 | }, |
| 5941 | .patterns = &.{ |
| 5942 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5943 | }, |
| 5944 | .extra_temps = .{ |
| 5945 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 5946 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 5947 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 5948 | .unused, |
| 5949 | .unused, |
| 5950 | .unused, |
| 5951 | .unused, |
| 5952 | .unused, |
| 5953 | .unused, |
| 5954 | .unused, |
| 5955 | .unused, |
| 5956 | }, |
| 5957 | .dst_temps = .{ .mem, .unused }, |
| 5958 | .clobbers = .{ .eflags = true }, |
| 5959 | .each = .{ .once = &.{ |
| 5960 | .{ ._, ._, .mov, .tmp0p, .sia(2, .src0, .sub_size_div_8), ._, ._ }, |
| 5961 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 5962 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| 5963 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -16), ._, ._ }, |
| 5964 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -16), .tmp1q, ._, ._ }, |
| 5965 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 5966 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 5967 | .{ ._, ._, .mov, .tmp1q, .memad(.src0q, .add_size, -16), ._, ._ }, |
| 5968 | .{ ._, ._, .adc, .tmp1q, .memad(.src1q, .add_size, -16), ._, ._ }, |
| 5969 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 5970 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 5971 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| 5972 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, |
| 5973 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 5974 | .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ }, |
| 5975 | .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ }, |
| 5976 | .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ }, |
| 5977 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| 5978 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ }, |
| 5979 | } }, |
| 5980 | }, .{ |
| 5981 | .required_features = .{ .@"64bit", null, null, null }, |
| 5982 | .src_constraints = .{ |
| 5983 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 5984 | .{ .exact_remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 5985 | .any, |
| 5986 | }, |
| 5987 | .patterns = &.{ |
| 5988 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 5989 | }, |
| 5990 | .extra_temps = .{ |
| 5991 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 5992 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 5993 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 5994 | .unused, |
| 5995 | .unused, |
| 5996 | .unused, |
| 5997 | .unused, |
| 5998 | .unused, |
| 5999 | .unused, |
| 6000 | .unused, |
| 6001 | .unused, |
| 6002 | }, |
| 6003 | .dst_temps = .{ .mem, .unused }, |
| 6004 | .clobbers = .{ .eflags = true }, |
| 6005 | .each = .{ .once = &.{ |
| 6006 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| 6007 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 6008 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 6009 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 6010 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp1q, ._, ._ }, |
| 6011 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 6012 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 6013 | .{ ._, ._nc, .j, .@"0f", ._, ._, ._ }, |
| 6014 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 6015 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, |
| 6016 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| 6017 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 6018 | .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| 6019 | } }, |
| 6020 | }, .{ |
| 6021 | .required_features = .{ .@"64bit", null, null, null }, |
| 6022 | .src_constraints = .{ |
| 6023 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| 6024 | .{ .remainder_signed_int = .{ .of = .xword, .is = .qword } }, |
| 6025 | .any, |
| 6026 | }, |
| 6027 | .patterns = &.{ |
| 6028 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6029 | }, |
| 6030 | .extra_temps = .{ |
| 6031 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 6032 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 6033 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 6034 | .unused, |
| 6035 | .unused, |
| 6036 | .unused, |
| 6037 | .unused, |
| 6038 | .unused, |
| 6039 | .unused, |
| 6040 | .unused, |
| 6041 | .unused, |
| 6042 | }, |
| 6043 | .dst_temps = .{ .mem, .unused }, |
| 6044 | .clobbers = .{ .eflags = true }, |
| 6045 | .each = .{ .once = &.{ |
| 6046 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| 6047 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 6048 | .{ .@"0:", ._, .mov, .tmp1q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 6049 | .{ ._, ._, .adc, .tmp1q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 6050 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp1q, ._, ._ }, |
| 6051 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 6052 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 6053 | .{ ._, ._l, .sa, .tmp1q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| 6054 | .{ ._, ._, .add, .tmp1q, .tmp1q, ._, ._ }, |
| 6055 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 6056 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 6057 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| 6058 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, |
| 6059 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 6060 | .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ }, |
| 6061 | .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ }, |
| 6062 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ }, |
| 6063 | .{ .@"0:", ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| 6064 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ }, |
| 6065 | } }, |
| 6066 | }, .{ |
| 6067 | .required_features = .{ .@"64bit", null, null, null }, |
| 6068 | .src_constraints = .{ |
| 6069 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 6070 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .qword } }, |
| 6071 | .any, |
| 6072 | }, |
| 6073 | .patterns = &.{ |
| 6074 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6075 | }, |
| 6076 | .extra_temps = .{ |
| 6077 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 6078 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 6079 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 6080 | .unused, |
| 6081 | .unused, |
| 6082 | .unused, |
| 6083 | .unused, |
| 6084 | .unused, |
| 6085 | .unused, |
| 6086 | .unused, |
| 6087 | .unused, |
| 6088 | }, |
| 6089 | .dst_temps = .{ .mem, .unused }, |
| 6090 | .clobbers = .{ .eflags = true }, |
| 6091 | .each = .{ .once = &.{ |
| 6092 | .{ ._, ._, .mov, .tmp0p, .sia(1, .src0, .sub_size_div_8), ._, ._ }, |
| 6093 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| 6094 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 6095 | .{ .@"0:", ._, .mov, .tmp2q, .memsiad(.src0q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 6096 | .{ ._, ._, .adc, .tmp2q, .memsiad(.src1q, .@"8", .tmp0, .add_size, -8), ._, ._ }, |
| 6097 | .{ ._, ._, .mov, .memsiad(.dst0q, .@"8", .tmp0, .add_size, -8), .tmp2q, ._, ._ }, |
| 6098 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 6099 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 6100 | .{ ._, ._, .cmp, .tmp2q, .tmp1q, ._, ._ }, |
| 6101 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, |
| 6102 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -16), .tmp1q, ._, ._ }, |
| 6103 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 6104 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, |
| 6105 | .{ ._, ._, .mov, .tmp2d, .sia(-2, .src0, .add_size_div_8), ._, ._ }, |
| 6106 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 6107 | .{ .@"0:", ._, .mov, .memad(.dst0q, .add_size, -8), .si(0), ._, ._ }, |
| 6108 | } }, |
| 6109 | }, .{ |
| 6110 | .required_features = .{ .@"64bit", null, null, null }, |
| 6111 | .src_constraints = .{ |
| 6112 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| 6113 | .{ .remainder_signed_int = .{ .of = .xword, .is = .xword } }, |
| 6114 | .any, |
| 6115 | }, |
| 6116 | .patterns = &.{ |
| 6117 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6118 | }, |
| 6119 | .extra_temps = .{ |
| 6120 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 6121 | .{ .type = .i64, .kind = .{ .reg = .rax } }, |
| 6122 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 6123 | .unused, |
| 6124 | .unused, |
| 6125 | .unused, |
| 6126 | .unused, |
| 6127 | .unused, |
| 6128 | .unused, |
| 6129 | .unused, |
| 6130 | .unused, |
| 6131 | }, |
| 6132 | .dst_temps = .{ .mem, .unused }, |
| 6133 | .clobbers = .{ .eflags = true }, |
| 6134 | .each = .{ .once = &.{ |
| 6135 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| 6136 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 6137 | .{ .@"0:", ._, .mov, .tmp1q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 6138 | .{ ._, ._, .adc, .tmp1q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 6139 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp1q, ._, ._ }, |
| 6140 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 6141 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 6142 | .{ ._, ._l, .sa, .tmp1q, .uia(63, .src0, .sub_bit_size_rem_64), ._, ._ }, |
| 6143 | .{ ._, ._, .add, .tmp1q, .tmp1q, ._, ._ }, |
| 6144 | .{ ._, ._no, .j, .@"0f", ._, ._, ._ }, |
| 6145 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 6146 | .{ ._, ._r, .sa, .tmp1q, .ui(63), ._, ._ }, |
| 6147 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| 6148 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 6149 | .{ ._, ._, .mov, .tmp2q, .ua(.src0, .add_smin), ._, ._ }, |
| 6150 | .{ ._, ._, .xor, .tmp1q, .tmp2q, ._, ._ }, |
| 6151 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ }, |
| 6152 | } }, |
| 6153 | }, .{ |
| 6154 | .required_features = .{ .@"64bit", null, null, null }, |
| 6155 | .src_constraints = .{ |
| 6156 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| 6157 | .{ .remainder_unsigned_int = .{ .of = .xword, .is = .xword } }, |
| 6158 | .any, |
| 6159 | }, |
| 6160 | .patterns = &.{ |
| 6161 | .{ .src = .{ .to_mem, .to_mem, .none } }, |
| 6162 | }, |
| 6163 | .extra_temps = .{ |
| 6164 | .{ .type = .isize, .kind = .{ .reg = .rdi } }, |
| 6165 | .{ .type = .u64, .kind = .{ .reg = .rax } }, |
| 6166 | .{ .type = .u64, .kind = .{ .reg = .rcx } }, |
| 6167 | .unused, |
| 6168 | .unused, |
| 6169 | .unused, |
| 6170 | .unused, |
| 6171 | .unused, |
| 6172 | .unused, |
| 6173 | .unused, |
| 6174 | .unused, |
| 6175 | }, |
| 6176 | .dst_temps = .{ .mem, .unused }, |
| 6177 | .clobbers = .{ .eflags = true }, |
| 6178 | .each = .{ .once = &.{ |
| 6179 | .{ ._, ._, .mov, .tmp0p, .sa(.src0, .sub_size_div_8), ._, ._ }, |
| 6180 | .{ ._, ._, .mov, .tmp1q, .ua(.src0, .add_umax), ._, ._ }, |
| 6181 | .{ ._, ._c, .cl, ._, ._, ._, ._ }, |
| 6182 | .{ .@"0:", ._, .mov, .tmp2q, .memsia(.src0q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 6183 | .{ ._, ._, .adc, .tmp2q, .memsia(.src1q, .@"8", .tmp0, .add_size), ._, ._ }, |
| 6184 | .{ ._, ._, .mov, .memsia(.dst0q, .@"8", .tmp0, .add_size), .tmp2q, ._, ._ }, |
| 6185 | .{ ._, ._c, .in, .tmp0p, ._, ._, ._ }, |
| 6186 | .{ ._, ._nz, .j, .@"0b", ._, ._, ._ }, |
| 6187 | .{ ._, ._, .cmp, .tmp2q, .tmp1q, ._, ._ }, |
| 6188 | .{ ._, ._na, .j, .@"0f", ._, ._, ._ }, |
| 6189 | .{ ._, ._, .mov, .memad(.dst0q, .add_size, -8), .tmp1q, ._, ._ }, |
| 6190 | .{ ._, ._, .lea, .tmp0p, .mem(.dst0), ._, ._ }, |
| 6191 | .{ ._, ._, .mov, .tmp1q, .si(-1), ._, ._ }, |
| 6192 | .{ ._, ._, .mov, .tmp2d, .sia(-1, .src0, .add_size_div_8), ._, ._ }, |
| 6193 | .{ ._, .@"rep _sq", .sto, ._, ._, ._, ._ }, |
| 6194 | } }, |
| 6195 | } }) catch |err| switch (err) { |
| 6196 | error.SelectFailed => return cg.fail("failed to select {s} {} {} {}", .{ |
| 6197 | @tagName(air_tag), |
| 6198 | cg.typeOf(bin_op.lhs).fmt(pt), |
| 6199 | ops[0].tracking(cg), |
| 6200 | ops[1].tracking(cg), |
| 6201 | }), |
| 6202 | else => |e| return e, |
| 6203 | }; |
| 6204 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 6205 | }, |
| 4349 | 6206 | .sub, .sub_optimized, .sub_wrap => |air_tag| if (use_old) try cg.airBinOp(inst, switch (air_tag) { |
| 4350 | 6207 | else => unreachable, |
| 4351 | 6208 | .sub, .sub_optimized => .sub, |
| ... | ... | @@ -119854,6 +121711,7 @@ const Select = struct { |
| 119854 | 121711 | const add_elem_limbs: Adjust = .{ .sign = .pos, .lhs = .elem_limbs, .op = .mul, .rhs = .@"1" }; |
| 119855 | 121712 | const add_smin: Adjust = .{ .sign = .pos, .lhs = .smin, .op = .mul, .rhs = .@"1" }; |
| 119856 | 121713 | const sub_smin: Adjust = .{ .sign = .neg, .lhs = .smin, .op = .mul, .rhs = .@"1" }; |
| 121714 | const add_smax: Adjust = .{ .sign = .pos, .lhs = .smax, .op = .mul, .rhs = .@"1" }; |
| 119857 | 121715 | const add_umax: Adjust = .{ .sign = .pos, .lhs = .umax, .op = .mul, .rhs = .@"1" }; |
| 119858 | 121716 | const sub_umax: Adjust = .{ .sign = .neg, .lhs = .umax, .op = .mul, .rhs = .@"1" }; |
| 119859 | 121717 | const add_umax_shr_src1: Adjust = .{ .sign = .pos, .lhs = .umax_shr_src1, .op = .mul, .rhs = .@"1" }; |
Jacob Young <jacobly@ziglang.org> 2025-05-10 01:55:25-04:00