| ... | @@ -2408,7 +2408,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2408,7 +2408,7 @@ fn genBodyBlock(self: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2408 | } | 2408 | } |
| 2409 | | 2409 | |
| 2410 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | 2410 | fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2411 | @setEvalBranchQuota(15_800); | 2411 | @setEvalBranchQuota(15_900); |
| 2412 | const pt = cg.pt; | 2412 | const pt = cg.pt; |
| 2413 | const zcu = pt.zcu; | 2413 | const zcu = pt.zcu; |
| 2414 | const ip = &zcu.intern_pool; | 2414 | const ip = &zcu.intern_pool; |
| ... | @@ -2444,7 +2444,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -2444,7 +2444,6 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 2444 | try cg.inst_tracking.ensureUnusedCapacity(cg.gpa, 1); | 2444 | try cg.inst_tracking.ensureUnusedCapacity(cg.gpa, 1); |
| 2445 | switch (air_tags[@intFromEnum(inst)]) { | 2445 | switch (air_tags[@intFromEnum(inst)]) { |
| 2446 | // zig fmt: off | 2446 | // zig fmt: off |
| 2447 | .add_sat => try cg.airAddSat(inst), | | |
| 2448 | .sub_sat => try cg.airSubSat(inst), | 2447 | .sub_sat => try cg.airSubSat(inst), |
| 2449 | .mul_sat => try cg.airMulSat(inst), | 2448 | .mul_sat => try cg.airMulSat(inst), |
| 2450 | .shl_sat => try cg.airShlSat(inst), | 2449 | .shl_sat => try cg.airShlSat(inst), |
| ... | @@ -4346,6 +4345,1864 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { | ... | @@ -4346,6 +4345,1864 @@ fn genBody(cg: *CodeGen, body: []const Air.Inst.Index) InnerError!void { |
| 4346 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); | 4345 | try res[0].finish(inst, &.{ bin_op.lhs, bin_op.rhs }, &ops, cg); |
| 4347 | }, | 4346 | }, |
| 4348 | .add_safe => unreachable, | 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 | .sub, .sub_optimized, .sub_wrap => |air_tag| if (use_old) try cg.airBinOp(inst, switch (air_tag) { | 6206 | .sub, .sub_optimized, .sub_wrap => |air_tag| if (use_old) try cg.airBinOp(inst, switch (air_tag) { |
| 4350 | else => unreachable, | 6207 | else => unreachable, |
| 4351 | .sub, .sub_optimized => .sub, | 6208 | .sub, .sub_optimized => .sub, |
| ... | @@ -119854,6 +121711,7 @@ const Select = struct { | ... | @@ -119854,6 +121711,7 @@ const Select = struct { |
| 119854 | const add_elem_limbs: Adjust = .{ .sign = .pos, .lhs = .elem_limbs, .op = .mul, .rhs = .@"1" }; | 121711 | const add_elem_limbs: Adjust = .{ .sign = .pos, .lhs = .elem_limbs, .op = .mul, .rhs = .@"1" }; |
| 119855 | const add_smin: Adjust = .{ .sign = .pos, .lhs = .smin, .op = .mul, .rhs = .@"1" }; | 121712 | const add_smin: Adjust = .{ .sign = .pos, .lhs = .smin, .op = .mul, .rhs = .@"1" }; |
| 119856 | const sub_smin: Adjust = .{ .sign = .neg, .lhs = .smin, .op = .mul, .rhs = .@"1" }; | 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 | const add_umax: Adjust = .{ .sign = .pos, .lhs = .umax, .op = .mul, .rhs = .@"1" }; | 121715 | const add_umax: Adjust = .{ .sign = .pos, .lhs = .umax, .op = .mul, .rhs = .@"1" }; |
| 119858 | const sub_umax: Adjust = .{ .sign = .neg, .lhs = .umax, .op = .mul, .rhs = .@"1" }; | 121716 | const sub_umax: Adjust = .{ .sign = .neg, .lhs = .umax, .op = .mul, .rhs = .@"1" }; |
| 119859 | const add_umax_shr_src1: Adjust = .{ .sign = .pos, .lhs = .umax_shr_src1, .op = .mul, .rhs = .@"1" }; | 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